1263 lines
35 KiB
C
1263 lines
35 KiB
C
/*************************************************************************\
|
||
* Copyright (c) 2002 The University of Chicago, as Operator of Argonne
|
||
* National Laboratory.
|
||
* Copyright (c) 2002 The Regents of the University of California, as
|
||
* Operator of Los Alamos National Laboratory.
|
||
* EPICS BASE Versions 3.13.7
|
||
* and higher are distributed subject to a Software License Agreement found
|
||
* in file LICENSE that is included with this distribution.
|
||
\*************************************************************************/
|
||
/* db_access.c */
|
||
/* base/src/db $Id$ */
|
||
/* db_access.c - Interface between old database access and new */
|
||
/*
|
||
* Author: Marty Kraimer
|
||
* Date: 6-1-90
|
||
*/
|
||
|
||
|
||
/***
|
||
*** note: the order of the DBR_... elements in the "new" structures
|
||
*** in db_get_field() is important - and must correspond to
|
||
*** the presumed order in dbAccess.c's dbGetField() routine
|
||
***/
|
||
|
||
#include <stddef.h>
|
||
#include <stdlib.h>
|
||
#include <stdarg.h>
|
||
#include <string.h>
|
||
#include <math.h>
|
||
#include <float.h>
|
||
|
||
#include "epicsConvert.h"
|
||
#include "dbDefs.h"
|
||
#include "errlog.h"
|
||
#include "ellLib.h"
|
||
#include "epicsTime.h"
|
||
#include "dbStaticLib.h"
|
||
#include "dbBase.h"
|
||
#include "dbCommon.h"
|
||
#include "errMdef.h"
|
||
#include "recSup.h"
|
||
#include "alarm.h"
|
||
#define db_accessHFORdb_accessC
|
||
#include "db_access.h"
|
||
#undef db_accessHFORdb_accessC
|
||
#define epicsExportSharedSymbols
|
||
#include "dbNotify.h"
|
||
#include "dbAccessDefs.h"
|
||
#include "dbEvent.h"
|
||
#include "db_access_routines.h"
|
||
|
||
#ifndef NULL
|
||
#define NULL 0
|
||
#endif
|
||
|
||
|
||
#define oldDBF_STRING 0
|
||
#define oldDBF_INT 1
|
||
#define oldDBF_SHORT 1
|
||
#define oldDBF_FLOAT 2
|
||
#define oldDBF_ENUM 3
|
||
#define oldDBF_CHAR 4
|
||
#define oldDBF_LONG 5
|
||
#define oldDBF_DOUBLE 6
|
||
|
||
/* data request buffer types */
|
||
#define oldDBR_STRING oldDBF_STRING
|
||
#define oldDBR_INT oldDBF_INT
|
||
#define oldDBR_SHORT oldDBF_INT
|
||
#define oldDBR_FLOAT oldDBF_FLOAT
|
||
#define oldDBR_ENUM oldDBF_ENUM
|
||
#define oldDBR_CHAR oldDBF_CHAR
|
||
#define oldDBR_LONG oldDBF_LONG
|
||
#define oldDBR_DOUBLE oldDBF_DOUBLE
|
||
#define oldDBR_STS_STRING 7
|
||
#define oldDBR_STS_INT 8
|
||
#define oldDBR_STS_SHORT 8
|
||
#define oldDBR_STS_FLOAT 9
|
||
#define oldDBR_STS_ENUM 10
|
||
#define oldDBR_STS_CHAR 11
|
||
#define oldDBR_STS_LONG 12
|
||
#define oldDBR_STS_DOUBLE 13
|
||
#define oldDBR_TIME_STRING 14
|
||
#define oldDBR_TIME_INT 15
|
||
#define oldDBR_TIME_SHORT 15
|
||
#define oldDBR_TIME_FLOAT 16
|
||
#define oldDBR_TIME_ENUM 17
|
||
#define oldDBR_TIME_CHAR 18
|
||
#define oldDBR_TIME_LONG 19
|
||
#define oldDBR_TIME_DOUBLE 20
|
||
#define oldDBR_GR_STRING 21
|
||
#define oldDBR_GR_INT 22
|
||
#define oldDBR_GR_SHORT 22
|
||
#define oldDBR_GR_FLOAT 23
|
||
#define oldDBR_GR_ENUM 24
|
||
#define oldDBR_GR_CHAR 25
|
||
#define oldDBR_GR_LONG 26
|
||
#define oldDBR_GR_DOUBLE 27
|
||
#define oldDBR_CTRL_STRING 28
|
||
#define oldDBR_CTRL_INT 29
|
||
#define oldDBR_CTRL_SHORT 29
|
||
#define oldDBR_CTRL_FLOAT 30
|
||
#define oldDBR_CTRL_ENUM 31
|
||
#define oldDBR_CTRL_CHAR 32
|
||
#define oldDBR_CTRL_LONG 33
|
||
#define oldDBR_CTRL_DOUBLE 34
|
||
#define oldDBR_PUT_ACKT oldDBR_CTRL_DOUBLE + 1
|
||
#define oldDBR_PUT_ACKS oldDBR_PUT_ACKT + 1
|
||
#define oldDBR_STSACK_STRING oldDBR_PUT_ACKS + 1
|
||
#define oldDBR_CLASS_NAME oldDBR_STSACK_STRING + 1
|
||
|
||
/*Following is defined in dbConvert.h*/
|
||
extern unsigned short dbDBRnewToDBRold[DBR_ENUM+1];
|
||
|
||
|
||
/* function declarations */
|
||
|
||
#ifndef MAX_STRING_SIZE
|
||
#define MAX_STRING_SIZE 40
|
||
#endif
|
||
|
||
/* From $cs/dblib/src/dbiocsubs.c
|
||
* subroutines
|
||
*
|
||
* db_process process a database record
|
||
* args
|
||
* pdb_addr pointer to a database address
|
||
* command_mask mask of operations to perform
|
||
* new_alarm send an alarm message (NYI!!!!!)
|
||
* fill fill a buffer with a character
|
||
* args
|
||
* pbuffer pointer to the buffer
|
||
* size number of characters
|
||
* fillchar character with which to fill
|
||
*/
|
||
|
||
/*
|
||
* DB_PROCESS
|
||
*
|
||
* process database records
|
||
*/
|
||
void db_process(struct dbAddr *pdb_addr)
|
||
{
|
||
long status;
|
||
|
||
status=dbProcess((void *)pdb_addr->precord);
|
||
if(status) errMessage(status,"db_process failed");
|
||
return;
|
||
}
|
||
|
||
/* IOCDBACCESS.C
|
||
* Global Subroutines
|
||
*
|
||
* db_name_to_addr converts a database name in the format "pv<.field>"
|
||
* to a database address
|
||
* args
|
||
* pname pointer to the database name
|
||
* paddr pointer to the database address structure
|
||
* returns
|
||
* 0 successful
|
||
* -1 not successful
|
||
* pv portion failed - node, record type and record number are -1
|
||
* field portion failed - field type, offset, size and ext are -1
|
||
*
|
||
*
|
||
* db_get_field get a field from the database and convert it to
|
||
* the specified type.
|
||
*
|
||
* args
|
||
* paddr pointer to the database address structure
|
||
* buffer_type the type of data to return
|
||
* see DBR_ defines in db_access.h
|
||
* pbuffer return buffer
|
||
* no_elements number of elements
|
||
* void *pfl;
|
||
* returns
|
||
* 0 successful
|
||
* -1 failed
|
||
*
|
||
* db_put_field put a converted buffer into the database
|
||
* args
|
||
* paddr pointer to the database address structure
|
||
* buffer_type the type of data to be converted and stored
|
||
* see DBR_ defines in db_access.h
|
||
* pbuffer return buffer
|
||
* returns
|
||
* 0 successful
|
||
* -1 failed
|
||
*
|
||
*/
|
||
|
||
/*
|
||
* DB_NAME_TO_ADDR
|
||
*/
|
||
int epicsShareAPI db_name_to_addr(const char *pname, struct dbAddr *paddr)
|
||
{
|
||
long status;
|
||
short ftype;
|
||
|
||
status=dbNameToAddr(pname, paddr);
|
||
if(!status) {
|
||
ftype = paddr->dbr_field_type;
|
||
if(INVALID_DB_REQ(ftype)) {
|
||
errlogPrintf("%s dbNameToAddr failed\n",pname);
|
||
return(-2);
|
||
}
|
||
paddr->dbr_field_type = dbDBRnewToDBRold[ftype];
|
||
return(0);
|
||
}
|
||
else
|
||
return(-1);
|
||
}
|
||
|
||
typedef char DBSTRING[MAX_STRING_SIZE];
|
||
|
||
int epicsShareAPI db_get_field(
|
||
struct dbAddr *paddr,
|
||
int buffer_type,
|
||
void *pbuffer,
|
||
int no_elements,
|
||
void *pfl
|
||
)
|
||
{
|
||
long status;
|
||
long options;
|
||
long nRequest;
|
||
long i;
|
||
|
||
|
||
switch(buffer_type) {
|
||
case(oldDBR_STRING):
|
||
{
|
||
DBSTRING *pvalue = (DBSTRING *)pbuffer;
|
||
|
||
options=0;
|
||
nRequest=no_elements;
|
||
status = dbGetField(paddr,DBR_STRING,pbuffer,&options,&nRequest,
|
||
pfl);
|
||
for(i=nRequest; i<no_elements; i++) pvalue[i][0] = 0;
|
||
}
|
||
break;
|
||
/* case(oldDBR_INT): */
|
||
case(oldDBR_SHORT):
|
||
{
|
||
dbr_short_t *pvalue = (dbr_short_t *)pbuffer;
|
||
|
||
options=0;
|
||
nRequest=no_elements;
|
||
status = dbGetField(paddr,DBR_SHORT,pbuffer,&options,&nRequest,
|
||
pfl);
|
||
for(i=nRequest; i<no_elements; i++) pvalue[i] = 0;
|
||
}
|
||
break;
|
||
case(oldDBR_FLOAT):
|
||
{
|
||
dbr_float_t *pvalue = (dbr_float_t *)pbuffer;
|
||
|
||
options=0;
|
||
nRequest=no_elements;
|
||
status = dbGetField(paddr,DBR_FLOAT,pbuffer,&options,&nRequest,
|
||
pfl);
|
||
for(i=nRequest; i<no_elements; i++) pvalue[i] = 0;
|
||
}
|
||
break;
|
||
case(oldDBR_ENUM):
|
||
{
|
||
dbr_enum_t *pvalue = (dbr_enum_t *)pbuffer;
|
||
|
||
options=0;
|
||
nRequest=no_elements;
|
||
status = dbGetField(paddr,DBR_ENUM,pbuffer,&options,&nRequest,
|
||
pfl);
|
||
for(i=nRequest; i<no_elements; i++) pvalue[i] = 0;
|
||
}
|
||
break;
|
||
case(oldDBR_CHAR):
|
||
{
|
||
dbr_char_t *pvalue = (dbr_char_t *)pbuffer;
|
||
|
||
options=0;
|
||
nRequest=no_elements;
|
||
status = dbGetField(paddr,DBR_CHAR,pbuffer,&options,&nRequest,
|
||
pfl);
|
||
for(i=nRequest; i<no_elements; i++) pvalue[i] = 0;
|
||
}
|
||
break;
|
||
case(oldDBR_LONG):
|
||
{
|
||
dbr_long_t *pvalue = (dbr_long_t *)pbuffer;
|
||
|
||
options=0;
|
||
nRequest=no_elements;
|
||
status = dbGetField(paddr,DBR_LONG,pbuffer,&options,&nRequest,
|
||
pfl);
|
||
for(i=nRequest; i<no_elements; i++) pvalue[i] = 0;
|
||
}
|
||
break;
|
||
case(oldDBR_DOUBLE):
|
||
{
|
||
dbr_double_t *pvalue = (dbr_double_t *)pbuffer;
|
||
|
||
options=0;
|
||
nRequest=no_elements;
|
||
status = dbGetField(paddr,DBR_DOUBLE,pbuffer,&options,&nRequest,
|
||
pfl);
|
||
for(i=nRequest; i<no_elements; i++) pvalue[i] = 0;
|
||
}
|
||
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
|
||
} new;
|
||
DBSTRING *pvalue = (DBSTRING *)(pold->value);
|
||
|
||
options=DBR_STATUS;
|
||
nRequest=0;
|
||
status = dbGetField(paddr,DBR_STRING,&new,&options,&nRequest,
|
||
pfl);
|
||
pold->status = new.status;
|
||
pold->severity = new.severity;
|
||
options=0;
|
||
nRequest=no_elements;
|
||
status = dbGetField(paddr,DBR_STRING,&(pold->value[0]),
|
||
&options,&nRequest,pfl);
|
||
for(i=nRequest; i<no_elements; i++) pvalue[i][0] = 0;
|
||
}
|
||
break;
|
||
/* case(oldDBR_STS_INT): */
|
||
case(oldDBR_STS_SHORT):
|
||
{
|
||
struct dbr_sts_int *pold = (struct dbr_sts_int *)pbuffer;
|
||
struct {
|
||
DBRstatus
|
||
} new;
|
||
dbr_short_t *pvalue = &pold->value;
|
||
|
||
options=DBR_STATUS;
|
||
nRequest=0;
|
||
status = dbGetField(paddr,DBR_SHORT,&new,&options,&nRequest,
|
||
pfl);
|
||
pold->status = new.status;
|
||
pold->severity = new.severity;
|
||
options=0;
|
||
nRequest=no_elements;
|
||
status = dbGetField(paddr,DBR_SHORT,&(pold->value),&options,
|
||
&nRequest,pfl);
|
||
for(i=nRequest; i<no_elements; i++) pvalue[i] = 0;
|
||
}
|
||
break;
|
||
case(oldDBR_STS_FLOAT):
|
||
{
|
||
struct dbr_sts_float *pold = (struct dbr_sts_float *)pbuffer;
|
||
struct {
|
||
DBRstatus
|
||
} new;
|
||
dbr_float_t *pvalue = &pold->value;
|
||
|
||
options=DBR_STATUS;
|
||
nRequest=0;
|
||
status = dbGetField(paddr,DBR_FLOAT,&new,&options,&nRequest,
|
||
pfl);
|
||
pold->status = new.status;
|
||
pold->severity = new.severity;
|
||
options=0;
|
||
nRequest=no_elements;
|
||
status = dbGetField(paddr,DBR_FLOAT,&(pold->value),&options,
|
||
&nRequest,pfl);
|
||
for(i=nRequest; i<no_elements; i++) pvalue[i] = 0;
|
||
}
|
||
break;
|
||
case(oldDBR_STS_ENUM):
|
||
{
|
||
struct dbr_sts_enum *pold = (struct dbr_sts_enum *)pbuffer;
|
||
struct {
|
||
DBRstatus
|
||
} new;
|
||
dbr_enum_t *pvalue = &pold->value;
|
||
|
||
options=DBR_STATUS;
|
||
nRequest=0;
|
||
status = dbGetField(paddr,DBR_ENUM,&new,&options,&nRequest,
|
||
pfl);
|
||
pold->status = new.status;
|
||
pold->severity = new.severity;
|
||
options=0;
|
||
nRequest=no_elements;
|
||
status = dbGetField(paddr,DBR_ENUM,&(pold->value),&options,
|
||
&nRequest,pfl);
|
||
for(i=nRequest; i<no_elements; i++) pvalue[i] = 0;
|
||
}
|
||
break;
|
||
case(oldDBR_STS_CHAR):
|
||
{
|
||
struct dbr_sts_char *pold = (struct dbr_sts_char *)pbuffer;
|
||
struct {
|
||
DBRstatus
|
||
} new;
|
||
dbr_char_t *pvalue = &pold->value;
|
||
|
||
options=DBR_STATUS;
|
||
nRequest=0;
|
||
status = dbGetField(paddr,DBR_UCHAR,&new,&options,&nRequest,
|
||
pfl);
|
||
pold->status = new.status;
|
||
pold->severity = new.severity;
|
||
options=0;
|
||
nRequest=no_elements;
|
||
status = dbGetField(paddr,DBR_UCHAR,&(pold->value),&options,
|
||
&nRequest,pfl);
|
||
for(i=nRequest; i<no_elements; i++) pvalue[i] = 0;
|
||
}
|
||
break;
|
||
case(oldDBR_STS_LONG):
|
||
{
|
||
struct dbr_sts_long *pold = (struct dbr_sts_long *)pbuffer;
|
||
struct {
|
||
DBRstatus
|
||
} new;
|
||
dbr_long_t *pvalue = &pold->value;
|
||
|
||
options=DBR_STATUS;
|
||
nRequest=0;
|
||
status = dbGetField(paddr,DBR_LONG,&new,&options,&nRequest,
|
||
pfl);
|
||
pold->status = new.status;
|
||
pold->severity = new.severity;
|
||
options=0;
|
||
nRequest=no_elements;
|
||
status = dbGetField(paddr,DBR_LONG,&(pold->value),&options,
|
||
&nRequest,pfl);
|
||
for(i=nRequest; i<no_elements; i++) pvalue[i] = 0;
|
||
}
|
||
break;
|
||
case(oldDBR_STS_DOUBLE):
|
||
{
|
||
struct dbr_sts_double *pold = (struct dbr_sts_double *)pbuffer;
|
||
struct {
|
||
DBRstatus
|
||
} new;
|
||
dbr_double_t *pvalue = &pold->value;
|
||
|
||
options=DBR_STATUS;
|
||
nRequest=0;
|
||
status = dbGetField(paddr,DBR_DOUBLE,&new,&options,&nRequest,
|
||
pfl);
|
||
pold->status = new.status;
|
||
pold->severity = new.severity;
|
||
options=0;
|
||
nRequest=no_elements;
|
||
status = dbGetField(paddr,DBR_DOUBLE,&(pold->value),&options,
|
||
&nRequest,pfl);
|
||
for(i=nRequest; i<no_elements; i++) pvalue[i] = 0;
|
||
}
|
||
break;
|
||
case(oldDBR_TIME_STRING):
|
||
{
|
||
struct dbr_time_string *pold=(struct dbr_time_string *)pbuffer;
|
||
struct {
|
||
DBRstatus
|
||
DBRtime
|
||
} new;
|
||
DBSTRING *pvalue = (DBSTRING *)(pold->value);
|
||
|
||
options=DBR_STATUS | DBR_TIME;
|
||
nRequest=0;
|
||
status = dbGetField(paddr,DBR_STRING,&new,&options,&nRequest,
|
||
pfl);
|
||
pold->status = new.status;
|
||
pold->severity = new.severity;
|
||
pold->stamp = new.time; /* structure copy */
|
||
options=0;
|
||
nRequest=no_elements;
|
||
status = dbGetField(paddr,DBR_STRING,pold->value,&options,
|
||
&nRequest,pfl);
|
||
for(i=nRequest; i<no_elements; i++) pvalue[i][0] = 0;
|
||
}
|
||
break;
|
||
/* case(oldDBR_TIME_INT): */
|
||
case(oldDBR_TIME_SHORT):
|
||
{
|
||
struct dbr_time_short *pold=(struct dbr_time_short *)pbuffer;
|
||
struct {
|
||
DBRstatus
|
||
DBRtime
|
||
} new;
|
||
dbr_short_t *pvalue = &pold->value;
|
||
|
||
options=DBR_STATUS | DBR_TIME;
|
||
nRequest=0;
|
||
status = dbGetField(paddr,DBR_SHORT,&new,&options,&nRequest,
|
||
pfl);
|
||
pold->status = new.status;
|
||
pold->severity = new.severity;
|
||
pold->stamp = new.time; /* structure copy */
|
||
options=0;
|
||
nRequest=no_elements;
|
||
status = dbGetField(paddr,DBR_SHORT,&(pold->value),&options,
|
||
&nRequest,pfl);
|
||
for(i=nRequest; i<no_elements; i++) pvalue[i] = 0;
|
||
}
|
||
break;
|
||
case(oldDBR_TIME_FLOAT):
|
||
{
|
||
struct dbr_time_float *pold=(struct dbr_time_float *)pbuffer;
|
||
struct {
|
||
DBRstatus
|
||
DBRtime
|
||
} new;
|
||
dbr_float_t *pvalue = &pold->value;
|
||
|
||
options=DBR_STATUS | DBR_TIME;
|
||
nRequest=0;
|
||
status = dbGetField(paddr,DBR_FLOAT,&new,&options,&nRequest,
|
||
pfl);
|
||
pold->status = new.status;
|
||
pold->severity = new.severity;
|
||
pold->stamp = new.time; /* structure copy */
|
||
options=0;
|
||
nRequest=no_elements;
|
||
status = dbGetField(paddr,DBR_FLOAT,&(pold->value),&options,
|
||
&nRequest,pfl);
|
||
for(i=nRequest; i<no_elements; i++) pvalue[i] = 0;
|
||
}
|
||
break;
|
||
case(oldDBR_TIME_ENUM):
|
||
{
|
||
struct dbr_time_enum *pold=(struct dbr_time_enum *)pbuffer;
|
||
struct {
|
||
DBRstatus
|
||
DBRtime
|
||
} new;
|
||
dbr_enum_t *pvalue = &pold->value;
|
||
|
||
options=DBR_STATUS | DBR_TIME;
|
||
nRequest=0;
|
||
status = dbGetField(paddr,DBR_ENUM,&new,&options,&nRequest,
|
||
pfl);
|
||
pold->status = new.status;
|
||
pold->severity = new.severity;
|
||
pold->stamp = new.time; /* structure copy */
|
||
options=0;
|
||
nRequest=no_elements;
|
||
status = dbGetField(paddr,DBR_ENUM,&(pold->value),&options,
|
||
&nRequest,pfl);
|
||
for(i=nRequest; i<no_elements; i++) pvalue[i] = 0;
|
||
}
|
||
break;
|
||
case(oldDBR_TIME_CHAR):
|
||
{
|
||
struct dbr_time_char *pold=(struct dbr_time_char *)pbuffer;
|
||
struct {
|
||
DBRstatus
|
||
DBRtime
|
||
} new;
|
||
dbr_char_t *pvalue = &pold->value;
|
||
|
||
options=DBR_STATUS | DBR_TIME;
|
||
nRequest=0;
|
||
status = dbGetField(paddr,DBR_CHAR,&new,&options,&nRequest,
|
||
pfl);
|
||
pold->status = new.status;
|
||
pold->severity = new.severity;
|
||
pold->stamp = new.time; /* structure copy */
|
||
options=0;
|
||
nRequest=no_elements;
|
||
status = dbGetField(paddr,DBR_CHAR,&(pold->value),&options,
|
||
&nRequest,pfl);
|
||
for(i=nRequest; i<no_elements; i++) pvalue[i] = 0;
|
||
}
|
||
break;
|
||
case(oldDBR_TIME_LONG):
|
||
{
|
||
struct dbr_time_long *pold=(struct dbr_time_long *)pbuffer;
|
||
struct {
|
||
DBRstatus
|
||
DBRtime
|
||
} new;
|
||
dbr_long_t *pvalue = &pold->value;
|
||
|
||
options=DBR_STATUS | DBR_TIME;
|
||
nRequest=0;
|
||
status = dbGetField(paddr,DBR_LONG,&new,&options,&nRequest,
|
||
pfl);
|
||
pold->status = new.status;
|
||
pold->severity = new.severity;
|
||
pold->stamp = new.time; /* structure copy */
|
||
options=0;
|
||
nRequest=no_elements;
|
||
status = dbGetField(paddr,DBR_LONG,&(pold->value),&options,
|
||
&nRequest,pfl);
|
||
for(i=nRequest; i<no_elements; i++) pvalue[i] = 0;
|
||
}
|
||
break;
|
||
case(oldDBR_TIME_DOUBLE):
|
||
{
|
||
struct dbr_time_double *pold=(struct dbr_time_double *)pbuffer;
|
||
struct {
|
||
DBRstatus
|
||
DBRtime
|
||
} new;
|
||
dbr_double_t *pvalue = &pold->value;
|
||
|
||
options=DBR_STATUS | DBR_TIME;
|
||
nRequest=0;
|
||
status = dbGetField(paddr,DBR_DOUBLE,&new,&options,&nRequest,
|
||
pfl);
|
||
pold->status = new.status;
|
||
pold->severity = new.severity;
|
||
pold->stamp = new.time; /* structure copy */
|
||
options=0;
|
||
nRequest=no_elements;
|
||
status = dbGetField(paddr,DBR_DOUBLE,&(pold->value),&options,
|
||
&nRequest,pfl);
|
||
for(i=nRequest; i<no_elements; i++) pvalue[i] = 0;
|
||
}
|
||
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
|
||
} new;
|
||
dbr_short_t *pvalue = &pold->value;
|
||
|
||
options=DBR_STATUS|DBR_UNITS|DBR_GR_LONG|DBR_AL_LONG;
|
||
nRequest=0;
|
||
status = dbGetField(paddr,DBR_SHORT,&new,&options,&nRequest,
|
||
pfl);
|
||
pold->status = new.status;
|
||
pold->severity = new.severity;
|
||
strncpy(pold->units,new.units,MAX_UNITS_SIZE);
|
||
pold->units[MAX_UNITS_SIZE-1] = '\0';
|
||
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,pfl);
|
||
for(i=nRequest; i<no_elements; i++) pvalue[i] = 0;
|
||
}
|
||
break;
|
||
case(oldDBR_GR_FLOAT):
|
||
{
|
||
struct dbr_gr_float *pold = (struct dbr_gr_float *)pbuffer;
|
||
struct {
|
||
DBRstatus
|
||
DBRunits
|
||
DBRprecision
|
||
DBRgrDouble
|
||
DBRalDouble
|
||
} new;
|
||
dbr_float_t *pvalue = &pold->value;
|
||
|
||
options=DBR_STATUS|DBR_UNITS|DBR_PRECISION|DBR_GR_DOUBLE
|
||
|DBR_AL_DOUBLE;
|
||
nRequest=0;
|
||
status = dbGetField(paddr,DBR_FLOAT,&new,&options,&nRequest,
|
||
pfl);
|
||
pold->status = new.status;
|
||
pold->severity = new.severity;
|
||
pold->precision = new.precision;
|
||
strncpy(pold->units,new.units,MAX_UNITS_SIZE);
|
||
pold->units[MAX_UNITS_SIZE-1] = '\0';
|
||
pold->upper_disp_limit = epicsConvertDoubleToFloat(new.upper_disp_limit);
|
||
pold->lower_disp_limit = epicsConvertDoubleToFloat(new.lower_disp_limit);
|
||
pold->upper_alarm_limit = epicsConvertDoubleToFloat(new.upper_alarm_limit);
|
||
pold->lower_alarm_limit = epicsConvertDoubleToFloat(new.lower_alarm_limit);
|
||
pold->upper_warning_limit = epicsConvertDoubleToFloat(new.upper_warning_limit);
|
||
pold->lower_warning_limit = epicsConvertDoubleToFloat(new.lower_warning_limit);
|
||
options=0;
|
||
nRequest=no_elements;
|
||
status = dbGetField(paddr,DBR_FLOAT,&(pold->value),&options,
|
||
&nRequest,pfl);
|
||
for(i=nRequest; i<no_elements; i++) pvalue[i] = 0;
|
||
}
|
||
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
|
||
} new;
|
||
dbr_char_t *pvalue = &pold->value;
|
||
|
||
options=DBR_STATUS|DBR_UNITS|DBR_GR_LONG|DBR_AL_LONG;
|
||
nRequest=0;
|
||
status = dbGetField(paddr,DBR_UCHAR,&new,&options,&nRequest,
|
||
pfl);
|
||
pold->status = new.status;
|
||
pold->severity = new.severity;
|
||
strncpy(pold->units,new.units,MAX_UNITS_SIZE);
|
||
pold->units[MAX_UNITS_SIZE-1] = '\0';
|
||
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_UCHAR,&(pold->value),&options,
|
||
&nRequest,pfl);
|
||
for(i=nRequest; i<no_elements; i++) pvalue[i] = 0;
|
||
}
|
||
break;
|
||
case(oldDBR_GR_LONG):
|
||
{
|
||
struct dbr_gr_long *pold = (struct dbr_gr_long *)pbuffer;
|
||
struct {
|
||
DBRstatus
|
||
DBRunits
|
||
DBRgrLong
|
||
DBRalLong
|
||
} new;
|
||
dbr_long_t *pvalue = &pold->value;
|
||
|
||
options=DBR_STATUS|DBR_UNITS|DBR_GR_LONG|DBR_AL_LONG;
|
||
nRequest=0;
|
||
status = dbGetField(paddr,DBR_LONG,&new,&options,&nRequest,
|
||
pfl);
|
||
pold->status = new.status;
|
||
pold->severity = new.severity;
|
||
strncpy(pold->units,new.units,MAX_UNITS_SIZE);
|
||
pold->units[MAX_UNITS_SIZE-1] = '\0';
|
||
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_LONG,&(pold->value),&options,
|
||
&nRequest,pfl);
|
||
for(i=nRequest; i<no_elements; i++) pvalue[i] = 0;
|
||
}
|
||
break;
|
||
case(oldDBR_GR_DOUBLE):
|
||
{
|
||
struct dbr_gr_double *pold = (struct dbr_gr_double *)pbuffer;
|
||
struct {
|
||
DBRstatus
|
||
DBRunits
|
||
DBRprecision
|
||
DBRgrDouble
|
||
DBRalDouble
|
||
} new;
|
||
dbr_double_t *pvalue = &pold->value;
|
||
|
||
options=DBR_STATUS|DBR_UNITS|DBR_PRECISION|DBR_GR_DOUBLE
|
||
|DBR_AL_DOUBLE;
|
||
nRequest=0;
|
||
status = dbGetField(paddr,DBR_DOUBLE,&new,&options,&nRequest,
|
||
pfl);
|
||
pold->status = new.status;
|
||
pold->severity = new.severity;
|
||
pold->precision = new.precision;
|
||
strncpy(pold->units,new.units,MAX_UNITS_SIZE);
|
||
pold->units[MAX_UNITS_SIZE-1] = '\0';
|
||
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_DOUBLE,&(pold->value),&options,
|
||
&nRequest,pfl);
|
||
for(i=nRequest; i<no_elements; i++) pvalue[i] = 0;
|
||
}
|
||
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
|
||
} new;
|
||
dbr_short_t *pvalue = &pold->value;
|
||
|
||
options=DBR_STATUS|DBR_UNITS|DBR_GR_LONG|DBR_CTRL_LONG
|
||
|DBR_AL_LONG;
|
||
nRequest=0;
|
||
status = dbGetField(paddr,DBR_SHORT,&new,&options,&nRequest,
|
||
pfl);
|
||
pold->status = new.status;
|
||
pold->severity = new.severity;
|
||
strncpy(pold->units,new.units,MAX_UNITS_SIZE);
|
||
pold->units[MAX_UNITS_SIZE-1] = '\0';
|
||
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,pfl);
|
||
for(i=nRequest; i<no_elements; i++) pvalue[i] = 0;
|
||
}
|
||
break;
|
||
case(oldDBR_CTRL_FLOAT):
|
||
{
|
||
struct dbr_ctrl_float *pold = (struct dbr_ctrl_float *)pbuffer;
|
||
struct {
|
||
DBRstatus
|
||
DBRunits
|
||
DBRprecision
|
||
DBRgrDouble
|
||
DBRctrlDouble
|
||
DBRalDouble
|
||
} new;
|
||
dbr_float_t *pvalue = &pold->value;
|
||
|
||
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,
|
||
pfl);
|
||
pold->status = new.status;
|
||
pold->severity = new.severity;
|
||
pold->precision = new.precision;
|
||
strncpy(pold->units,new.units,MAX_UNITS_SIZE);
|
||
pold->units[MAX_UNITS_SIZE-1] = '\0';
|
||
pold->upper_disp_limit = epicsConvertDoubleToFloat(new.upper_disp_limit);
|
||
pold->lower_disp_limit = epicsConvertDoubleToFloat(new.lower_disp_limit);
|
||
pold->upper_alarm_limit = epicsConvertDoubleToFloat(new.upper_alarm_limit);
|
||
pold->lower_alarm_limit = epicsConvertDoubleToFloat(new.lower_alarm_limit);
|
||
pold->upper_warning_limit = epicsConvertDoubleToFloat(new.upper_warning_limit);
|
||
pold->lower_warning_limit = epicsConvertDoubleToFloat(new.lower_warning_limit);
|
||
pold->upper_ctrl_limit = epicsConvertDoubleToFloat(new.upper_ctrl_limit);
|
||
pold->lower_ctrl_limit = epicsConvertDoubleToFloat(new.lower_ctrl_limit);
|
||
options=0;
|
||
nRequest=no_elements;
|
||
status = dbGetField(paddr,DBR_FLOAT,&(pold->value),&options,
|
||
&nRequest,pfl);
|
||
for(i=nRequest; i<no_elements; i++) pvalue[i] = 0;
|
||
}
|
||
break;
|
||
case(oldDBR_GR_ENUM):
|
||
case(oldDBR_CTRL_ENUM):
|
||
{
|
||
struct dbr_ctrl_enum *pold = (struct dbr_ctrl_enum *)pbuffer;
|
||
struct {
|
||
DBRstatus
|
||
DBRenumStrs
|
||
} new;
|
||
short no_str;
|
||
dbr_enum_t *pvalue = &pold->value;
|
||
|
||
memset(pold,'\0',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,pfl);
|
||
pold->status = new.status;
|
||
pold->severity = new.severity;
|
||
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,pfl);
|
||
for(i=nRequest; i<no_elements; i++) pvalue[i] = 0;
|
||
}
|
||
break;
|
||
case(oldDBR_CTRL_CHAR):
|
||
{
|
||
struct dbr_ctrl_char *pold = (struct dbr_ctrl_char *)pbuffer;
|
||
struct {
|
||
DBRstatus
|
||
DBRunits
|
||
DBRgrLong
|
||
DBRctrlLong
|
||
DBRalLong
|
||
} new;
|
||
dbr_char_t *pvalue = &pold->value;
|
||
|
||
options=DBR_STATUS|DBR_UNITS|DBR_GR_LONG|DBR_CTRL_LONG
|
||
|DBR_AL_LONG;
|
||
nRequest=0;
|
||
status = dbGetField(paddr,DBR_UCHAR,&new,&options,&nRequest,
|
||
pfl);
|
||
pold->status = new.status;
|
||
pold->severity = new.severity;
|
||
strncpy(pold->units,new.units,MAX_UNITS_SIZE);
|
||
pold->units[MAX_UNITS_SIZE-1] = '\0';
|
||
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_UCHAR,&(pold->value),&options,
|
||
&nRequest,pfl);
|
||
for(i=nRequest; i<no_elements; i++) pvalue[i] = 0;
|
||
}
|
||
break;
|
||
case(oldDBR_CTRL_LONG):
|
||
{
|
||
struct dbr_ctrl_long *pold = (struct dbr_ctrl_long *)pbuffer;
|
||
struct {
|
||
DBRstatus
|
||
DBRunits
|
||
DBRgrLong
|
||
DBRctrlLong
|
||
DBRalLong
|
||
} new;
|
||
dbr_long_t *pvalue = &pold->value;
|
||
|
||
options=DBR_STATUS|DBR_UNITS|DBR_GR_LONG|DBR_CTRL_LONG
|
||
|DBR_AL_LONG;
|
||
nRequest=0;
|
||
status = dbGetField(paddr,DBR_LONG,&new,&options,&nRequest,pfl);
|
||
pold->status = new.status;
|
||
pold->severity = new.severity;
|
||
strncpy(pold->units,new.units,MAX_UNITS_SIZE);
|
||
pold->units[MAX_UNITS_SIZE-1] = '\0';
|
||
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_LONG,&(pold->value),&options,
|
||
&nRequest,pfl);
|
||
for(i=nRequest; i<no_elements; i++) pvalue[i] = 0;
|
||
}
|
||
break;
|
||
case(oldDBR_CTRL_DOUBLE):
|
||
{
|
||
struct dbr_ctrl_double *pold=(struct dbr_ctrl_double *)pbuffer;
|
||
struct {
|
||
DBRstatus
|
||
DBRunits
|
||
DBRprecision
|
||
DBRgrDouble
|
||
DBRctrlDouble
|
||
DBRalDouble
|
||
} new;
|
||
dbr_double_t *pvalue = &pold->value;
|
||
|
||
options=DBR_STATUS|DBR_UNITS|DBR_PRECISION|DBR_GR_DOUBLE
|
||
|DBR_CTRL_DOUBLE|DBR_AL_DOUBLE;
|
||
nRequest=0;
|
||
status = dbGetField(paddr,DBR_DOUBLE,&new,&options,&nRequest,
|
||
pfl);
|
||
pold->status = new.status;
|
||
pold->severity = new.severity;
|
||
pold->precision = new.precision;
|
||
strncpy(pold->units,new.units,MAX_UNITS_SIZE);
|
||
pold->units[MAX_UNITS_SIZE-1] = '\0';
|
||
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_DOUBLE,&(pold->value),&options,
|
||
&nRequest,pfl);
|
||
for(i=nRequest; i<no_elements; i++) pvalue[i] = 0;
|
||
}
|
||
break;
|
||
case(oldDBR_STSACK_STRING):
|
||
{
|
||
struct dbr_stsack_string *pold = (struct dbr_stsack_string *)pbuffer;
|
||
struct {
|
||
DBRstatus
|
||
} new;
|
||
DBSTRING *pvalue = (DBSTRING *)(pold->value);
|
||
|
||
options=DBR_STATUS;
|
||
nRequest=0;
|
||
status = dbGetField(paddr,DBR_STRING,&new,&options,&nRequest,
|
||
pfl);
|
||
pold->status = new.status;
|
||
pold->severity = new.severity;
|
||
pold->ackt = new.ackt;
|
||
pold->acks = new.acks;
|
||
options=0;
|
||
nRequest=no_elements;
|
||
status = dbGetField(paddr,DBR_STRING,&(pold->value[0]),
|
||
&options,&nRequest,pfl);
|
||
for(i=nRequest; i<no_elements; i++) pvalue[i][0] = 0;
|
||
}
|
||
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,paddr->precord->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:
|
||
return(-1);
|
||
}
|
||
if(status) return(-1);
|
||
return(0);
|
||
}
|
||
|
||
/* DB_PUT_FIELD put a field and convert it to the desired type */
|
||
|
||
int epicsShareAPI db_put_field(
|
||
struct dbAddr *paddr, /* where to put it */
|
||
int src_type,
|
||
const void *psrc, /* where to get it from */
|
||
int no_elements
|
||
)
|
||
{
|
||
long status;
|
||
|
||
|
||
switch(src_type) {
|
||
case(oldDBR_STRING):
|
||
status = dbPutField(paddr,DBR_STRING,psrc,(long)no_elements);
|
||
break;
|
||
/* case(oldDBR_INT): */
|
||
case(oldDBR_SHORT):
|
||
status = dbPutField(paddr,DBR_SHORT,psrc,(long)no_elements);
|
||
break;
|
||
case(oldDBR_FLOAT):
|
||
status = dbPutField(paddr,DBR_FLOAT,psrc,(long)no_elements);
|
||
break;
|
||
case(oldDBR_ENUM):
|
||
status = dbPutField(paddr,DBR_ENUM,psrc,(long)no_elements);
|
||
break;
|
||
case(oldDBR_CHAR):
|
||
status = dbPutField(paddr,DBR_UCHAR,psrc,(long)no_elements);
|
||
break;
|
||
case(oldDBR_LONG):
|
||
status = dbPutField(paddr,DBR_LONG,psrc,(long)no_elements);
|
||
break;
|
||
case(oldDBR_DOUBLE):
|
||
status = dbPutField(paddr,DBR_DOUBLE,psrc,(long)no_elements);
|
||
break;
|
||
case(oldDBR_STS_STRING):
|
||
status = dbPutField(paddr,DBR_STRING,
|
||
((struct dbr_sts_string *)psrc)->value,(long)no_elements);
|
||
break;
|
||
/* case(oldDBR_STS_INT): */
|
||
case(oldDBR_STS_SHORT):
|
||
status = dbPutField(paddr,DBR_SHORT,
|
||
&(((struct dbr_sts_short *)psrc)->value),(long)no_elements);
|
||
break;
|
||
case(oldDBR_STS_FLOAT):
|
||
status = dbPutField(paddr,DBR_FLOAT,
|
||
&(((struct dbr_sts_float *)psrc)->value),(long)no_elements);
|
||
break;
|
||
case(oldDBR_STS_ENUM):
|
||
status = dbPutField(paddr,DBR_ENUM,
|
||
&(((struct dbr_sts_enum *)psrc)->value),(long)no_elements);
|
||
break;
|
||
case(oldDBR_STS_CHAR):
|
||
status = dbPutField(paddr,DBR_UCHAR,
|
||
&(((struct dbr_sts_char *)psrc)->value),(long)no_elements);
|
||
break;
|
||
case(oldDBR_STS_LONG):
|
||
status = dbPutField(paddr,DBR_LONG,
|
||
&(((struct dbr_sts_long *)psrc)->value),(long)no_elements);
|
||
break;
|
||
case(oldDBR_STS_DOUBLE):
|
||
status = dbPutField(paddr,DBR_DOUBLE,
|
||
&(((struct dbr_sts_double *)psrc)->value),(long)no_elements);
|
||
break;
|
||
case(oldDBR_TIME_STRING):
|
||
status = dbPutField(paddr,DBR_TIME,
|
||
((struct dbr_time_string *)psrc)->value,(long)no_elements);
|
||
break;
|
||
/* case(oldDBR_TIME_INT): */
|
||
case(oldDBR_TIME_SHORT):
|
||
status = dbPutField(paddr,DBR_SHORT,
|
||
&(((struct dbr_time_short *)psrc)->value),(long)no_elements);
|
||
break;
|
||
case(oldDBR_TIME_FLOAT):
|
||
status = dbPutField(paddr,DBR_FLOAT,
|
||
&(((struct dbr_time_float *)psrc)->value),(long)no_elements);
|
||
break;
|
||
case(oldDBR_TIME_ENUM):
|
||
status = dbPutField(paddr,DBR_ENUM,
|
||
&(((struct dbr_time_enum *)psrc)->value),(long)no_elements);
|
||
break;
|
||
case(oldDBR_TIME_CHAR):
|
||
status = dbPutField(paddr,DBR_UCHAR,
|
||
&(((struct dbr_time_char *)psrc)->value),(long)no_elements);
|
||
break;
|
||
case(oldDBR_TIME_LONG):
|
||
status = dbPutField(paddr,DBR_LONG,
|
||
&(((struct dbr_time_long *)psrc)->value),(long)no_elements);
|
||
break;
|
||
case(oldDBR_TIME_DOUBLE):
|
||
status = dbPutField(paddr,DBR_DOUBLE,
|
||
&(((struct dbr_time_double *)psrc)->value),(long)no_elements);
|
||
break;
|
||
case(oldDBR_GR_STRING):
|
||
/* no struct dbr_gr_string - use dbr_sts_string instead */
|
||
status = dbPutField(paddr,DBR_STRING,
|
||
((struct dbr_sts_string *)psrc)->value,(long)no_elements);
|
||
break;
|
||
/* case(oldDBR_GR_INT): */
|
||
case(oldDBR_GR_SHORT):
|
||
status = dbPutField(paddr,DBR_SHORT,
|
||
&(((struct dbr_gr_short *)psrc)->value),(long)no_elements);
|
||
break;
|
||
case(oldDBR_GR_FLOAT):
|
||
status = dbPutField(paddr,DBR_FLOAT,
|
||
&(((struct dbr_gr_float *)psrc)->value),(long)no_elements);
|
||
break;
|
||
case(oldDBR_GR_ENUM):
|
||
status = dbPutField(paddr,DBR_ENUM,
|
||
&(((struct dbr_gr_enum *)psrc)->value),(long)no_elements);
|
||
break;
|
||
case(oldDBR_GR_CHAR):
|
||
status = dbPutField(paddr,DBR_UCHAR,
|
||
&(((struct dbr_gr_char *)psrc)->value),(long)no_elements);
|
||
break;
|
||
case(oldDBR_GR_LONG):
|
||
status = dbPutField(paddr,DBR_LONG,
|
||
&(((struct dbr_gr_long *)psrc)->value),(long)no_elements);
|
||
break;
|
||
case(oldDBR_GR_DOUBLE):
|
||
status = dbPutField(paddr,DBR_DOUBLE,
|
||
&(((struct dbr_gr_double *)psrc)->value),(long)no_elements);
|
||
break;
|
||
case(oldDBR_CTRL_STRING):
|
||
/* no struct dbr_ctrl_string - use dbr_sts_string instead */
|
||
status = dbPutField(paddr,DBR_STRING,
|
||
((struct dbr_sts_string *)psrc)->value,(long)no_elements);
|
||
break;
|
||
/* case(oldDBR_CTRL_INT): */
|
||
case(oldDBR_CTRL_SHORT):
|
||
status = dbPutField(paddr,DBR_SHORT,
|
||
&(((struct dbr_ctrl_short *)psrc)->value),(long)no_elements);
|
||
break;
|
||
case(oldDBR_CTRL_FLOAT):
|
||
status = dbPutField(paddr,DBR_FLOAT,
|
||
&(((struct dbr_ctrl_float *)psrc)->value),(long)no_elements);
|
||
break;
|
||
case(oldDBR_CTRL_ENUM):
|
||
status = dbPutField(paddr,DBR_ENUM,
|
||
&(((struct dbr_ctrl_enum *)psrc)->value),(long)no_elements);
|
||
break;
|
||
case(oldDBR_CTRL_CHAR):
|
||
status = dbPutField(paddr,DBR_UCHAR,
|
||
&(((struct dbr_ctrl_char *)psrc)->value),(long)no_elements);
|
||
break;
|
||
case(oldDBR_CTRL_LONG):
|
||
status = dbPutField(paddr,DBR_LONG,
|
||
&(((struct dbr_ctrl_long *)psrc)->value),(long)no_elements);
|
||
break;
|
||
case(oldDBR_CTRL_DOUBLE):
|
||
status = dbPutField(paddr,DBR_DOUBLE,
|
||
&(((struct dbr_ctrl_double *)psrc)->value),(long)no_elements);
|
||
break;
|
||
case(oldDBR_PUT_ACKT):
|
||
status = dbPutField(paddr,DBR_PUT_ACKT,psrc,(long)no_elements);
|
||
break;
|
||
case(oldDBR_PUT_ACKS):
|
||
status = dbPutField(paddr,DBR_PUT_ACKS,psrc,(long)no_elements);
|
||
break;
|
||
|
||
default:
|
||
return(-1);
|
||
}
|
||
if(status) return(-1);
|
||
return(0);
|
||
}
|
||
|
||
|
||
epicsShareFunc int epicsShareAPI dbPutNotifyMapType (putNotify *ppn, short oldtype)
|
||
{
|
||
switch(oldtype) {
|
||
case(oldDBR_STRING):
|
||
ppn->dbrType = DBR_STRING;
|
||
break;
|
||
/* case(oldDBR_INT): */
|
||
case(oldDBR_SHORT):
|
||
ppn->dbrType = DBR_SHORT;
|
||
break;
|
||
case(oldDBR_FLOAT):
|
||
ppn->dbrType = DBR_FLOAT;
|
||
break;
|
||
case(oldDBR_ENUM):
|
||
ppn->dbrType = DBR_ENUM;
|
||
break;
|
||
case(oldDBR_CHAR):
|
||
ppn->dbrType = DBR_UCHAR;
|
||
break;
|
||
case(oldDBR_LONG):
|
||
ppn->dbrType = DBR_LONG;
|
||
break;
|
||
case(oldDBR_DOUBLE):
|
||
ppn->dbrType = DBR_DOUBLE;
|
||
break;
|
||
case(oldDBR_PUT_ACKT):
|
||
ppn->dbrType = DBR_PUT_ACKT;
|
||
break;
|
||
case(oldDBR_PUT_ACKS):
|
||
ppn->dbrType = DBR_PUT_ACKS;
|
||
break;
|
||
default:
|
||
return(-1);
|
||
}
|
||
return(0);
|
||
}
|