From c85106c5adf919b8239a1cb3a44115a0f424d4f4 Mon Sep 17 00:00:00 2001 From: "Janet B. Anderson" Date: Thu, 21 Feb 1991 16:48:15 +0000 Subject: [PATCH] jba changes --- src/db/dbAccess.c | 285 ++++++++++--------------------- src/db/dbEvent.c | 2 +- src/db/dbTest.c | 230 ++++++++++++------------- src/db/db_access.c | 413 ++++++++++++++++++++++++++++++++------------- src/db/recGbl.c | 7 +- 5 files changed, 499 insertions(+), 438 deletions(-) diff --git a/src/db/dbAccess.c b/src/db/dbAccess.c index bbf9154b7..9efd907f7 100644 --- a/src/db/dbAccess.c +++ b/src/db/dbAccess.c @@ -1,3 +1,4 @@ + /* dbAccess.c */ /* share/src/db $Id$ */ @@ -206,7 +207,7 @@ long dbProcess(paddr) struct rset *prset; struct dbCommon *precord=(struct dbCommon *)(paddr->precord); long status; - + /* If already active dont process */ if(precord->pact) { struct rset *prset; @@ -261,7 +262,6 @@ long dbProcess(paddr) /* process record */ status = (*prset->process)(paddr); - return(status); } @@ -418,26 +418,12 @@ long dbBufferSize(dbr_type,options,no_elements) if(options & DBR_PRECISION) nbytes += dbr_precision_size; if(options & DBR_TIME) nbytes += dbr_time_size; if(options & DBR_ENUM_STRS) nbytes += dbr_enumStrs_size; - if(options& - (DBR_GR_UCHAR|DBR_GR_SHORT|DBR_GR_LONG|DBR_GR_ULONG|DBR_GR_FLOAT - |DBR_GR_DOUBLE)) { - if(options & DBR_GR_UCHAR)nbytes += dbr_grUchar_size; - else if(options & DBR_GR_SHORT) nbytes += dbr_grShort_size; - else if(options & DBR_GR_LONG) nbytes += dbr_grLong_size; - else if(options & DBR_GR_ULONG) nbytes += dbr_grUlong_size; - else if(options & DBR_GR_FLOAT) nbytes += dbr_grFloat_size; - else if(options & DBR_GR_DOUBLE)nbytes += dbr_grDouble_size; - } - if(options& - (DBR_CTRL_UCHAR|DBR_CTRL_SHORT|DBR_CTRL_LONG|DBR_CTRL_ULONG|DBR_CTRL_FLOAT - |DBR_CTRL_DOUBLE)) { - if(options & DBR_CTRL_UCHAR) nbytes += dbr_ctrlUchar_size; - else if(options & DBR_CTRL_SHORT)nbytes += dbr_ctrlShort_size; - else if(options & DBR_CTRL_LONG) nbytes += dbr_ctrlLong_size; - else if(options & DBR_CTRL_ULONG)nbytes += dbr_ctrlUlong_size; - else if(options & DBR_CTRL_FLOAT)nbytes += dbr_ctrlFloat_size; - else if(options & DBR_CTRL_DOUBLE)nbytes += dbr_ctrlDouble_size; - } + if(options & DBR_GR_LONG) nbytes += dbr_grLong_size; + if(options & DBR_GR_DOUBLE) nbytes += dbr_grDouble_size; + if(options & DBR_CTRL_LONG) nbytes += dbr_ctrlLong_size; + if(options & DBR_CTRL_DOUBLE)nbytes += dbr_ctrlDouble_size; + if(options & DBR_AL_LONG) nbytes += dbr_alLong_size; + if(options & DBR_AL_DOUBLE) nbytes += dbr_alDouble_size; return(nbytes); } @@ -3007,6 +2993,12 @@ long (*get_convert_table[DBF_DEVCHOICE+1][DBR_ENUM+1])() = { }; +/* forward references for private routines used by dbGetField */ +void get_enum_strs(); +void get_graphics(); +void get_control(); +void get_alarm(); + long dbGetField(paddr,dbrType,pbuffer,options,nRequest) struct dbAddr *paddr; short dbrType; @@ -3021,6 +3013,7 @@ long *nRequest; long (*pconvert_routine)(); struct dbCommon *pcommon; long status; + long *perr_status=NULL; prset=GET_PRSET(paddr->record_type); @@ -3032,6 +3025,8 @@ long *nRequest; if( (*options) & DBR_STATUS ) { *((unsigned short *)pbuffer)++ = pcommon->stat; *((unsigned short *)pbuffer)++ = pcommon->sevr; + perr_status=((long *)pbuffer)++; + *perr_status = 0; } if( (*options) & DBR_UNITS ) { if( prset && prset->get_units ){ @@ -3043,8 +3038,12 @@ long *nRequest; pbuffer += dbr_units_size; } if( (*options) & DBR_PRECISION ) { + struct dbr_precision *pdbr_precision=( struct dbr_precision *)pbuffer; + if((field_type==DBF_FLOAT || field_type==DBF_DOUBLE) && prset && prset->get_precision ){ (*prset->get_precision)(paddr,pbuffer); + if(pdbr_precision->field_width<=0) + pdbr_precision->field_width = pdbr_precision->precision + 5; } else { bzero(pbuffer,dbr_precision_size); *options = (*options) ^ DBR_PRECISION; /*Turn off DBR_PRECISION*/ @@ -3052,17 +3051,16 @@ long *nRequest; pbuffer += dbr_precision_size; } if( (*options) & DBR_TIME ) { - *((unsigned long *)pbuffer)++ = pcommon->esec; - *((unsigned long *)pbuffer)++ = pcommon->nsec; + *((unsigned long *)pbuffer)++ = pcommon->time.secPastEpoch; + *((unsigned long *)pbuffer)++ = pcommon->time.nsec; } - /* get_enum_strs, get_graphics, and get_control follow this procedure*/ if( (*options) & DBR_ENUM_STRS ) get_enum_strs(paddr,&pbuffer,prset,options); - if( (*options) & (DBR_GR_UCHAR | DBR_GR_SHORT | DBR_GR_LONG - | DBR_GR_ULONG | DBR_GR_FLOAT | DBR_GR_DOUBLE )) + if( (*options) & (DBR_GR_LONG|DBR_GR_DOUBLE )) get_graphics(paddr,&pbuffer,prset,options); - if((*options) & (DBR_CTRL_UCHAR | DBR_CTRL_SHORT | DBR_CTRL_LONG - | DBR_CTRL_ULONG | DBR_CTRL_FLOAT | DBR_CTRL_DOUBLE )) + if((*options) & (DBR_CTRL_LONG | DBR_CTRL_DOUBLE )) get_control(paddr,&pbuffer,prset,options); + if((*options) & (DBR_AL_LONG | DBR_AL_DOUBLE )) + get_alarm(paddr,&pbuffer,prset,options); GET_DATA: @@ -3074,6 +3072,7 @@ GET_DATA: sprintf(message,"dbGetField - database request type is %d",dbrType); recGblDbaddrError(S_db_badDbrtype,paddr,message); + if(perr_status) *perr_status = S_db_badDbrtype; return(S_db_badDbrtype); } @@ -3088,20 +3087,21 @@ GET_DATA: sprintf(message,"dbGetField - database request type is %d",dbrType); recGblDbaddrError(S_db_badDbrtype,paddr,message); + if(perr_status) *perr_status = S_db_badDbrtype; return(S_db_badDbrtype); } /* convert database field to buffer type and place it in the buffer */ status=(*pconvert_routine)(paddr,pbuffer,*nRequest,no_elements,offset); + if(perr_status) *perr_status = status; return(status); } -static get_enum_strs(paddr,ppbuffer,prset,options) +static void get_enum_strs(paddr,ppbuffer,prset,options) struct dbAddr *paddr; char **ppbuffer; struct rset *prset; long *options; { - char *pbuffer=*ppbuffer; short field_type=paddr->field_type; struct choiceSet *pchoiceSet; struct arrChoiceSet *parrChoiceSet; @@ -3109,15 +3109,15 @@ long *options; struct devChoiceSet *pdevChoiceSet; unsigned long no_str; char *ptemp; - struct dbr_enumStrs *pdbr_enumStrs; + struct dbr_enumStrs *pdbr_enumStrs=(struct dbr_enumStrs*)(*ppbuffer); int i; + bzero(pdbr_enumStrs,dbr_enumStrs_size); switch(field_type) { case DBF_ENUM: if( prset && prset->get_enum_strs ) { - (*prset->get_enum_strs)(paddr,pbuffer); + (*prset->get_enum_strs)(paddr,pdbr_enumStrs); } else { - bzero(pbuffer,dbr_enumStrs_size); *options = (*options)^DBR_ENUM_STRS;/*Turn off option*/ } break; @@ -3133,14 +3133,13 @@ long *options; pchoiceSet=GET_PCHOICE_SET(parrChoiceSet,paddr->choice_set); choice_common: if(pchoiceSet==NULL) { - bzero(pbuffer,dbr_enumStrs_size); *options = (*options)^DBR_ENUM_STRS;/*Turn off option*/ break; } i = sizeof(pdbr_enumStrs->strs)/sizeof(pdbr_enumStrs->strs[0]); no_str=MIN(pchoiceSet->number,i); - *(unsigned long*)pbuffer = no_str; - ptemp = pbuffer + sizeof(unsigned long); + pdbr_enumStrs->no_str = no_str; + ptemp = &(pdbr_enumStrs->strs[0][0]); for (i=0; ipapChoice[i]==NULL) *ptemp=0; @@ -3153,14 +3152,13 @@ choice_common: pdevChoiceSet=GET_PDEV_CHOICE_SET(choiceDev, paddr->record_type); if(pdevChoiceSet==NULL) { - bzero(pbuffer,dbr_enumStrs_size); *options = (*options)^DBR_ENUM_STRS;/*Turn off option*/ break; } i = sizeof(pdbr_enumStrs->strs)/sizeof(pdbr_enumStrs->strs[0]); no_str=MIN(pdevChoiceSet->number,i); - *(unsigned long*)pbuffer = no_str; - ptemp = pbuffer + sizeof(unsigned long); + pdbr_enumStrs->no_str = no_str; + ptemp = &(pdbr_enumStrs->strs[0][0]); for (i=0; ipchoice==NULL) @@ -3171,7 +3169,6 @@ choice_common: } break; default: - bzero(pbuffer,dbr_enumStrs_size); *options = (*options)^DBR_ENUM_STRS;/*Turn off option*/ break; } @@ -3179,7 +3176,7 @@ choice_common: return; } -static get_graphics(paddr,ppbuffer,prset,options) +static void get_graphics(paddr,ppbuffer,prset,options) struct dbAddr *paddr; char **ppbuffer; struct rset *prset; @@ -3194,49 +3191,6 @@ long *options; (*prset->get_graphic_double)(paddr,&grd); got_data=TRUE; } - if( (*options) & (DBR_GR_UCHAR) ) { - char *pbuffer=*ppbuffer; - - if(got_data) { - struct dbr_grUchar *pgr=(struct dbr_grUchar*)pbuffer; - pgr->upper_disp_limit=MIN(255,MAX(0,grd.upper_disp_limit)); - pgr->lower_disp_limit=MIN(255,MAX(0,grd.lower_disp_limit)); - pgr->upper_alarm_limit=MIN(255,MAX(0,grd.upper_alarm_limit)); - pgr->upper_warning_limit= - MIN(255,MAX(0,grd.upper_warning_limit)); - pgr->lower_warning_limit= - MIN(255,MAX(0,grd.lower_warning_limit)); - pgr->lower_alarm_limit= - MIN(255,MAX(0,grd.lower_alarm_limit)); - } else { - bzero(pbuffer,dbr_grUchar_size); - *options = (*options) ^ DBR_GR_UCHAR; /*Turn off option*/ - } - *ppbuffer += dbr_grUchar_size; - } - if( (*options) & (DBR_GR_SHORT) ) { - char *pbuffer=*ppbuffer; - - if(got_data) { - struct dbr_grShort *pgr=(struct dbr_grShort*)pbuffer; - pgr->upper_disp_limit = - MIN(32767,MAX(-32768,grd.upper_disp_limit)); - pgr->lower_disp_limit = - MIN(32767,MAX(-32768,grd.lower_disp_limit)); - pgr->upper_alarm_limit = - MIN(32767,MAX(-32768,grd.upper_alarm_limit)); - pgr->upper_warning_limit = - MIN(32767,MAX(-32768,grd.upper_warning_limit)); - pgr->lower_warning_limit = - MIN(32767,MAX(-32768,grd.lower_warning_limit)); - pgr->lower_alarm_limit = - MIN(32767,MAX(-32768,grd.lower_alarm_limit)); - } else { - bzero(pbuffer,dbr_grShort_size); - *options = (*options) ^ DBR_GR_SHORT; /*Turn off option*/ - } - *ppbuffer += dbr_grShort_size; - } if( (*options) & (DBR_GR_LONG) ) { char *pbuffer=*ppbuffer; @@ -3244,56 +3198,12 @@ long *options; struct dbr_grLong *pgr=(struct dbr_grLong*)pbuffer; pgr->upper_disp_limit = grd.upper_disp_limit; pgr->lower_disp_limit = grd.lower_disp_limit; - pgr->upper_alarm_limit = grd.upper_alarm_limit; - pgr->upper_warning_limit = grd.upper_warning_limit; - pgr->lower_warning_limit = grd.lower_warning_limit; - pgr->lower_alarm_limit = grd.lower_alarm_limit; } else { bzero(pbuffer,dbr_grLong_size); *options = (*options) ^ DBR_GR_LONG; /*Turn off option*/ } *ppbuffer += dbr_grLong_size; } - if( (*options) & (DBR_GR_ULONG) ) { - char *pbuffer=*ppbuffer; - - if(got_data) { - struct dbr_grUlong *pgr=(struct dbr_grUlong*)pbuffer; - ltemp = grd.upper_disp_limit; - pgr->upper_disp_limit = ltemp; - ltemp = grd.lower_disp_limit; - pgr->lower_disp_limit = ltemp; - ltemp = grd.upper_alarm_limit; - pgr->upper_alarm_limit = ltemp; - ltemp = grd.upper_warning_limit; - pgr->upper_warning_limit = ltemp; - ltemp = grd.lower_warning_limit; - pgr->lower_warning_limit = ltemp; - ltemp = grd.lower_alarm_limit; - pgr->lower_alarm_limit = ltemp; - } else { - bzero(pbuffer,dbr_grUlong_size); - *options = (*options) ^ DBR_GR_ULONG; /*Turn off option*/ - } - *ppbuffer += dbr_grUlong_size; - } - if( (*options) & (DBR_GR_FLOAT) ) { - char *pbuffer=*ppbuffer; - - if(got_data) { - struct dbr_grFloat *pgr=(struct dbr_grFloat*)pbuffer; - pgr->upper_disp_limit = grd.upper_disp_limit; - pgr->lower_disp_limit = grd.lower_disp_limit; - pgr->upper_alarm_limit = grd.upper_alarm_limit; - pgr->upper_warning_limit = grd.upper_warning_limit; - pgr->lower_warning_limit = grd.lower_warning_limit; - pgr->lower_alarm_limit = grd.lower_alarm_limit; - } else { - bzero(pbuffer,dbr_grFloat_size); - *options = (*options) ^ DBR_GR_FLOAT; /*Turn off option*/ - } - *ppbuffer += dbr_grFloat_size; - } if( (*options) & (DBR_GR_DOUBLE) ) { char *pbuffer=*ppbuffer; @@ -3301,10 +3211,6 @@ long *options; struct dbr_grDouble *pgr=(struct dbr_grDouble*)pbuffer; pgr->upper_disp_limit = grd.upper_disp_limit; pgr->lower_disp_limit = grd.lower_disp_limit; - pgr->upper_alarm_limit = grd.upper_alarm_limit; - pgr->upper_warning_limit = grd.upper_warning_limit; - pgr->lower_warning_limit = grd.lower_warning_limit; - pgr->lower_alarm_limit = grd.lower_alarm_limit; } else { bzero(pbuffer,dbr_grDouble_size); *options = (*options) ^ DBR_GR_DOUBLE; /*Turn off option*/ @@ -3314,7 +3220,7 @@ long *options; return; } -static get_control(paddr,ppbuffer,prset,options) +static void get_control(paddr,ppbuffer,prset,options) struct dbAddr *paddr; char **ppbuffer; struct rset *prset; @@ -3329,36 +3235,6 @@ long *options; (*prset->get_control_double)(paddr,&ctrld); got_data=TRUE; } - if( (*options) & (DBR_CTRL_UCHAR) ) { - char *pbuffer=*ppbuffer; - - if(got_data) { - struct dbr_ctrlUchar *pctrl=(struct dbr_ctrlUchar*)pbuffer; - pctrl->upper_ctrl_limit = - MIN(255,MAX(0,ctrld.upper_ctrl_limit)); - pctrl->lower_ctrl_limit = - MIN(255,MAX(0,ctrld.lower_ctrl_limit)); - } else { - bzero(pbuffer,dbr_ctrlUchar_size); - *options = (*options) ^ DBR_CTRL_UCHAR; /*Turn off option*/ - } - *ppbuffer += dbr_ctrlUchar_size; - } - if( (*options) & (DBR_CTRL_SHORT) ) { - char *pbuffer=*ppbuffer; - - if(got_data) { - struct dbr_ctrlShort *pctrl=(struct dbr_ctrlShort*)pbuffer; - pctrl->upper_ctrl_limit = - MIN(32767,MAX(-32768,ctrld.upper_ctrl_limit)); - pctrl->lower_ctrl_limit = - MIN(32767,MAX(-32768,ctrld.lower_ctrl_limit)); - } else { - bzero(pbuffer,dbr_ctrlShort_size); - *options = (*options) ^ DBR_CTRL_SHORT; /*Turn off option*/ - } - *ppbuffer += dbr_ctrlShort_size; - } if( (*options) & (DBR_CTRL_LONG) ) { char *pbuffer=*ppbuffer; @@ -3372,34 +3248,6 @@ long *options; } *ppbuffer += dbr_ctrlLong_size; } - if( (*options) & (DBR_CTRL_ULONG) ) { - char *pbuffer=*ppbuffer; - - if(got_data) { - struct dbr_ctrlUlong *pctrl=(struct dbr_ctrlUlong*)pbuffer; - ltemp = ctrld.upper_ctrl_limit; - pctrl->upper_ctrl_limit = ltemp; - ltemp = ctrld.lower_ctrl_limit; - pctrl->lower_ctrl_limit = ltemp; - } else { - bzero(pbuffer,dbr_ctrlUlong_size); - *options = (*options) ^ DBR_CTRL_ULONG; /*Turn off option*/ - } - *ppbuffer += dbr_ctrlUlong_size; - } - if( (*options) & (DBR_CTRL_FLOAT) ) { - char *pbuffer=*ppbuffer; - - if(got_data) { - struct dbr_ctrlFloat *pctrl=(struct dbr_ctrlFloat*)pbuffer; - pctrl->upper_ctrl_limit = ctrld.upper_ctrl_limit; - pctrl->lower_ctrl_limit = ctrld.lower_ctrl_limit; - } else { - bzero(pbuffer,dbr_ctrlFloat_size); - *options = (*options) ^ DBR_CTRL_FLOAT; /*Turn off option*/ - } - *ppbuffer += dbr_ctrlFloat_size; - } if( (*options) & (DBR_CTRL_DOUBLE) ) { char *pbuffer=*ppbuffer; @@ -3416,6 +3264,54 @@ long *options; return; } +static void get_alarm(paddr,ppbuffer,prset,options) +struct dbAddr *paddr; +char **ppbuffer; +struct rset *prset; +long *options; +{ + short field_type=paddr->field_type; + struct dbr_alDouble ald; + int got_data=FALSE; + long ltemp;/*vxWorks does not support double to unsigned long*/ + + if( prset && prset->get_alarm_double ) { + (*prset->get_alarm_double)(paddr,&ald); + got_data=TRUE; + } + if( (*options) & (DBR_GR_LONG) ) { + char *pbuffer=*ppbuffer; + + if(got_data) { + struct dbr_alLong *pal=(struct dbr_alLong*)pbuffer; + pal->upper_alarm_limit = ald.upper_alarm_limit; + pal->upper_warning_limit = ald.upper_warning_limit; + pal->lower_warning_limit = ald.lower_warning_limit; + pal->lower_alarm_limit = ald.lower_alarm_limit; + } else { + bzero(pbuffer,dbr_alLong_size); + *options = (*options) ^ DBR_AL_LONG; /*Turn off option*/ + } + *ppbuffer += dbr_alLong_size; + } + if( (*options) & (DBR_GR_DOUBLE) ) { + char *pbuffer=*ppbuffer; + + if(got_data) { + struct dbr_alDouble *pal=(struct dbr_alDouble*)pbuffer; + pal->upper_alarm_limit = ald.upper_alarm_limit; + pal->upper_warning_limit = ald.upper_warning_limit; + pal->lower_warning_limit = ald.lower_warning_limit; + pal->lower_alarm_limit = ald.lower_alarm_limit; + } else { + bzero(pbuffer,dbr_alDouble_size); + *options = (*options) ^ DBR_AL_DOUBLE; /*Turn off option*/ + } + *ppbuffer += dbr_alDouble_size; + } + return; +} + /* DATABASE ACCESS PUT CONVERSION SUPPORT */ static long putStringString(paddr,pbuffer,nRequest,no_elements,offset) @@ -3623,9 +3519,6 @@ long offset; return(-1); } -/* The next four routines are not used. I don't think that they should!!!*/ - - static long putStringGchoice(paddr,pbuffer,nRequest,no_elements,offset) struct dbAddr *paddr; char *pbuffer; @@ -5824,7 +5717,7 @@ long (*put_convert_table[DBR_ENUM+1][DBF_DEVCHOICE+1])() = { /* source is a DBR_STRING */ {putStringString, putStringChar, putStringUchar, putStringShort, putStringUshort, putStringLong, putStringUlong, putStringFloat, putStringDouble, putStringEnum, - putStringEnum, putStringEnum, putStringEnum, putStringEnum}, + putStringGchoice,putStringCchoice,putStringRchoice,putStringDchoice}, /* source is a DBR_CHAR */ {putCharString, putCharChar, putCharUchar, putCharShort, putCharUshort, putCharLong, putCharUlong, putCharFloat, putCharDouble, putCharEnum, diff --git a/src/db/dbEvent.c b/src/db/dbEvent.c index 442a23f83..cb1dd472e 100644 --- a/src/db/dbEvent.c +++ b/src/db/dbEvent.c @@ -1,4 +1,3 @@ - /* dbEvent.c */ /* share/src/db $Id$ */ @@ -34,6 +33,7 @@ mrk(anl)07 09-18-90 Made changes for new record and device support #include #include +#include #include #include #include diff --git a/src/db/dbTest.c b/src/db/dbTest.c index da0f88ee0..29db4ecc7 100644 --- a/src/db/dbTest.c +++ b/src/db/dbTest.c @@ -1,3 +1,4 @@ + /* dbTest.c */ /* share/src/db $Id$ */ @@ -85,7 +86,6 @@ #include #include -#define BFSIZE 50 #define MAXLINE 80 struct msgBuff { /* line output structure */ char out_buff[MAXLINE + 1]; @@ -190,6 +190,26 @@ long dbgf(pname) /* get field value*/ } +/* vxWorks 4.x does not support strspn. Here it is*/ +static int strspn(ps,pp) +char *ps; /* pointer to source*/ +char *pp; /* pointer to pattern*/ +{ + int i; + char *p1=ps; + char *p2; + + for (i=0; *p1; i++, p1++) { + for (p2=pp; *p2; p2++) { + if(*p1==*p2) goto ok; + } + return(i); +ok: + continue; + } + return strlen(ps); +} + long dbpf(pname,pvalue) /* put field value*/ char *pname; char *pvalue; @@ -198,12 +218,27 @@ long dbpf(pname,pvalue) /* put field value*/ struct dbAddr addr; long status; + /* make sure value was passed*/ + if(pvalue==0) { + errMessage(0L,"No value was specified"); + return(1); + } status=dbNameToAddr(pname,&addr); if(status) { errMessage(status,"dbNameToAddr error"); return(1); } - status=dbPutField(&addr,DBR_STRING,pvalue,1L); + /* For enumerated types must allow for ENUM rather than string*/ + /* If entire field is digits then use DBR_ENUM else DBR_STRING*/ + if((addr.dbr_field_type==DBR_ENUM) && (*pvalue!=0) + && (strspn(pvalue,"0123456789")==strlen(pvalue))) { + short value; + + sscanf(pvalue,"%hu",&value); + status=dbPutField(&addr,DBR_ENUM,&value,1L); + } else { + status=dbPutField(&addr,DBR_STRING,pvalue,1L); + } if(status) { errMessage(status,"dbPutField error"); return(1); @@ -221,7 +256,6 @@ long dbpr(pname, interest_level) /* print record */ struct dbAddr addr; long status; char *pmsg; - struct rset *prset; int tab_size; pmsg = pMsgBuff->message; @@ -230,12 +264,7 @@ long dbpr(pname, interest_level) /* print record */ status = dbNameToAddr(pname, &addr); printDbAddr(status, &addr); - if (status) - return (1); - if (!(prset = GET_PRSET(addr.record_type))) { - printf("No record Support for this record type\n"); - return (1); - } + if (status) return (1); if (dbpr_report(pname, &addr, interest_level, pMsgBuff, tab_size)) return (1); pmsg[0] = '\0'; @@ -267,7 +296,7 @@ long dbtr(pname) /* test record and print*/ status=dbProcess(&addr); if(!(RTN_SUCCESS(status))) recGblRecSupError(S_db_noSupport,&addr,"dbtr","process"); - dbpr(pname,0); + dbpr(pname,3); return(0); } @@ -677,109 +706,29 @@ static void printBuffer(status, dbr_type, pbuffer, reqOptions, no_strs = *((unsigned long *) pbuffer); printf("no_strs=%lu\n", no_strs); for (i = 0; i < *((unsigned long *) pbuffer); i++) - printf("%s\n", (pbuffer + 4 + i * 26)); + printf("%s\n", (pbuffer + 8 + i * 26)); } else printf("enum strings not returned\n"); pbuffer += dbr_enumStrs_size; } - if (reqOptions & DBR_GR_UCHAR) { - usarr[0] = *((unsigned char *) pbuffer); - usarr[1] = *((unsigned char *) (pbuffer + 1)); - usarr[2] = *((unsigned char *) (pbuffer + 2)); - usarr[3] = *((unsigned char *) (pbuffer + 3)); - usarr[4] = *((unsigned char *) (pbuffer + 4)); - usarr[5] = *((unsigned char *) (pbuffer + 5)); - if (retOptions & DBR_GR_UCHAR) - printf("grUchar: %u %u %u %u %u %u\n", - usarr[0], usarr[1], usarr[2], usarr[3], usarr[4], usarr[5]); - else - printf("DBRgrUchar not returned\n"); - pbuffer += dbr_grUchar_size; - } - if (reqOptions & DBR_GR_SHORT) { - if (retOptions & DBR_GR_SHORT) - printf("grShort: %d %d %d %d %d %d\n", - *(short *) (pbuffer), - *(short *) (pbuffer + 2), - *(short *) (pbuffer + 4), - *(short *) (pbuffer + 6), - *(short *) (pbuffer + 8), - *(short *) (pbuffer + 10)); - else - printf("DBRgrShort not returned\n"); - pbuffer += dbr_grShort_size; - } if (reqOptions & DBR_GR_LONG) { if (retOptions & DBR_GR_LONG) printf("grLong: %ld %ld %ld %ld %ld %ld\n", *(long *) (pbuffer), - *(long *) (pbuffer + 4), - *(long *) (pbuffer + 8), - *(long *) (pbuffer + 12), - *(long *) (pbuffer + 16), - *(long *) (pbuffer + 20)); + *(long *) (pbuffer + 4)); else printf("DBRgrLong not returned\n"); pbuffer += dbr_grLong_size; } - if (reqOptions & DBR_GR_ULONG) { - if (retOptions & DBR_GR_ULONG) - printf("grUlong: %lu %lu %lu %lu %lu %lu\n", - *(unsigned long *) (pbuffer), - *(unsigned long *) (pbuffer + 4), - *(unsigned long *) (pbuffer + 8), - *(unsigned long *) (pbuffer + 12), - *(unsigned long *) (pbuffer + 16), - *(unsigned long *) (pbuffer + 20)); - else - printf("DBRgrUlong not returned\n"); - pbuffer += dbr_grUlong_size; - } - if (reqOptions & DBR_GR_FLOAT) { - if (retOptions & DBR_GR_FLOAT) - printf("grFloat: %g %g %g %g %g %g\n", - *(float *) (pbuffer), - *(float *) (pbuffer + 4), - *(float *) (pbuffer + 8), - *(float *) (pbuffer + 12), - *(float *) (pbuffer + 16), - *(float *) (pbuffer + 20)); - else - printf("DBRgrFloat not returned\n"); - pbuffer += dbr_grFloat_size; - } if (reqOptions & DBR_GR_DOUBLE) { if (retOptions & DBR_GR_DOUBLE) printf("grDouble: %lg %lg %lg %lg %lg %lg\n", *(double *) (pbuffer), - *(double *) (pbuffer + 8), - *(double *) (pbuffer + 16), - *(double *) (pbuffer + 24), - *(double *) (pbuffer + 32), - *(double *) (pbuffer + 40)); + *(double *) (pbuffer + 8)); else printf("DBRgrDouble not returned\n"); pbuffer += dbr_grDouble_size; } - if (reqOptions & DBR_CTRL_UCHAR) { - usarr[0] = *((unsigned char *) pbuffer); - usarr[1] = *((unsigned char *) (pbuffer + 1)); - if (retOptions & DBR_CTRL_UCHAR) - printf("ctrlUchar: %u %u\n", - usarr[0], usarr[1]); - else - printf("DBRctrlUchar not returned\n"); - pbuffer += dbr_ctrlUchar_size; - } - if (reqOptions & DBR_CTRL_SHORT) { - if (retOptions & DBR_CTRL_SHORT) - printf("ctrlShort: %d %d\n", - *(short *) (pbuffer), - *(short *) (pbuffer + 2)); - else - printf("DBRctrlShort not returned\n"); - pbuffer += dbr_ctrlShort_size; - } if (reqOptions & DBR_CTRL_LONG) { if (retOptions & DBR_CTRL_LONG) printf("ctrlLong: %ld %ld\n", @@ -789,24 +738,6 @@ static void printBuffer(status, dbr_type, pbuffer, reqOptions, printf("DBRctrlLong not returned\n"); pbuffer += dbr_ctrlLong_size; } - if (reqOptions & DBR_CTRL_ULONG) { - if (retOptions & DBR_CTRL_ULONG) - printf("ctrlUlong: %lu %lu\n", - *(unsigned long *) (pbuffer), - *(unsigned long *) (pbuffer + 4)); - else - printf("DBRctrlUlong not returned\n"); - pbuffer += dbr_ctrlUlong_size; - } - if (reqOptions & DBR_CTRL_FLOAT) { - if (retOptions & DBR_CTRL_FLOAT) - printf("ctrlFloat: %g %g\n", - *(float *) (pbuffer), - *(float *) (pbuffer + 4)); - else - printf("DBRctrlFloat not returned\n"); - pbuffer += dbr_ctrlFloat_size; - } if (reqOptions & DBR_CTRL_DOUBLE) { if (retOptions & DBR_CTRL_DOUBLE) printf("ctrlDouble: %lg %lg\n", @@ -816,6 +747,28 @@ static void printBuffer(status, dbr_type, pbuffer, reqOptions, printf("DBRctrlDouble not returned\n"); pbuffer += dbr_ctrlDouble_size; } + if (reqOptions & DBR_AL_LONG) { + if (retOptions & DBR_AL_LONG) + printf("alLong: %ld %ld %ld %ld\n", + *(long *) (pbuffer), + *(long *) (pbuffer + 4), + *(long *) (pbuffer + 8), + *(long *) (pbuffer + 12)); + else + printf("DBRalLong not returned\n"); + pbuffer += dbr_alLong_size; + } + if (reqOptions & DBR_AL_DOUBLE) { + if (retOptions & DBR_AL_DOUBLE) + printf("alDouble: %lg %lg %lg %lg\n", + *(double *) (pbuffer), + *(double *) (pbuffer + 8), + *(double *) (pbuffer + 16), + *(double *) (pbuffer + 24)); + else + printf("DBRalDouble not returned\n"); + pbuffer += dbr_alDouble_size; + } /* Now print values */ if (no_elements == 0) return; switch (dbr_type) { @@ -962,6 +915,7 @@ static void printBuffer(status, dbr_type, pbuffer, reqOptions, printf(" illegal request type."); break; } + dbpr_msg_flush(pMsgBuff, tab_size); return; } @@ -989,7 +943,7 @@ static int dbpr_report(pname, paddr, interest_level, pMsgBuff, tab_size) char PvName[PVNAME_SZ + FLDNAME_SZ + 4]; /* recordname. */ short n; long status; - long buffer[BFSIZE]; /* limit array buffer to 1st 50 */ + long buffer[100]; caddr_t pbuffer; long options; long nRequest; @@ -1049,7 +1003,7 @@ static int dbpr_report(pname, paddr, interest_level, pMsgBuff, tab_size) status = dbNameToAddr(pPvName, &Laddr); if (status) return (1); - if (pfldDes->interest >= interest_level ) + if (pfldDes->interest > interest_level ) continue; pLaddr = &Laddr; switch (pfldDes->field_type) { @@ -1082,6 +1036,23 @@ static int dbpr_report(pname, paddr, interest_level, pMsgBuff, tab_size) dbpr_msgOut(pMsgBuff, tab_size); break; case DBF_NOACCESS: + { /* lets just print field in hex */ + char * pchar = (char *)(pLaddr->pfield); + char temp_buf[42]; + char *ptemp_buf = &temp_buf[0]; + short n = pLaddr->field_size; + short i; + unsigned long value; + + if(n>(sizeof(temp_buf)-2)/2) n = (sizeof(temp_buf)-2)/2; + for (i=0; ipfield); @@ -1150,7 +1121,7 @@ static int dbpr_report(pname, paddr, interest_level, pMsgBuff, tab_size) if (pLaddr->field_type != pfldDes->field_type || pLaddr->no_elements > 1) { options = 0; - nRequest = MIN(BFSIZE, pLaddr->no_elements); + nRequest = MIN(pLaddr->no_elements,((sizeof(buffer)*4)/pLaddr->field_size)); status = dbGetField(&Laddr, Laddr.dbr_field_type, pbuffer, &options, &nRequest); printBuffer(status, Laddr.dbr_field_type, pbuffer, @@ -1318,22 +1289,33 @@ static void dbprReportLink(pMsgBuff,pfield_name,plink,field_type, tab_size) dbpr_msgOut(pMsgBuff,tab_size); break; case GPIB_IO: -#if 0 - sprintf(pmsg,"%4s: GPIB link=%2d taddr=%2d laddr=%2d signal=%3d", + sprintf(pmsg,"%4s: GPIB link=%2d addr=%2d parm=%s", pfield_name, - plink->value.gpibio.link, plink->value.gpibio.taddr, - plink->value.gpibio.laddr,plink->value.gpibio.signal); + plink->value.gpibio.link, plink->value.gpibio.addr, + &plink->value.gpibio.parm[0]); dbpr_msgOut(pMsgBuff,tab_size); -#endif break; case BITBUS_IO: -#if 0 - sprintf(pmsg,"%4s: BITBUS link=%2d addr=%2d signal=%3d", + sprintf(pmsg,"%4s: BITBUS link=%2d node=%2d port=%2d signal=%2d parm=%s", pfield_name, - plink->value.bitbusio.link,plink->value.bitbusio.addr, - plink->value.bitbusio.signal); + plink->value.bitbusio.link,plink->value.bitbusio.node, + plink->value.bitbusio.port,plink->value.bitbusio.signal, + &plink->value.bitbusio.parm[0]); + dbpr_msgOut(pMsgBuff,tab_size); + break; + case BBGPIB_IO: + sprintf(pmsg,"%4s: BBGPIBIO link=%2d bbaddr=%2d gpibio=%2d parm=%s", + pfield_name, + plink->value.bbgpibio.link,plink->value.bbgpibio.bbaddr, + plink->value.bbgpibio.gpibaddr, + &plink->value.bbgpibio.parm[0]); + dbpr_msgOut(pMsgBuff,tab_size); + break; + case INST_IO: + sprintf(pmsg,"%4s: INSTIO parm=%s", + pfield_name, + &plink->value.instio.string[0]); dbpr_msgOut(pMsgBuff,tab_size); -#endif break; case DB_LINK: if(field_type != DBF_FWDLINK) { diff --git a/src/db/db_access.c b/src/db/db_access.c index 7d1473d65..425dc8bb3 100644 --- a/src/db/db_access.c +++ b/src/db/db_access.c @@ -1,3 +1,4 @@ + /* db_access.c */ /* share/src/db $Id$ */ /* db_access.c - Interface between old database access and new */ @@ -36,45 +37,109 @@ #define oldDBR_CTRL_FLOAT 11 #define oldDBR_CTRL_ENUM 12 -/* structures needed by db_put_field */ -struct dbr_ctrl_short{ - short status; /* status of value */ - short severity; /* severity of alarm */ - char units[8]; /* units of value */ - short upper_disp_limit; /* upper limit of graph */ - short lower_disp_limit; /* lower limit of graph */ - short upper_alarm_limit; - short upper_warning_limit; - short lower_warning_limit; - short lower_alarm_limit; - short upper_ctrl_limit; /* upper control limit */ - short lower_ctrl_limit; /* lower control limit */ - short value; /* current value */ +/* structures for old database access*/ +/* structure for a string status field */ +struct dbr_sts_string{ + short status; /* status of value */ + short severity; /* severity of alarm */ + char value[MAX_STRING_SIZE]; /* current value */ }; + +/* structure for an integer status field */ +struct dbr_sts_int{ + short status; /* status of value */ + short severity; /* severity of alarm */ + short value; /* current value */ +}; + +/* structure for a float status field */ +struct dbr_sts_float{ + short status; /* status of value */ + short severity; /* severity of alarm */ + float value; /* current value */ +}; + +/* structure for a enum status field */ +struct dbr_sts_enum{ + short status; /* status of value */ + short severity; /* severity of alarm */ + short value; /* current value */ +}; + + + + +/* structure for a graphic integer field */ +struct dbr_gr_int{ + short status; /* status of value */ + short severity; /* severity of alarm */ + char units[8]; /* units of value */ + short upper_disp_limit; /* upper limit of graph */ + short lower_disp_limit; /* lower limit of graph */ + short upper_alarm_limit; + short upper_warning_limit; + short lower_warning_limit; + short lower_alarm_limit; + short value; /* current value */ +}; + +/* structure for a graphic floating point field */ +struct dbr_gr_float{ + short status; /* status of value */ + short severity; /* severity of alarm */ + short precision; /* number of decimal places */ + char units[8]; /* units of value */ + float upper_disp_limit; /* upper limit of graph */ + float lower_disp_limit; /* lower limit of graph */ + float upper_alarm_limit; + float upper_warning_limit; + float lower_warning_limit; + float lower_alarm_limit; + float value; /* current value */ +}; + +/* structure for a control integer */ +struct dbr_ctrl_int{ + short status; /* status of value */ + short severity; /* severity of alarm */ + char units[8]; /* units of value */ + short upper_disp_limit; /* upper limit of graph */ + short lower_disp_limit; /* lower limit of graph */ + short upper_alarm_limit; + short upper_warning_limit; + short lower_warning_limit; + short lower_alarm_limit; + short upper_ctrl_limit; /* upper control limit */ + short lower_ctrl_limit; /* lower control limit */ + short value; /* current value */ +}; + /* structure for a control floating point field */ struct dbr_ctrl_float{ - short status; /* status of value */ - short severity; /* severity of alarm */ - short precision; /* number of decimal places */ - char units[8]; /* units of value */ - float upper_disp_limit; /* upper limit of graph */ - float lower_disp_limit; /* lower limit of graph */ - float upper_alarm_limit; - float upper_warning_limit; - float lower_warning_limit; - float lower_alarm_limit; - float upper_ctrl_limit; /* upper control limit */ - float lower_ctrl_limit; /* lower control limit */ - float value; /* current value */ + short status; /* status of value */ + short severity; /* severity of alarm */ + short precision; /* number of decimal places */ + char units[8]; /* units of value */ + float upper_disp_limit; /* upper limit of graph */ + float lower_disp_limit; /* lower limit of graph */ + float upper_alarm_limit; + float upper_warning_limit; + float lower_warning_limit; + float lower_alarm_limit; + float upper_ctrl_limit; /* upper control limit */ + float lower_ctrl_limit; /* lower control limit */ + float value; /* current value */ }; + /* structure for a control enumeration field */ struct dbr_ctrl_enum{ - short status; /* status of value */ - short severity; /* severity of alarm */ - short no_str; /* number of strings */ - char strs[16][26]; /* state strings */ - short value; /* current value */ + short status; /* status of value */ + short severity; /* severity of alarm */ + short no_str; /* number of strings */ + char strs[16][26]; /* state strings */ + short value; /* current value */ }; + /* From $cs/dblib/src/dbiocsubs.c * subroutines @@ -226,103 +291,223 @@ unsigned short no_elements; status = dbGetField(paddr,DBR_ENUM,pbuffer,&options,&nRequest); break; case(oldDBR_STS_STRING): - options=DBR_STATUS; - nRequest=no_elements; - status = dbGetField(paddr,DBR_STRING,pbuffer,&options,&nRequest); - adjust_severity(pbuffer); + { + struct dbr_sts_string *pold = (struct dbr_sts_string *)pbuffer; + struct { + DBRstatus + } new; + + options=DBR_STATUS; + nRequest=0; + status = dbGetField(paddr,DBR_STRING,&new,&options,&nRequest); + pold->status = new.status; + pold->severity = new.severity; + adjust_severity(pbuffer); + options=0; + nRequest=no_elements; + status = dbGetField(paddr,DBR_STRING,&(pold->value[0]),&options,&nRequest); + } break; case(oldDBR_STS_INT): - options=DBR_STATUS; - nRequest=no_elements; - status = dbGetField(paddr,DBR_SHORT,pbuffer,&options,&nRequest); - adjust_severity(pbuffer); + { + struct dbr_sts_int *pold = (struct dbr_sts_int *)pbuffer; + struct { + DBRstatus + } new; + + options=DBR_STATUS; + nRequest=0; + status = dbGetField(paddr,DBR_SHORT,&new,&options,&nRequest); + pold->status = new.status; + pold->severity = new.severity; + adjust_severity(pbuffer); + options=0; + nRequest=no_elements; + status = dbGetField(paddr,DBR_SHORT,&(pold->value),&options,&nRequest); + } break; case(oldDBR_STS_FLOAT): - options=DBR_STATUS; - nRequest=no_elements; - status = dbGetField(paddr,DBR_FLOAT,pbuffer,&options,&nRequest); - adjust_severity(pbuffer); + { + struct dbr_sts_float *pold = (struct dbr_sts_float *)pbuffer; + struct { + DBRstatus + } new; + + options=DBR_STATUS; + nRequest=0; + status = dbGetField(paddr,DBR_FLOAT,&new,&options,&nRequest); + pold->status = new.status; + pold->severity = new.severity; + adjust_severity(pbuffer); + options=0; + nRequest=no_elements; + status = dbGetField(paddr,DBR_FLOAT,&(pold->value),&options,&nRequest); + } break; case(oldDBR_STS_ENUM): - options=DBR_STATUS; - nRequest=no_elements; - status = dbGetField(paddr,DBR_ENUM,pbuffer,&options,&nRequest); - adjust_severity(pbuffer); + { + struct dbr_sts_enum *pold = (struct dbr_sts_enum *)pbuffer; + struct { + DBRstatus + } new; + + options=DBR_STATUS; + nRequest=0; + status = dbGetField(paddr,DBR_ENUM,&new,&options,&nRequest); + pold->status = new.status; + pold->severity = new.severity; + adjust_severity(pbuffer); + options=0; + nRequest=no_elements; + status = dbGetField(paddr,DBR_ENUM,&(pold->value),&options,&nRequest); + } break; case(oldDBR_GR_INT): - options=DBR_STATUS|DBR_UNITS|DBR_GR_SHORT; - nRequest=no_elements; - status = dbGetField(paddr,DBR_SHORT,pbuffer,&options,&nRequest); - adjust_severity(pbuffer); + { + struct dbr_gr_int *pold = (struct dbr_gr_int *)pbuffer; + struct { + DBRstatus + DBRunits + DBRgrLong + DBRalLong + } new; + + options=DBR_STATUS|DBR_UNITS|DBR_GR_LONG|DBR_AL_LONG; + nRequest=0; + status = dbGetField(paddr,DBR_SHORT,&new,&options,&nRequest); + pold->status = new.status; + pold->severity = new.severity; + adjust_severity(pbuffer); + strncpy(pold->units,new.units,8); + pold->upper_disp_limit = new.upper_disp_limit; + pold->lower_disp_limit = new.lower_disp_limit; + pold->upper_alarm_limit = new.upper_alarm_limit; + pold->upper_warning_limit = new.upper_warning_limit; + pold->lower_warning_limit = new.lower_warning_limit; + pold->lower_alarm_limit = new.lower_alarm_limit; + options=0; + nRequest=no_elements; + status = dbGetField(paddr,DBR_SHORT,&(pold->value),&options,&nRequest); + } break; case(oldDBR_GR_FLOAT): - /* First get status and precision */ - options=DBR_STATUS|DBR_PRECISION; - nRequest=0; - status = dbGetField(paddr,DBR_FLOAT,pbuffer,&options,&nRequest); - adjust_severity(pbuffer); - pbuffer += 2*sizeof(short);/*point pbuffer to precision value*/ - precision = *((long *)pbuffer); - *(((short *)pbuffer)++) = (short)precision; /* convert it to short*/ - /* get units and graphics float*/ - options=DBR_UNITS|DBR_GR_FLOAT; - nRequest=no_elements; - status = dbGetField(paddr,DBR_FLOAT,pbuffer,&options,&nRequest); - if(status!=0) { - /* VMS OPI asks for this for all variables at init. Must return success*/ - float *pb=(float *)pbuffer; + { + struct dbr_gr_float *pold = (struct dbr_gr_float *)pbuffer; + struct { + DBRstatus + DBRunits + DBRprecision + DBRgrDouble + DBRalDouble + } new; - while(nRequest>0) { - *pbuffer++ = 0; - nRequest--; - } - status=0; + options=DBR_STATUS|DBR_UNITS|DBR_PRECISION|DBR_GR_DOUBLE|DBR_AL_DOUBLE; + nRequest=0; + status = dbGetField(paddr,DBR_FLOAT,&new,&options,&nRequest); + pold->status = new.status; + pold->severity = new.severity; + adjust_severity(pbuffer); + pold->precision = new.precision; + strncpy(pold->units,new.units,8); + pold->upper_disp_limit = new.upper_disp_limit; + pold->lower_disp_limit = new.lower_disp_limit; + pold->upper_alarm_limit = new.upper_alarm_limit; + pold->upper_warning_limit = new.upper_warning_limit; + pold->lower_warning_limit = new.lower_warning_limit; + pold->lower_alarm_limit = new.lower_alarm_limit; + options=0; + nRequest=no_elements; + status = dbGetField(paddr,DBR_FLOAT,&(pold->value),&options,&nRequest); } break; case(oldDBR_CTRL_INT): - options=DBR_STATUS|DBR_UNITS|DBR_GR_SHORT|DBR_CTRL_SHORT; - nRequest=no_elements; - status = dbGetField(paddr,DBR_SHORT,pbuffer,&options,&nRequest); - adjust_severity(pbuffer); + { + struct dbr_ctrl_int *pold = (struct dbr_ctrl_int *)pbuffer; + struct { + DBRstatus + DBRunits + DBRgrLong + DBRctrlLong + DBRalLong + } new; + + options=DBR_STATUS|DBR_UNITS|DBR_GR_LONG|DBR_CTRL_LONG|DBR_AL_LONG; + nRequest=0; + status = dbGetField(paddr,DBR_SHORT,&new,&options,&nRequest); + pold->status = new.status; + pold->severity = new.severity; + adjust_severity(pbuffer); + strncpy(pold->units,new.units,8); + pold->upper_disp_limit = new.upper_disp_limit; + pold->lower_disp_limit = new.lower_disp_limit; + pold->upper_alarm_limit = new.upper_alarm_limit; + pold->upper_warning_limit = new.upper_warning_limit; + pold->lower_warning_limit = new.lower_warning_limit; + pold->lower_alarm_limit = new.lower_alarm_limit; + pold->upper_ctrl_limit = new.upper_ctrl_limit; + pold->lower_ctrl_limit = new.lower_ctrl_limit; + options=0; + nRequest=no_elements; + status = dbGetField(paddr,DBR_SHORT,&(pold->value),&options,&nRequest); + } break; case(oldDBR_CTRL_FLOAT): - /* First get status and precision */ - options=DBR_STATUS|DBR_PRECISION; - nRequest=0; - status = dbGetField(paddr,DBR_FLOAT,pbuffer,&options,&nRequest); - adjust_severity(pbuffer); - pbuffer += 2*sizeof(short);/*point pbuffer to precision value*/ - precision = *((long *)pbuffer); - *(((short *)pbuffer)++) = (short)precision; /* convert it to short*/ - /* get units and graphics float and control*/ - options=DBR_UNITS|DBR_GR_FLOAT|DBR_CTRL_FLOAT; - nRequest=no_elements; - status = dbGetField(paddr,DBR_FLOAT,pbuffer,&options,&nRequest); - break; - case(oldDBR_CTRL_ENUM): { - short no_str,i; - struct dbr_enumStrs enumStrs; - struct dbr_ctrl_enum *poldenum=(struct dbr_ctrl_enum *)pbuffer; + { + struct dbr_ctrl_float *pold = (struct dbr_ctrl_float *)pbuffer; + struct { + DBRstatus + DBRunits + DBRprecision + DBRgrDouble + DBRctrlDouble + DBRalDouble + } new; - bzero(pbuffer,sizeof(struct dbr_ctrl_enum)); - /* first get status and severity */ - options=DBR_STATUS; - nRequest=0; - status = dbGetField(paddr,DBR_ENUM,poldenum,&options,&nRequest); - adjust_severity(pbuffer); - /* now get enum strs */ - options=DBR_ENUM_STRS; - nRequest=0; - status = dbGetField(paddr,DBR_ENUM,&enumStrs,&options,&nRequest); - no_str = enumStrs.no_str; - if(no_str>16) no_str=16; - poldenum->no_str = no_str; - for (i=0; istrs[i],&enumStrs.strs[i],sizeof(poldenum->strs[i])); - /*now get values*/ - options=DBR_ENUM_STRS; - nRequest=no_elements; - status = dbGetField(paddr,DBR_ENUM,&poldenum->value,&options,&nRequest); + options=DBR_STATUS|DBR_UNITS|DBR_PRECISION|DBR_GR_DOUBLE|DBR_CTRL_DOUBLE|DBR_AL_DOUBLE; + nRequest=0; + status = dbGetField(paddr,DBR_FLOAT,&new,&options,&nRequest); + pold->status = new.status; + pold->severity = new.severity; + adjust_severity(pbuffer); + pold->precision = new.precision; + strncpy(pold->units,new.units,8); + pold->upper_disp_limit = new.upper_disp_limit; + pold->lower_disp_limit = new.lower_disp_limit; + pold->upper_alarm_limit = new.upper_alarm_limit; + pold->upper_warning_limit = new.upper_warning_limit; + pold->lower_warning_limit = new.lower_warning_limit; + pold->lower_alarm_limit = new.lower_alarm_limit; + pold->upper_ctrl_limit = new.upper_ctrl_limit; + pold->lower_ctrl_limit = new.lower_ctrl_limit; + options=0; + nRequest=no_elements; + status = dbGetField(paddr,DBR_FLOAT,&(pold->value),&options,&nRequest); + } + break; + case(oldDBR_CTRL_ENUM): + { + struct dbr_ctrl_enum *pold = (struct dbr_ctrl_enum *)pbuffer; + struct { + DBRstatus + DBRenumStrs + } new; + short no_str,i; + + bzero(pold,sizeof(struct dbr_ctrl_enum)); + /* first get status and severity */ + options=DBR_STATUS|DBR_ENUM_STRS; + nRequest=0; + status = dbGetField(paddr,DBR_ENUM,&new,&options,&nRequest); + adjust_severity(pold); + no_str = new.no_str; + if(no_str>16) no_str=16; + pold->no_str = no_str; + for (i=0; istrs[i],new.strs[i],sizeof(pold->strs[i])); + /*now get values*/ + options=0; + nRequest=no_elements; + status = dbGetField(paddr,DBR_ENUM,&(pold->value),&options,&nRequest); } break; default: @@ -334,7 +519,7 @@ unsigned short no_elements; /* the old software did not have a severity of INFO */ static adjust_severity(pbuffer) -struct dbr_ctrl_short *pbuffer; +struct dbr_sts_string *pbuffer; { if (pbuffer->severity > 0) pbuffer->severity--; } @@ -364,7 +549,7 @@ char *psrc; /* where to get it from */ break; case(oldDBR_CTRL_INT): status = dbPutField(paddr,DBR_SHORT, - &(((struct dbr_ctrl_short *)psrc)->value),(long)no_elements); + &(((struct dbr_ctrl_int *)psrc)->value),(long)no_elements); break; case(oldDBR_CTRL_FLOAT): status = dbPutField(paddr,DBR_FLOAT, diff --git a/src/db/recGbl.c b/src/db/recGbl.c index a9642bffd..d88597116 100644 --- a/src/db/recGbl.c +++ b/src/db/recGbl.c @@ -1,3 +1,4 @@ + /* recGbl.c - Global record processing routines */ /* share/src/db $Id$ */ @@ -36,7 +37,7 @@ * **************************************************************************/ -recGblDbaddrError(status,paddr,pcaller_name) +void recGblDbaddrError(status,paddr,pcaller_name) long status; struct dbAddr *paddr; char *pcaller_name; /* calling routine name*/ @@ -65,7 +66,7 @@ char *pcaller_name; /* calling routine name*/ return; } -recGblRecordError(status,precord,pcaller_name) +void recGblRecordError(status,precord,pcaller_name) long status; struct dbCommon *precord; char *pcaller_name; /* calling routine name*/ @@ -89,7 +90,7 @@ char *pcaller_name; /* calling routine name*/ return; } -recGblRecSupError(status,paddr,pcaller_name,psupport_name) +void recGblRecSupError(status,paddr,pcaller_name,psupport_name) long status; struct dbAddr *paddr; char *pcaller_name;