LOCAL int connect(void **pab1771IXPvt,DBLINK *plink,boolean *isEng)
{
DBENTRY dbEntry;
DBENTRY *pdbEntry = &dbEntry;
DBADDR dbAddr;
deviceData *pdeviceData;
ab1771IXRecord *precord;
recordPvt *precordPvt;
long status;
char buffer[MAX_BUFFER];
char *recordname = &buffer[0];
char *pstring;
unsigned short signal;
char *pLeftbracket;
char *pRightbracket;
if(plink->type!=INST_IO) return(ab1771IXFatalError);
pstring = plink->value.instio.string;
if(strlen(pstring)>=MAX_BUFFER) return(ab1771IXFatalError);
strcpy(buffer,pstring);
pLeftbracket = strchr(buffer,'['); pRightbracket = strchr(buffer,']');
if(!pLeftbracket || !pRightbracket) {
errlogPrintf("link was not of the form record[signal]\n");
return(ab1771IXFatalError);
}
*pLeftbracket++ = '\0'; *pRightbracket = '\0';
sscanf(pLeftbracket,"%hu",&signal);
dbInitEntry(pdbbase,pdbEntry);
status = dbFindRecord(pdbEntry,recordname);
if(status) return(ab1771IXNoRecord);
if(strcmp(dbGetRecordTypeName(pdbEntry),"ab1771IX")!=0)
return(ab1771IXIllegalRecordType);
dbFinishEntry(pdbEntry);
status = dbNameToAddr(recordname,&dbAddr);
if(status) return(ab1771IXNoRecord);
precord = (ab1771IXRecord *)dbAddr.precord;
if(!(precordPvt = (recordPvt *)precord->dpvt)) {
printf("%s precordPvt is NULL ?\n",precord->name);
return(ab1771IXFatalError);
}
if(signal>=NUM_CHANS) return(ab1771IXIllegalType);
if(signal<=3) {
*isEng = ((precord->typa==ab1771IX_TYPE_MV)?FALSE:TRUE);
} else {
*isEng = ((precord->typb==ab1771IX_TYPE_MV)?FALSE:TRUE);
}
pdeviceData = dbCalloc(1,sizeof(deviceData));
pdeviceData->precord = precord;
pdeviceData->signal = signal;
*pab1771IXPvt = (void *)pdeviceData;
return(ab1771IXOK);
}
static void dbRecordHead(char *recordType,char *name, int visible)
{
DBENTRY *pdbentry;
long status;
pdbentry = dbAllocEntry(pdbbase);
if(ellCount(&tempList))
yyerrorAbort("dbRecordHead: tempList not empty");
allocTemp(pdbentry);
status = dbFindRecordType(pdbentry,recordType);
if(status) {
epicsPrintf("Record \"%s\" is of unknown type \"%s\" - ",
name, recordType);
yyerrorAbort(NULL);
return;
}
/*Duplicate records ok if the same type */
status = dbCreateRecord(pdbentry,name);
if(status==S_dbLib_recExists) {
if(strcmp(recordType,dbGetRecordTypeName(pdbentry))!=0) {
epicsPrintf("Record %s already defined with different type %s\n",
name, dbGetRecordTypeName(pdbentry));
yyerror(NULL);
duplicate = TRUE;
return;
} else if (dbRecordsOnceOnly) {
epicsPrintf("Record \"%s\" already defined (dbRecordsOnceOnly is set)\n",
name);
yyerror(NULL);
duplicate = TRUE;
}
} else if(status) {
epicsPrintf("Can't create record \"%s\" of type \"%s\"\n",
name, recordType);
yyerrorAbort(NULL);
}
if(visible) dbVisibleRecord(pdbentry);
}
/*utility routine to dump raw messages*/
int ab1771IXpm(char *recordname)
{
DBENTRY dbEntry;
DBENTRY *pdbEntry = &dbEntry;
DBADDR dbAddr;
ab1771IXRecord *precord;
recordPvt *precordPvt;
long status;
short *pdata;
int i;
dbInitEntry(pdbbase,pdbEntry);
status = dbFindRecord(pdbEntry,recordname);
if(status) {
printf("Cant find %s\n",recordname);
return(0);
}
if(strcmp(dbGetRecordTypeName(pdbEntry),"ab1771IX")!=0) {
printf("Not a ab1771IXRecord\n");
return(0);
}
dbFinishEntry(pdbEntry);
status = dbNameToAddr(recordname,&dbAddr);
if(status) {
printf("Cant find %s\n",recordname);
return(0);
}
precord = (ab1771IXRecord *)dbAddr.precord;
if(!(precordPvt = (recordPvt *)precord->dpvt)) {
printf("dpvt is NULL\n");
return(0);
}
printf("output message");
pdata = precord->outm;
for(i=0; i< NUM_WORDS_OUT; i++) {
if(i%10 == 0) printf("\n");
printf(" %4hx",*pdata);
pdata++;
}
printf("\ninput message");
pdata = precord->inpm;
for(i=0; i< NUM_WORDS_IN; i++) {
if(i%10 == 0) printf("\n");
printf(" %4hx",*pdata);
pdata++;
}
printf("\n");
return(0);
}
long epicsShareAPI dbnr(int verbose)
{
DBENTRY dbentry;
DBENTRY *pdbentry=&dbentry;
long status;
int nrecords;
int naliases;
int trecords = 0;
int taliases = 0;
if (!pdbbase) {
printf("No database loaded\n");
return 0;
}
dbInitEntry(pdbbase, pdbentry);
status = dbFirstRecordType(pdbentry);
if (status) {
printf("No record types loaded\n");
return 0;
}
printf("Records Aliases Record Type\n");
while (!status) {
naliases = dbGetNAliases(pdbentry);
taliases += naliases;
nrecords = dbGetNRecords(pdbentry) - naliases;
trecords += nrecords;
if (verbose || nrecords)
printf(" %5d %5d %s\n",
nrecords, naliases, dbGetRecordTypeName(pdbentry));
status = dbNextRecordType(pdbentry);
}
dbFinishEntry(pdbentry);
printf("Total %d records, %d aliases\n", trecords, taliases);
return 0;
}
int epicsShareAPI logAlarmsInit (
) {
DBENTRY dbentry;
DBENTRY *pdbentry=&dbentry;
long status;
int numRecords=0;
int tid[MSG_TASK_NUM], btid, ctid, rtid;
int normalRangeSize, overRangeSize;
struct sockaddr_in *psin;
int node;
char string[32];
char *pstring, *serverList, *ptok, *pheader;
int i;
if (initialized) {
errlogPrintf ("logAlarmsInit: already initialized\n");
return ERROR;
}
clkRate = sysClkRateGet();
tickInitWait = (unsigned long)(clkRate * INIT_DELAY_SEC + 0.5);
tickMaxSilent = (unsigned long)(clkRate * BEACON_IDLE_SEC + 0.5);
tickBeaconPeriod = (unsigned long)(clkRate * BEACON_PERIOD_SEC + 0.5);
tickBeaconReplyTmo = (unsigned long)(clkRate * BEACON_REPLY_TMO_SEC + 0.5);
tickMessageReplyTmo = (unsigned long)(clkRate * MESSAGE_REPLY_TMO_SEC + 0.5);
/* wait time between retrying to send messages (>= 1 tick) */
tickMsgRetryWait = (unsigned long)(clkRate * MESSAGE_RETRY_WAIT_SEC + 0.5);
if (tickMsgRetryWait == 0UL) tickMsgRetryWait = 1UL;
if(!pdbbase) {
errlogPrintf ("logAlarmsInit: No database has been loaded\n");
return ERROR;
}
serverList = getenv ("EPICS_ALARM_SERVER_INET");
if (!serverList) {
errlogPrintf ("logAlarmsInit: EPICS_ALARM_SERVER_INET env not defined\n");
return ERROR;
}
pstring = getenv ("EPICS_ALARM_MESSAGE_PORT");
if (!pstring)
msg_port = DEFAULT_MSG_PORT;
else {
msg_port = (unsigned short) atoi (pstring);
if (msg_port < 1024) {
msg_port = DEFAULT_MSG_PORT;
errlogPrintf ("Port number EPICS_ALARM_MESSAGE_PORT is wrong\n");
}
}
pstring = getenv ("EPICS_ALARM_COMMAND_PORT");
if (!pstring)
cmd_port = DEFAULT_CMD_PORT;
else {
cmd_port = (unsigned short) atoi (pstring);
if (cmd_port < 1024) {
cmd_port = DEFAULT_CMD_PORT;
errlogPrintf ("Port number EPICS_ALARM_COMMAND_PORT is wrong\n");
}
}
/* if allAcceptOption is set, commands are accepted from all servers */
pstring = getenv ("EPICS_ALARM_COMMAND_ACCEPT_ALL");
if (strcmp (pstring, "YES") == 0)
allAcceptOption = TRUE;
psin = &msgServerAddr[0];
node = 0;
ptok = strtok_r (serverList, " ", &pstring);
while (ptok && node < SERVERS_MAX && aToIPAddr (ptok, msg_port, psin) == 0) {
node++;
psin++;
ptok = strtok_r (NULL, " ", &pstring);
}
numServersConfigured = node;
if (numServersConfigured == 0) {
errlogPrintf (
"logAlarmsInit: No server correctly defined in EPICS_ALARM_SERVER_INET\n");
}
wakeupSem = semBCreate (SEM_Q_FIFO, SEM_EMPTY);
if (!wakeupSem) {
errlogPrintf ("logAlarmsInit: Reader wakeup semaphore could not be created\n");
return ERROR;
}
bucketSem = semMCreate (SEM_Q_PRIORITY | SEM_DELETE_SAFE | SEM_INVERSION_SAFE);
if (!bucketSem) {
errlogPrintf ("logAlarmsInit: Hash facility mutex could not be created\n");
cleanup (1);
return ERROR;
}
ringSem = semMCreate (SEM_Q_PRIORITY | SEM_DELETE_SAFE | SEM_INVERSION_SAFE);
if (!ringSem) {
errlogPrintf ("logAlarmsInit: Ring r/w mutex could not be created\n");
cleanup (2);
return ERROR;
}
ringWriteSem = semMCreate (SEM_Q_PRIORITY | SEM_DELETE_SAFE | SEM_INVERSION_SAFE);
if (!ringWriteSem) {
errlogPrintf ("logAlarmsInit: Ring (write) mutex could not be created\n");
cleanup (3);
return ERROR;
}
msgSockSem = semMCreate (SEM_Q_PRIORITY | SEM_DELETE_SAFE | SEM_INVERSION_SAFE);
if (!msgSockSem) {
errlogPrintf ("logAlarmsInit: MsgSocket mutex could not be created\n");
cleanup (4);
return ERROR;
}
dbInitEntry(pdbbase,pdbentry);
status = dbFirstRecordType(pdbentry);
while(!status) {
int numRecordsType;
numRecordsType = dbGetNRecords(pdbentry);
DEBUG2(4,"There are %d records of type %s\n",
numRecordsType, dbGetRecordTypeName(pdbentry))
numRecords += numRecordsType;
status = dbNextRecordType(pdbentry);
}
dbFinishEntry(pdbentry);
normalRangeSize = (int)(numRecords * RING_NORMAL_MULTI) + 1;
overRangeSize = numRecords + numRecords / RING_OVER_DIVI + 1;
ringSize = normalRangeSize + overRangeSize;
pRingBottom = (msgBuffer_t *)calloc (ringSize, sizeof(msgBuffer_t));
if (!pRingBottom) {
errlogPrintf ("logAlarmsInit: Ring buffer could not be created\n");
cleanup (5);
return ERROR;
}
pRingTop = pRingBottom + ringSize;
DEBUG2(2,"pRingBottom:%lu pRingTop:%lu\n",
(unsigned long)pRingBottom, (unsigned long)pRingTop)
ringHighWater = normalRangeSize;
DEBUG2(2,"Ring buffer size:%d highwater:%d\n",ringSize,ringHighWater)
pRingRead = pRingBottom;
pRingWrite = pRingBottom;
msgLost = 0;
pbuck = bucketCreate (numRecords);
if (!pbuck) {
errlogPrintf ("logAlarmsInit: Hash table could not be initalized\n");
cleanup (6);
return ERROR;
}
serverSelected = -1;
serverSelectedLast = -1;
queueAllRecords();
/* spawn alarm beacon task */
btid = taskSpawn ("Al'Beacon", BEACON_TASK_PRIO, BEACON_TASK_OPTIONS,
BEACON_TASK_STACK, (FUNCPTR)alarmBeaconTask,0,0,0,0,0,0,0,0,0,0);
if (!btid) {
errlogPrintf ("logAlarmsInit: Beacon task could not be spawned\n");
cleanup (7);
return ERROR;
}
DEBUG1(1,"alarmBeaconTask started. Task-ID = 0x%x\n", btid);
msg_soc = socket (AF_INET, SOCK_DGRAM, 0);
if (msg_soc < 0) {
errlogPrintf ("Message socket create failed\n");
cleanup (7);
return ERROR;
}
bzero ((char *) &msgReplyInAddr, sockAddrSize);
msgReplyInAddr.sin_port = htons(msg_port);
msgReplyInAddr.sin_family = AF_INET;
msgReplyInAddr.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind (msg_soc, (struct sockaddr*)&msgReplyInAddr, sockAddrSize) < 0 ) {
errlogPrintf ("Message socket bind failed\n");
cleanup (8);
return ERROR;
}
cmd_soc = socket (AF_INET, SOCK_DGRAM, 0);
if (cmd_soc < 0) {
errlogPrintf ("Command socket create failed\n");
cleanup (8);
return ERROR;
}
bzero ((char *) &cmdServerAddr, sockAddrSize);
cmdServerAddr.sin_port = htons(cmd_port);
cmdServerAddr.sin_family = AF_INET;
cmdServerAddr.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind (cmd_soc, (struct sockaddr*)&cmdServerAddr, sockAddrSize) < 0 ) {
errlogPrintf ("Command socket bind failed\n");
cleanup (9);
return ERROR;
}
/* spawn alarm message tasks */
for (i=0; i<MSG_TASK_NUM; i++) {
sprintf (string, "Al'Msg%d", i+1);
tid[i] = taskSpawn (string, CLIENT_TASK_PRIO, CLIENT_TASK_OPTIONS,
CLIENT_TASK_STACK, (FUNCPTR)alarmMessageTask,i+1,0,0,0,0,0,0,0,0,0);
if (!tid[i]) {
errlogPrintf (
"logAlarmsInit: Message task %d could not be spawned\n");
cleanup (9);
while (i > 0) taskDelete (tid[--i]);
taskDelete (btid);
return ERROR;
}
}
/* spawn alarm log control (command receiver) server task */
ctid = taskSpawn ("Al'Command", CONTROL_TASK_PRIO, CONTROL_TASK_OPTIONS,
CONTROL_TASK_STACK, (FUNCPTR)alarmCommandTask,0,0,0,0,0,0,0,0,0,0);
if (!ctid) {
errlogPrintf ("logAlarmsInit: Control task could not be spawned\n");
cleanup (9);
taskDelete (btid);
for (i=0; i<MSG_TASK_NUM; i++) taskDelete (tid[i]);
return ERROR;
}
/* spawn message reply receiver task */
rtid = taskSpawn ("Al'ReplyRx", REPLY_TASK_PRIO, REPLY_TASK_OPTIONS,
REPLY_TASK_STACK, (FUNCPTR)replyReceiveTask,0,0,0,0,0,0,0,0,0,0);
if (!rtid) {
errlogPrintf ("logAlarmsInit: Reply receiver task could not be spawned\n");
cleanup (9);
taskDelete (btid);
taskDelete (ctid);
for (i=0; i<MSG_TASK_NUM; i++) taskDelete (tid[i]);
return ERROR;
}
pheader = messageHeader;
pstring = getenv ("EPICS_IOC_NAME");
if (pstring) /* given IOC name */
pheader = messageHeader +
sprintf (messageHeader, "HOST=%s;", pstring);
pheader +=
sprintf (pheader, "HOST-PHYS=%s;APPLICATION=logAlarms;",
gethostname (string, sizeof(string)) ? "TOO_LONG" : string);
pstring = getenv ("EPICS_FACILITY");
if (pstring) /* name of application facility */
pheader +=
sprintf (pheader, "FACILITY=%s;", pstring);
/* calculate the remaining space in the message string */
textMsgSize = MAX_MESSAGE_LENGTH - (pheader-messageHeader);
epicsPrintf("logAlarms started\n");
recGblAlarmHook = (RECGBL_ALARM_HOOK_ROUTINE)logEvent;
DEBUG1(3,"recGblAlarmHook = 0x%lx\n",(unsigned long)recGblAlarmHook)
initialized = TRUE;
return OK;
}
long epicsShareAPI dbl(const char *precordTypename, const char *fields)
{
DBENTRY dbentry;
DBENTRY *pdbentry=&dbentry;
long status;
int nfields = 0;
int ifield;
char *fieldnames = 0;
char **papfields = 0;
if (!pdbbase) {
printf("No database loaded\n");
return 0;
}
if (precordTypename &&
((*precordTypename == '\0') || !strcmp(precordTypename,"*")))
precordTypename = NULL;
if (fields && (*fields == '\0'))
fields = NULL;
if (fields) {
char *pnext;
fieldnames = epicsStrDup(fields);
nfields = 1;
pnext = fieldnames;
while (*pnext && (pnext = strchr(pnext,' '))) {
nfields++;
while (*pnext == ' ') pnext++;
}
papfields = dbCalloc(nfields,sizeof(char *));
pnext = fieldnames;
for (ifield = 0; ifield < nfields; ifield++) {
papfields[ifield] = pnext;
if (ifield < nfields - 1) {
pnext = strchr(pnext, ' ');
*pnext++ = 0;
while (*pnext == ' ') pnext++;
}
}
}
dbInitEntry(pdbbase, pdbentry);
if (!precordTypename)
status = dbFirstRecordType(pdbentry);
else
status = dbFindRecordType(pdbentry,precordTypename);
if (status) {
printf("No record type\n");
}
while (!status) {
status = dbFirstRecord(pdbentry);
while (!status) {
printf("%s", dbGetRecordName(pdbentry));
for (ifield = 0; ifield < nfields; ifield++) {
char *pvalue;
status = dbFindField(pdbentry, papfields[ifield]);
if (status) {
if (!strcmp(papfields[ifield], "recordType")) {
pvalue = dbGetRecordTypeName(pdbentry);
}
else {
printf(", ");
continue;
}
}
else {
pvalue = dbGetString(pdbentry);
}
printf(", \"%s\"", pvalue ? pvalue : "");
}
printf("\n");
status = dbNextRecord(pdbentry);
}
if (precordTypename)
break;
status = dbNextRecordType(pdbentry);
}
if (nfields > 0) {
free((void *)papfields);
free((void *)fieldnames);
}
dbFinishEntry(pdbentry);
return 0;
}
static long dbReadCOM(DBBASE **ppdbbase,const char *filename, FILE *fp,
const char *path,const char *substitutions)
{
long status;
inputFile *pinputFile = NULL;
char *penv;
char **macPairs;
if(*ppdbbase == 0) *ppdbbase = dbAllocBase();
pdbbase = *ppdbbase;
if(path && strlen(path)>0) {
dbPath(pdbbase,path);
} else {
penv = getenv("EPICS_DB_INCLUDE_PATH");
if(penv) {
dbPath(pdbbase,penv);
} else {
dbPath(pdbbase,".");
}
}
my_buffer = dbCalloc(MY_BUFFER_SIZE,sizeof(char));
freeListInitPvt(&freeListPvt,sizeof(tempListNode),100);
if(substitutions) {
if(macCreateHandle(&macHandle,NULL)) {
epicsPrintf("macCreateHandle error\n");
status = -1;
goto cleanup;
}
macParseDefns(macHandle,(char *)substitutions,&macPairs);
if(macPairs ==NULL) {
macDeleteHandle(macHandle);
macHandle = NULL;
} else {
macInstallMacros(macHandle,macPairs);
free((void *)macPairs);
mac_input_buffer = dbCalloc(MY_BUFFER_SIZE,sizeof(char));
}
}
pinputFile = dbCalloc(1,sizeof(inputFile));
if(filename) {
pinputFile->filename = macEnvExpand(filename);
}
if(!fp) {
FILE *fp1;
if(pinputFile->filename) pinputFile->path = dbOpenFile(pdbbase,pinputFile->filename,&fp1);
if(!pinputFile->filename || !fp1) {
errPrintf(0,__FILE__, __LINE__,
"dbRead opening file %s",pinputFile->filename);
free((void *)pinputFile->filename);
free((void *)pinputFile);
status = -1;
goto cleanup;
}
pinputFile->fp = fp1;
} else {
pinputFile->fp = fp;
}
pinputFile->line_num = 0;
pinputFileNow = pinputFile;
my_buffer[0] = '\0';
my_buffer_ptr = my_buffer;
ellAdd(&inputFileList,&pinputFile->node);
status = pvt_yy_parse();
dbFreePath(pdbbase);
if(!status) { /*add RTYP and VERS as an attribute */
DBENTRY dbEntry;
DBENTRY *pdbEntry = &dbEntry;
long localStatus;
dbInitEntry(pdbbase,pdbEntry);
localStatus = dbFirstRecordType(pdbEntry);
while(!localStatus) {
localStatus = dbPutRecordAttribute(pdbEntry,"RTYP",
dbGetRecordTypeName(pdbEntry));
if(!localStatus) {
localStatus = dbPutRecordAttribute(pdbEntry,"VERS",
"none specified");
}
if(localStatus) {
fprintf(stderr,"dbPutRecordAttribute status %ld\n",status);
} else {
localStatus = dbNextRecordType(pdbEntry);
}
}
dbFinishEntry(pdbEntry);
}
cleanup:
if(macHandle) macDeleteHandle(macHandle);
macHandle = NULL;
if(mac_input_buffer) free((void *)mac_input_buffer);
mac_input_buffer = NULL;
if(freeListPvt) freeListCleanup(freeListPvt);
freeListPvt = NULL;
if(my_buffer) free((void *)my_buffer);
my_buffer = NULL;
freeInputFileList();
return(status);
}
/* Performs the work of the public db_get_field API, but also returns the number
* of elements actually copied to the buffer. The caller is responsible for
* zeroing the remaining part of the buffer. */
int dbChannel_get_count(
struct dbChannel *chan, int buffer_type,
void *pbuffer, long *nRequest, void *pfl)
{
long status;
long options;
long i;
long zero = 0;
/* The order of the DBR* elements in the "newSt" structures below is
* very important and must correspond to the order of processing
* in the dbAccess.c dbGet() and getOptions() routines.
*/
dbScanLock(dbChannelRecord(chan));
switch(buffer_type) {
case(oldDBR_STRING):
status = dbChannelGet(chan, DBR_STRING, pbuffer, &zero, nRequest, pfl);
break;
/* case(oldDBR_INT): */
case(oldDBR_SHORT):
status = dbChannelGet(chan, DBR_SHORT, pbuffer, &zero, nRequest, pfl);
break;
case(oldDBR_FLOAT):
status = dbChannelGet(chan, DBR_FLOAT, pbuffer, &zero, nRequest, pfl);
break;
case(oldDBR_ENUM):
status = dbChannelGet(chan, DBR_ENUM, pbuffer, &zero, nRequest, pfl);
break;
case(oldDBR_CHAR):
status = dbChannelGet(chan, DBR_CHAR, pbuffer, &zero, nRequest, pfl);
break;
case(oldDBR_LONG):
status = dbChannelGet(chan, DBR_LONG, pbuffer, &zero, nRequest, pfl);
break;
case(oldDBR_DOUBLE):
status = dbChannelGet(chan, DBR_DOUBLE, pbuffer, &zero, nRequest, pfl);
break;
case(oldDBR_STS_STRING):
case(oldDBR_GR_STRING):
case(oldDBR_CTRL_STRING):
{
struct dbr_sts_string *pold = (struct dbr_sts_string *)pbuffer;
struct {
DBRstatus
} newSt;
options = DBR_STATUS;
status = dbChannelGet(chan, DBR_STRING, &newSt, &options, &zero, pfl);
pold->status = newSt.status;
pold->severity = newSt.severity;
status = dbChannelGet(chan, DBR_STRING, pold->value, &zero,
nRequest, pfl);
}
break;
/* case(oldDBR_STS_INT): */
case(oldDBR_STS_SHORT):
{
struct dbr_sts_int *pold = (struct dbr_sts_int *)pbuffer;
struct {
DBRstatus
} newSt;
options = DBR_STATUS;
status = dbChannelGet(chan, DBR_SHORT, &newSt, &options, &zero, pfl);
pold->status = newSt.status;
pold->severity = newSt.severity;
status = dbChannelGet(chan, DBR_SHORT, &pold->value, &zero,
nRequest, pfl);
}
break;
case(oldDBR_STS_FLOAT):
{
struct dbr_sts_float *pold = (struct dbr_sts_float *)pbuffer;
struct {
DBRstatus
} newSt;
options = DBR_STATUS;
status = dbChannelGet(chan, DBR_FLOAT, &newSt, &options, &zero, pfl);
pold->status = newSt.status;
pold->severity = newSt.severity;
status = dbChannelGet(chan, DBR_FLOAT, &pold->value, &zero,
nRequest, pfl);
}
break;
case(oldDBR_STS_ENUM):
{
struct dbr_sts_enum *pold = (struct dbr_sts_enum *)pbuffer;
struct {
DBRstatus
} newSt;
options = DBR_STATUS;
status = dbChannelGet(chan, DBR_ENUM, &newSt, &options, &zero, pfl);
pold->status = newSt.status;
pold->severity = newSt.severity;
status = dbChannelGet(chan, DBR_ENUM, &pold->value, &zero,
nRequest, pfl);
}
break;
case(oldDBR_STS_CHAR):
{
struct dbr_sts_char *pold = (struct dbr_sts_char *)pbuffer;
struct {
DBRstatus
} newSt;
options = DBR_STATUS;
status = dbChannelGet(chan, DBR_UCHAR, &newSt, &options, &zero, pfl);
pold->status = newSt.status;
pold->severity = newSt.severity;
status = dbChannelGet(chan, DBR_UCHAR, &pold->value, &zero,
nRequest, pfl);
}
break;
case(oldDBR_STS_LONG):
{
struct dbr_sts_long *pold = (struct dbr_sts_long *)pbuffer;
struct {
DBRstatus
} newSt;
options = DBR_STATUS;
status = dbChannelGet(chan, DBR_LONG, &newSt, &options, &zero, pfl);
pold->status = newSt.status;
pold->severity = newSt.severity;
status = dbChannelGet(chan, DBR_LONG, &pold->value, &zero,
nRequest, pfl);
}
break;
case(oldDBR_STS_DOUBLE):
{
struct dbr_sts_double *pold = (struct dbr_sts_double *)pbuffer;
struct {
DBRstatus
} newSt;
options = DBR_STATUS;
status = dbChannelGet(chan, DBR_DOUBLE, &newSt, &options, &zero, pfl);
pold->status = newSt.status;
pold->severity = newSt.severity;
options = 0;
status = dbChannelGet(chan, DBR_DOUBLE, &pold->value, &options,
nRequest, pfl);
}
break;
case(oldDBR_TIME_STRING):
{
struct dbr_time_string *pold = (struct dbr_time_string *)pbuffer;
struct {
DBRstatus
DBRtime
} newSt;
options = DBR_STATUS | DBR_TIME;
status = dbChannelGet(chan, DBR_STRING, &newSt, &options, &zero, pfl);
pold->status = newSt.status;
pold->severity = newSt.severity;
pold->stamp = newSt.time; /* structure copy */
options = 0;
status = dbChannelGet(chan, DBR_STRING, pold->value, &options,
nRequest, pfl);
}
break;
/* case(oldDBR_TIME_INT): */
case(oldDBR_TIME_SHORT):
{
struct dbr_time_short *pold = (struct dbr_time_short *)pbuffer;
struct {
DBRstatus
DBRtime
} newSt;
options = DBR_STATUS | DBR_TIME;
status = dbChannelGet(chan, DBR_SHORT, &newSt, &options, &zero, pfl);
pold->status = newSt.status;
pold->severity = newSt.severity;
pold->stamp = newSt.time; /* structure copy */
options = 0;
status = dbChannelGet(chan, DBR_SHORT, &pold->value, &options,
nRequest, pfl);
}
break;
case(oldDBR_TIME_FLOAT):
{
struct dbr_time_float *pold = (struct dbr_time_float *)pbuffer;
struct {
DBRstatus
DBRtime
} newSt;
options = DBR_STATUS | DBR_TIME;
status = dbChannelGet(chan, DBR_FLOAT, &newSt, &options, &zero, pfl);
pold->status = newSt.status;
pold->severity = newSt.severity;
pold->stamp = newSt.time; /* structure copy */
options = 0;
status = dbChannelGet(chan, DBR_FLOAT, &pold->value, &options,
nRequest, pfl);
}
break;
case(oldDBR_TIME_ENUM):
{
struct dbr_time_enum *pold = (struct dbr_time_enum *)pbuffer;
struct {
DBRstatus
DBRtime
} newSt;
options = DBR_STATUS | DBR_TIME;
status = dbChannelGet(chan, DBR_ENUM, &newSt, &options, &zero, pfl);
pold->status = newSt.status;
pold->severity = newSt.severity;
pold->stamp = newSt.time; /* structure copy */
options = 0;
status = dbChannelGet(chan, DBR_ENUM, &pold->value, &options,
nRequest, pfl);
}
break;
case(oldDBR_TIME_CHAR):
{
struct dbr_time_char *pold = (struct dbr_time_char *)pbuffer;
struct {
DBRstatus
DBRtime
} newSt;
options = DBR_STATUS | DBR_TIME;
status = dbChannelGet(chan, DBR_CHAR, &newSt, &options, &zero, pfl);
pold->status = newSt.status;
pold->severity = newSt.severity;
pold->stamp = newSt.time; /* structure copy */
options = 0;
status = dbChannelGet(chan, DBR_CHAR, &pold->value, &options,
nRequest, pfl);
}
break;
case(oldDBR_TIME_LONG):
{
struct dbr_time_long *pold = (struct dbr_time_long *)pbuffer;
struct {
DBRstatus
DBRtime
} newSt;
options = DBR_STATUS | DBR_TIME;
status = dbChannelGet(chan, DBR_LONG, &newSt, &options, &zero, pfl);
pold->status = newSt.status;
pold->severity = newSt.severity;
pold->stamp = newSt.time; /* structure copy */
options = 0;
status = dbChannelGet(chan, DBR_LONG, &pold->value, &options,
nRequest, pfl);
}
break;
case(oldDBR_TIME_DOUBLE):
{
struct dbr_time_double *pold = (struct dbr_time_double *)pbuffer;
struct {
DBRstatus
DBRtime
} newSt;
options = DBR_STATUS | DBR_TIME;
status = dbChannelGet(chan, DBR_DOUBLE, &newSt, &options, &zero, pfl);
pold->status = newSt.status;
pold->severity = newSt.severity;
pold->stamp = newSt.time; /* structure copy */
options = 0;
status = dbChannelGet(chan, DBR_DOUBLE, &pold->value, &options,
nRequest, pfl);
}
break;
/* case(oldDBR_GR_STRING): NOT IMPLEMENTED - use DBR_STS_STRING */
/* case(oldDBR_GR_INT): */
case(oldDBR_GR_SHORT):
{
struct dbr_gr_int *pold = (struct dbr_gr_int *)pbuffer;
struct {
DBRstatus
DBRunits
DBRgrLong
DBRalLong
} newSt;
options = DBR_STATUS | DBR_UNITS | DBR_GR_LONG | DBR_AL_LONG;
status = dbChannelGet(chan, DBR_SHORT, &newSt, &options, &zero, pfl);
pold->status = newSt.status;
pold->severity = newSt.severity;
strncpy(pold->units, newSt.units, MAX_UNITS_SIZE);
pold->units[MAX_UNITS_SIZE-1] = '\0';
pold->upper_disp_limit = newSt.upper_disp_limit;
pold->lower_disp_limit = newSt.lower_disp_limit;
pold->upper_alarm_limit = newSt.upper_alarm_limit;
pold->upper_warning_limit = newSt.upper_warning_limit;
pold->lower_warning_limit = newSt.lower_warning_limit;
pold->lower_alarm_limit = newSt.lower_alarm_limit;
options = 0;
status = dbChannelGet(chan, DBR_SHORT, &pold->value, &options,
nRequest, pfl);
}
break;
case(oldDBR_GR_FLOAT):
{
struct dbr_gr_float *pold = (struct dbr_gr_float *)pbuffer;
struct {
DBRstatus
DBRunits
DBRprecision
DBRgrDouble
DBRalDouble
} newSt;
options = DBR_STATUS | DBR_UNITS | DBR_PRECISION | DBR_GR_DOUBLE |
DBR_AL_DOUBLE;
status = dbChannelGet(chan, DBR_FLOAT, &newSt, &options, &zero, pfl);
pold->status = newSt.status;
pold->severity = newSt.severity;
pold->precision = (dbr_short_t) newSt.precision.dp;
strncpy(pold->units, newSt.units, MAX_UNITS_SIZE);
pold->units[MAX_UNITS_SIZE-1] = '\0';
pold->upper_disp_limit = epicsConvertDoubleToFloat(newSt.upper_disp_limit);
pold->lower_disp_limit = epicsConvertDoubleToFloat(newSt.lower_disp_limit);
pold->upper_alarm_limit = epicsConvertDoubleToFloat(newSt.upper_alarm_limit);
pold->lower_alarm_limit = epicsConvertDoubleToFloat(newSt.lower_alarm_limit);
pold->upper_warning_limit = epicsConvertDoubleToFloat(newSt.upper_warning_limit);
pold->lower_warning_limit = epicsConvertDoubleToFloat(newSt.lower_warning_limit);
options = 0;
status = dbChannelGet(chan, DBR_FLOAT, &pold->value, &options,
nRequest, pfl);
}
break;
/* case(oldDBR_GR_ENUM): see oldDBR_CTRL_ENUM */
case(oldDBR_GR_CHAR):
{
struct dbr_gr_char *pold = (struct dbr_gr_char *)pbuffer;
struct {
DBRstatus
DBRunits
DBRgrLong
DBRalLong
} newSt;
options = DBR_STATUS | DBR_UNITS | DBR_GR_LONG | DBR_AL_LONG;
status = dbChannelGet(chan, DBR_UCHAR, &newSt, &options, &zero, pfl);
pold->status = newSt.status;
pold->severity = newSt.severity;
strncpy(pold->units, newSt.units, MAX_UNITS_SIZE);
pold->units[MAX_UNITS_SIZE-1] = '\0';
pold->upper_disp_limit = newSt.upper_disp_limit;
pold->lower_disp_limit = newSt.lower_disp_limit;
pold->upper_alarm_limit = newSt.upper_alarm_limit;
pold->upper_warning_limit = newSt.upper_warning_limit;
pold->lower_warning_limit = newSt.lower_warning_limit;
pold->lower_alarm_limit = newSt.lower_alarm_limit;
options = 0;
status = dbChannelGet(chan, DBR_UCHAR, &pold->value, &options,
nRequest, pfl);
}
break;
case(oldDBR_GR_LONG):
{
struct dbr_gr_long *pold = (struct dbr_gr_long *)pbuffer;
struct {
DBRstatus
DBRunits
DBRgrLong
DBRalLong
} newSt;
options = DBR_STATUS | DBR_UNITS | DBR_GR_LONG | DBR_AL_LONG;
status = dbChannelGet(chan, DBR_LONG, &newSt, &options, &zero, pfl);
pold->status = newSt.status;
pold->severity = newSt.severity;
strncpy(pold->units, newSt.units, MAX_UNITS_SIZE);
pold->units[MAX_UNITS_SIZE-1] = '\0';
pold->upper_disp_limit = newSt.upper_disp_limit;
pold->lower_disp_limit = newSt.lower_disp_limit;
pold->upper_alarm_limit = newSt.upper_alarm_limit;
pold->upper_warning_limit = newSt.upper_warning_limit;
pold->lower_warning_limit = newSt.lower_warning_limit;
pold->lower_alarm_limit = newSt.lower_alarm_limit;
options = 0;
status = dbChannelGet(chan, DBR_LONG, &pold->value, &options,
nRequest, pfl);
}
break;
case(oldDBR_GR_DOUBLE):
{
struct dbr_gr_double *pold = (struct dbr_gr_double *)pbuffer;
struct {
DBRstatus
DBRunits
DBRprecision
DBRgrDouble
DBRalDouble
} newSt;
options = DBR_STATUS | DBR_UNITS | DBR_PRECISION | DBR_GR_DOUBLE |
DBR_AL_DOUBLE;
status = dbChannelGet(chan, DBR_DOUBLE, &newSt, &options, &zero, pfl);
pold->status = newSt.status;
pold->severity = newSt.severity;
pold->precision = (dbr_short_t) newSt.precision.dp;
strncpy(pold->units, newSt.units, MAX_UNITS_SIZE);
pold->units[MAX_UNITS_SIZE-1] = '\0';
pold->upper_disp_limit = newSt.upper_disp_limit;
pold->lower_disp_limit = newSt.lower_disp_limit;
pold->upper_alarm_limit = newSt.upper_alarm_limit;
pold->upper_warning_limit = newSt.upper_warning_limit;
pold->lower_warning_limit = newSt.lower_warning_limit;
pold->lower_alarm_limit = newSt.lower_alarm_limit;
options = 0;
status = dbChannelGet(chan, DBR_DOUBLE, &pold->value, &options,
nRequest, pfl);
}
break;
/* case(oldDBR_CTRL_INT): */
case(oldDBR_CTRL_SHORT):
{
struct dbr_ctrl_int *pold = (struct dbr_ctrl_int *)pbuffer;
struct {
DBRstatus
DBRunits
DBRgrLong
DBRctrlLong
DBRalLong
} newSt;
options = DBR_STATUS | DBR_UNITS | DBR_GR_LONG | DBR_CTRL_LONG |
DBR_AL_LONG;
status = dbChannelGet(chan, DBR_SHORT, &newSt, &options, &zero, pfl);
pold->status = newSt.status;
pold->severity = newSt.severity;
strncpy(pold->units, newSt.units, MAX_UNITS_SIZE);
pold->units[MAX_UNITS_SIZE-1] = '\0';
pold->upper_disp_limit = newSt.upper_disp_limit;
pold->lower_disp_limit = newSt.lower_disp_limit;
pold->upper_alarm_limit = newSt.upper_alarm_limit;
pold->upper_warning_limit = newSt.upper_warning_limit;
pold->lower_warning_limit = newSt.lower_warning_limit;
pold->lower_alarm_limit = newSt.lower_alarm_limit;
pold->upper_ctrl_limit = newSt.upper_ctrl_limit;
pold->lower_ctrl_limit = newSt.lower_ctrl_limit;
options = 0;
status = dbChannelGet(chan, DBR_SHORT, &pold->value, &options,
nRequest, pfl);
}
break;
case(oldDBR_CTRL_FLOAT):
{
struct dbr_ctrl_float *pold = (struct dbr_ctrl_float *)pbuffer;
struct {
DBRstatus
DBRunits
DBRprecision
DBRgrDouble
DBRctrlDouble
DBRalDouble
} newSt;
options = DBR_STATUS | DBR_UNITS | DBR_PRECISION | DBR_GR_DOUBLE |
DBR_CTRL_DOUBLE | DBR_AL_DOUBLE;
status = dbChannelGet(chan, DBR_FLOAT, &newSt, &options, &zero, pfl);
pold->status = newSt.status;
pold->severity = newSt.severity;
pold->precision = (dbr_short_t) newSt.precision.dp;
strncpy(pold->units, newSt.units, MAX_UNITS_SIZE);
pold->units[MAX_UNITS_SIZE-1] = '\0';
pold->upper_disp_limit = epicsConvertDoubleToFloat(newSt.upper_disp_limit);
pold->lower_disp_limit = epicsConvertDoubleToFloat(newSt.lower_disp_limit);
pold->upper_alarm_limit = epicsConvertDoubleToFloat(newSt.upper_alarm_limit);
pold->lower_alarm_limit = epicsConvertDoubleToFloat(newSt.lower_alarm_limit);
pold->upper_warning_limit = epicsConvertDoubleToFloat(newSt.upper_warning_limit);
pold->lower_warning_limit = epicsConvertDoubleToFloat(newSt.lower_warning_limit);
pold->upper_ctrl_limit = epicsConvertDoubleToFloat(newSt.upper_ctrl_limit);
pold->lower_ctrl_limit = epicsConvertDoubleToFloat(newSt.lower_ctrl_limit);
options = 0;
status = dbChannelGet(chan, DBR_FLOAT, &pold->value, &options,
nRequest, pfl);
}
break;
case(oldDBR_GR_ENUM):
case(oldDBR_CTRL_ENUM):
{
struct dbr_ctrl_enum *pold = (struct dbr_ctrl_enum *)pbuffer;
struct {
DBRstatus
DBRenumStrs
} newSt;
short no_str;
memset(pold, '\0', sizeof(struct dbr_ctrl_enum));
/* first get status and severity */
options = DBR_STATUS | DBR_ENUM_STRS;
status = dbChannelGet(chan, DBR_ENUM, &newSt, &options, &zero, pfl);
pold->status = newSt.status;
pold->severity = newSt.severity;
no_str = newSt.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], newSt.strs[i], sizeof(pold->strs[i]));
/*now get values*/
options = 0;
status = dbChannelGet(chan, DBR_ENUM, &pold->value, &options,
nRequest, pfl);
}
break;
case(oldDBR_CTRL_CHAR):
{
struct dbr_ctrl_char *pold = (struct dbr_ctrl_char *)pbuffer;
struct {
DBRstatus
DBRunits
DBRgrLong
DBRctrlLong
DBRalLong
} newSt;
options = DBR_STATUS | DBR_UNITS | DBR_GR_LONG | DBR_CTRL_LONG |
DBR_AL_LONG;
status = dbChannelGet(chan, DBR_UCHAR, &newSt, &options, &zero, pfl);
pold->status = newSt.status;
pold->severity = newSt.severity;
strncpy(pold->units, newSt.units, MAX_UNITS_SIZE);
pold->units[MAX_UNITS_SIZE-1] = '\0';
pold->upper_disp_limit = newSt.upper_disp_limit;
pold->lower_disp_limit = newSt.lower_disp_limit;
pold->upper_alarm_limit = newSt.upper_alarm_limit;
pold->upper_warning_limit = newSt.upper_warning_limit;
pold->lower_warning_limit = newSt.lower_warning_limit;
pold->lower_alarm_limit = newSt.lower_alarm_limit;
pold->upper_ctrl_limit = newSt.upper_ctrl_limit;
pold->lower_ctrl_limit = newSt.lower_ctrl_limit;
options = 0;
status = dbChannelGet(chan, DBR_UCHAR, &pold->value, &options,
nRequest, pfl);
}
break;
case(oldDBR_CTRL_LONG):
{
struct dbr_ctrl_long *pold = (struct dbr_ctrl_long *)pbuffer;
struct {
DBRstatus
DBRunits
DBRgrLong
DBRctrlLong
DBRalLong
} newSt;
options = DBR_STATUS | DBR_UNITS | DBR_GR_LONG | DBR_CTRL_LONG |
DBR_AL_LONG;
status = dbChannelGet(chan, DBR_LONG, &newSt, &options, &zero, pfl);
pold->status = newSt.status;
pold->severity = newSt.severity;
strncpy(pold->units, newSt.units, MAX_UNITS_SIZE);
pold->units[MAX_UNITS_SIZE-1] = '\0';
pold->upper_disp_limit = newSt.upper_disp_limit;
pold->lower_disp_limit = newSt.lower_disp_limit;
pold->upper_alarm_limit = newSt.upper_alarm_limit;
pold->upper_warning_limit = newSt.upper_warning_limit;
pold->lower_warning_limit = newSt.lower_warning_limit;
pold->lower_alarm_limit = newSt.lower_alarm_limit;
pold->upper_ctrl_limit = newSt.upper_ctrl_limit;
pold->lower_ctrl_limit = newSt.lower_ctrl_limit;
options = 0;
status = dbChannelGet(chan, DBR_LONG, &pold->value, &options,
nRequest, pfl);
}
break;
case(oldDBR_CTRL_DOUBLE):
{
struct dbr_ctrl_double *pold = (struct dbr_ctrl_double *)pbuffer;
struct {
DBRstatus
DBRunits
DBRprecision
DBRgrDouble
DBRctrlDouble
DBRalDouble
} newSt;
options = DBR_STATUS | DBR_UNITS | DBR_PRECISION | DBR_GR_DOUBLE |
DBR_CTRL_DOUBLE | DBR_AL_DOUBLE;
status = dbChannelGet(chan, DBR_DOUBLE, &newSt, &options, &zero, pfl);
pold->status = newSt.status;
pold->severity = newSt.severity;
pold->precision = (dbr_short_t) newSt.precision.dp;
strncpy(pold->units, newSt.units, MAX_UNITS_SIZE);
pold->units[MAX_UNITS_SIZE-1] = '\0';
pold->upper_disp_limit = newSt.upper_disp_limit;
pold->lower_disp_limit = newSt.lower_disp_limit;
pold->upper_alarm_limit = newSt.upper_alarm_limit;
pold->upper_warning_limit = newSt.upper_warning_limit;
pold->lower_warning_limit = newSt.lower_warning_limit;
pold->lower_alarm_limit = newSt.lower_alarm_limit;
pold->upper_ctrl_limit = newSt.upper_ctrl_limit;
pold->lower_ctrl_limit = newSt.lower_ctrl_limit;
options = 0;
status = dbChannelGet(chan, DBR_DOUBLE, &pold->value, &options,
nRequest, pfl);
}
break;
case(oldDBR_STSACK_STRING):
{
struct dbr_stsack_string *pold = (struct dbr_stsack_string *)pbuffer;
struct {
DBRstatus
} newSt;
options = DBR_STATUS;
status = dbChannelGet(chan, DBR_STRING, &newSt, &options, &zero, pfl);
pold->status = newSt.status;
pold->severity = newSt.severity;
pold->ackt = newSt.ackt;
pold->acks = newSt.acks;
options = 0;
status = dbChannelGet(chan, DBR_STRING, pold->value,
&options, nRequest, pfl);
}
break;
case(oldDBR_CLASS_NAME):
{
DBENTRY dbEntry;
char *name = 0;
char *pto = (char *)pbuffer;
if (!pdbbase) {
status = S_db_notFound;
break;
}
dbInitEntry(pdbbase, &dbEntry);
status = dbFindRecord(&dbEntry, dbChannelRecord(chan)->name);
if (!status) name = dbGetRecordTypeName(&dbEntry);
dbFinishEntry(&dbEntry);
if (status) break;
if (!name) {
status = S_dbLib_recordTypeNotFound;
break;
}
pto[MAX_STRING_SIZE-1] = 0;
strncpy(pto, name, MAX_STRING_SIZE-1);
}
break;
default:
status = -1;
break;
}
dbScanUnlock(dbChannelRecord(chan));
if (status) return -1;
return 0;
}
