epics/pcas
0
0
Fork 0
Code Issues Pull Requests Projects Wiki Activity

jba changes

Browse Source
This commit is contained in:
Janet B. Anderson
1991-02-21 16:48:15 +00:00
parent 34740ae6a8
commit c85106c5ad
5 changed files with 499 additions and 438 deletions
Download Patch File Download Diff File Expand all files Collapse all files

285
src/db/dbAccess.c
View File

@@ -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; i<no_str; i++) {
if(pchoiceSet->papChoice[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; i<no_str; i++) {
pdevChoice=GET_DEV_CHOICE(pdevChoiceSet,i);
if(pdevChoice==NULL || pdevChoice->pchoice==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,

2
src/db/dbEvent.c
View File

@@ -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 <semLib.h>
#include <dbDefs.h>
#include <tsDefs.h>
#include <dbCommon.h>
#include <dbAccess.h>
#include <taskParams.h>

230
src/db/dbTest.c
View File

@@ -1,3 +1,4 @@
/* dbTest.c */
/* share/src/db $Id$ */
@@ -85,7 +86,6 @@
#include <dbPvd.h>
#include <link.h>
#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.<pvname> */
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; i<n; i++, (ptemp_buf+=2), pchar++) {
value = *((unsigned char *)pchar);
sprintf(ptemp_buf,"%-2.2x",value);
}
*ptemp_buf = 0;
sprintf(pmsg, "%s: %s", pfield_name,temp_buf);
dbpr_msgOut(pMsgBuff, tab_size);
}
break;
case DBF_SHORT:
sprintf(pmsg, "%s: %d", pfield_name, *(short *) pLaddr->pfield);
@@ -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) {

413
src/db/db_access.c
View File

@@ -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; i<no_str; i++)
strncpy(poldenum->strs[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; i<no_str; i++)
strncpy(pold->strs[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,

7
src/db/recGbl.c
View File

@@ -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;