dbStaticPvt.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	dbLinkInfo
struct	dbPathNode
struct	dbGuiGroup
struct	PVDENTRY

Typedefs
typedef struct dbLinkInfo	dbLinkInfo
typedef struct dbPathNode	dbPathNode
typedef struct dbGuiGroup	dbGuiGroup

Functions
dbDeviceMenu *	dbGetDeviceMenu (DBENTRY *pdbentry)
void	dbFreeLinkContents (struct link *plink)
void	dbFreePath (DBBASE *pdbbase)
int	dbIsMacroOk (DBENTRY *pdbentry)
long	dbAllocRecord (DBENTRY *pdbentry, const char *precordName)
long	dbFreeRecord (DBENTRY *pdbentry)
long	dbGetFieldAddress (DBENTRY *pdbentry)
char *	dbRecordName (DBENTRY *pdbentry)
char *	dbGetStringNum (DBENTRY *pdbentry)
long	dbPutStringNum (DBENTRY *pdbentry, const char *pstring)
long	dbInitRecordLinks (dbRecordType *rtyp, struct dbCommon *prec)
epicsShareFunc long	dbParseLink (const char *str, short ftype, dbLinkInfo *pinfo)
long	dbCanSetLink (DBLINK *plink, dbLinkInfo *pinfo, devSup *devsup)
long	dbSetLink (DBLINK *plink, dbLinkInfo *pinfo, devSup *dset)
epicsShareFunc void	dbFreeLinkInfo (dbLinkInfo *pinfo)
epicsShareFunc int	dbPvdTableSize (int size)
void	dbPvdInitPvt (DBBASE *pdbbase)
PVDENTRY *	dbPvdFind (DBBASE *pdbbase, const char *name, size_t lenname)
PVDENTRY *	dbPvdAdd (DBBASE *pdbbase, dbRecordType *precordType, dbRecordNode *precnode)
void	dbPvdDelete (DBBASE *pdbbase, dbRecordNode *precnode)
void	dbPvdFreeMem (DBBASE *pdbbase)

Variables
int	dbStaticDebug

Typedef Documentation

typedef struct dbGuiGroup dbGuiGroup

typedef struct dbLinkInfo dbLinkInfo

typedef struct dbPathNode dbPathNode

Function Documentation

long dbAllocRecord	(	DBENTRY *	pdbentry,
		const char *	precordName
	)

Definition at line 69 of file dbStaticRun.c.

{
    dbRecordType    *pdbRecordType = pdbentry->precordType;
    dbRecordNode    *precnode = pdbentry->precnode;
    dbFldDes        *pflddes;
    int             i;
    dbCommonPvt     *ppvt;
    dbCommon        *precord;
    char            *pfield;

    if(!pdbRecordType) return(S_dbLib_recordTypeNotFound);
    if(!precnode) return(S_dbLib_recNotFound);
    if(pdbRecordType->rec_size == 0) {
        printf("\t*** Did you run x_RegisterRecordDeviceDriver(pdbbase) yet? ***\n");
        epicsPrintf("dbAllocRecord(%s) with %s rec_size = 0\n",
                    precordName, pdbRecordType->name);
        return(S_dbLib_noRecSup);
    } else if(pdbRecordType->rec_size<sizeof(*precord)) {
        printf("\t*** Recordtype %s must include \"dbCommon.dbd\"\n", pdbRecordType->name);
        epicsPrintf("dbAllocRecord(%s) with %s rec_size = %d\n",
                    precordName, pdbRecordType->name, pdbRecordType->rec_size);
        return(S_dbLib_noRecSup);
    }
    ppvt = dbCalloc(1, offsetof(dbCommonPvt, common) + pdbRecordType->rec_size);
    precord = &ppvt->common;
    ppvt->recnode = precnode;
    precord->rdes = pdbRecordType;
    precnode->precord = precord;
    pflddes = pdbRecordType->papFldDes[0];
    if(!pflddes) {
        epicsPrintf("dbAllocRecord pflddes for NAME not found\n");
        return(S_dbLib_flddesNotFound);
    }
    assert(pflddes->offset == 0);
    assert(pflddes->size == sizeof(precord->name));
    if(strlen(precordName) >= sizeof(precord->name)) {
        epicsPrintf("dbAllocRecord: NAME(%s) too long\n",precordName);
        return(S_dbLib_nameLength);
    }
    strcpy(precord->name, precordName);
    for(i=1; i<pdbRecordType->no_fields; i++) {

        pflddes = pdbRecordType->papFldDes[i];
        if(!pflddes) continue;
        pfield = (char*)precord + pflddes->offset;
        pdbentry->pfield = (void *)pfield;
        pdbentry->pflddes = pflddes;
        pdbentry->indfield = i;
        switch(pflddes->field_type) {
        case DBF_STRING:
            if(pflddes->initial)  {
                if(strlen(pflddes->initial) >= pflddes->size) {
                    epicsPrintf("initial size > size for %s.%s\n",
                                pdbRecordType->name,pflddes->name);
                } else {
                    strcpy(pfield,pflddes->initial);
                }
            }
            break;
        case DBF_CHAR:
        case DBF_UCHAR:
        case DBF_SHORT:
        case DBF_USHORT:
        case DBF_LONG:
        case DBF_ULONG:
        case DBF_INT64:
        case DBF_UINT64:
        case DBF_FLOAT:
        case DBF_DOUBLE:
        case DBF_ENUM:
        case DBF_MENU:
            if(pflddes->initial) {
                long status;

                status = dbPutStringNum(pdbentry,pflddes->initial);
                if(status)
                    epicsPrintf("Error initializing %s.%s initial %s\n",
                                pdbRecordType->name,pflddes->name,pflddes->initial);
            }
            break;
        case DBF_DEVICE:
            if(!pflddes->ftPvt) dbGetDeviceMenu(pdbentry);
            break;
        case DBF_INLINK:
        case DBF_OUTLINK:
        case DBF_FWDLINK: {
            DBLINK *plink = (DBLINK *)pfield;

            plink->type = CONSTANT;
            if(pflddes->initial) {
                plink->text =
                        dbCalloc(strlen(pflddes->initial)+1,sizeof(char));
                strcpy(plink->text,pflddes->initial);
            }
        }
            break;
        case DBF_NOACCESS:
            break;
        default:
            epicsPrintf("dbAllocRecord: Illegal field type\n");
        }
    }
    return(0);
}

long dbCanSetLink	(	DBLINK *	plink,
		dbLinkInfo *	pinfo,
		devSup *	devsup
	)

Definition at line 2375 of file dbStaticLib.c.

{
    /* Release pinfo resources on failure */
    int expected_type = devsup ? devsup->link_type : CONSTANT;

    if (pinfo->ltype == expected_type)
        return 0;

    switch (pinfo->ltype) {
    case CONSTANT:
    case JSON_LINK:
    case PV_LINK:
        if (expected_type == CONSTANT ||
            expected_type == JSON_LINK ||
            expected_type == PV_LINK)
            return 0;
    default:
        dbFreeLinkInfo(pinfo);
        return 1;
    }
}

void dbFreeLinkContents

(

struct link *

plink

)

Definition at line 109 of file dbStaticLib.c.

{
    char *parm = NULL;

    switch(plink->type) {
        case CONSTANT: free((void *)plink->value.constantStr); break;
        case MACRO_LINK: free((void *)plink->value.macro_link.macroStr); break;
        case PV_LINK: free((void *)plink->value.pv_link.pvname); break;
        case JSON_LINK:
            dbJLinkFree(plink->value.json.jlink);
            parm = plink->value.json.string;
            break;
        case VME_IO: parm = plink->value.vmeio.parm; break;
        case CAMAC_IO: parm = plink->value.camacio.parm; break;
        case AB_IO: parm = plink->value.abio.parm; break;
        case GPIB_IO: parm = plink->value.gpibio.parm; break;
        case BITBUS_IO: parm = plink->value.bitbusio.parm;break;
        case INST_IO: parm = plink->value.instio.string; break;
        case BBGPIB_IO: parm = plink->value.bbgpibio.parm;break;
        case RF_IO: break;
        case VXI_IO: parm = plink->value.vxiio.parm; break;
        default:
         epicsPrintf("dbFreeLink called but link type %d unknown\n", plink->type);
    }
    if(parm && (parm != pNullString)) free((void *)parm);
    if(plink->text) free(plink->text);
    plink->lset = NULL;
    plink->text = NULL;
    memset(&plink->value, 0, sizeof(union value));
}

epicsShareFunc void dbFreeLinkInfo

(

dbLinkInfo *

pinfo

)

Definition at line 2216 of file dbStaticLib.c.

{
    if (pinfo->ltype == JSON_LINK) {
        dbJLinkFree(pinfo->jlink);
        pinfo->jlink = NULL;
    }
    free(pinfo->target);
    pinfo->target = NULL;
}

void dbFreePath

(

DBBASE *

pdbbase

)

Definition at line 140 of file dbStaticLib.c.

{
    ELLLIST     *ppathList;
    dbPathNode  *pdbPathNode;

    if(!pdbbase) return;
    ppathList = (ELLLIST *)pdbbase->pathPvt;
    if(!ppathList) return;
    while((pdbPathNode = (dbPathNode *)ellFirst(ppathList))) {
        ellDelete(ppathList,&pdbPathNode->node);
        free((void *)pdbPathNode->directory);
        free((void *)pdbPathNode);
    }
    free((void *)ppathList);
    pdbbase->pathPvt = 0;
    return;
}

long dbFreeRecord

(

DBENTRY *

pdbentry

)

Definition at line 174 of file dbStaticRun.c.

{
    dbRecordType *pdbRecordType = pdbentry->precordType;
    dbRecordNode *precnode = pdbentry->precnode;

    if(!pdbRecordType) return(S_dbLib_recordTypeNotFound);
    if(!precnode) return(S_dbLib_recNotFound);
    if(!precnode->precord) return(S_dbLib_recNotFound);
    free(dbRec2Pvt(precnode->precord));
    precnode->precord = NULL;
    return(0);
}

dbDeviceMenu* dbGetDeviceMenu

(

DBENTRY *

pdbentry

)

Definition at line 336 of file dbStaticLib.c.

{
    dbRecordType    *precordType = pdbentry->precordType;
    dbFldDes        *pflddes = pdbentry->pflddes;
    dbDeviceMenu    *pdbDeviceMenu;
    devSup          *pdevSup;
    int             ind;
    int             nChoice;

    if(!precordType) return(NULL);
    if(!pflddes) return(NULL);
    if(pflddes->field_type!=DBF_DEVICE) return(NULL);
    if(pflddes->ftPvt){
        pdbDeviceMenu = (dbDeviceMenu *)pflddes->ftPvt;
        if(pdbDeviceMenu->nChoice == ellCount(&precordType->devList))
            return(pdbDeviceMenu);
        free((void *)pdbDeviceMenu->papChoice);
        free((void *)pdbDeviceMenu);
        pflddes->ftPvt = NULL;
    }
    nChoice = ellCount(&precordType->devList);
    if(nChoice <= 0) return(NULL);
    pdbDeviceMenu = dbCalloc(1,sizeof(dbDeviceMenu));
    pdbDeviceMenu->nChoice = nChoice;
    pdbDeviceMenu->papChoice = dbCalloc(pdbDeviceMenu->nChoice,sizeof(char *));
    pdevSup = (devSup *)ellFirst(&precordType->devList);
    ind = 0;
    while(pdevSup) {
        pdbDeviceMenu->papChoice[ind] = pdevSup->choice;
        ind++;
        pdevSup = (devSup *)ellNext(&pdevSup->node);
    }
    pflddes->ftPvt = pdbDeviceMenu;
    return(pdbDeviceMenu);
}

long dbGetFieldAddress

(

DBENTRY *

pdbentry

)

Definition at line 187 of file dbStaticRun.c.

{
    dbRecordType *pdbRecordType = pdbentry->precordType;
    dbRecordNode *precnode = pdbentry->precnode;
    dbFldDes    *pflddes = pdbentry->pflddes;

    if(!pdbRecordType) return(S_dbLib_recordTypeNotFound);
    if(!precnode) return(S_dbLib_recNotFound);
    if(!pflddes) return(S_dbLib_flddesNotFound);
    if(!precnode->precord) return(0);
    pdbentry->pfield = ((char *)precnode->precord) + pflddes->offset;
    return(0);
}

char* dbGetStringNum

(

DBENTRY *

pdbentry

)

Definition at line 2040 of file dbStaticLib.c.

{
    dbFldDes    *pflddes = pdbentry->pflddes;
    void        *pfield = pdbentry->pfield;
    char        *message;
    unsigned char cvttype;

    /* the following assumes that messagesize is large enough
     * to hold the base 10 encoded value of a 32-bit integer.
     */
    message = getpMessage(pdbentry);
    cvttype = pflddes->base;
    switch (pflddes->field_type) {
    case DBF_CHAR:
        if (cvttype == CT_DECIMAL)
            cvtCharToString(*(char *) pfield, message);
        else
            ulongToHexString(*(char *) pfield, message);
        break;
    case DBF_UCHAR:
        if (cvttype==CT_DECIMAL)
            cvtUcharToString(*(epicsUInt8 *) pfield, message);
        else
            ulongToHexString(*(epicsUInt8 *) pfield, message);
        break;
    case DBF_SHORT:
        if (cvttype==CT_DECIMAL)
            cvtShortToString(*(epicsInt16 *) pfield, message);
        else
            ulongToHexString(*(epicsInt16 *) pfield, message);
        break;
    case DBF_USHORT:
    case DBF_ENUM:
        if (cvttype==CT_DECIMAL)
            cvtUshortToString(*(epicsUInt16 *) pfield, message);
        else
            ulongToHexString(*(epicsUInt16 *) pfield, message);
        break;
    case DBF_LONG:
        if (cvttype==CT_DECIMAL)
            cvtLongToString(*(epicsInt32 *) pfield, message);
        else
            ulongToHexString(*(epicsInt32 *) pfield, message);
        break;
    case DBF_ULONG:
        if (cvttype==CT_DECIMAL)
            cvtUlongToString(*(epicsUInt32 *) pfield, message);
        else
            ulongToHexString(*(epicsUInt32 *) pfield, message);
        break;
    case DBF_INT64:
        if (cvttype==CT_DECIMAL)
            cvtInt64ToString(*(epicsInt64 *) pfield, message);
        else
            cvtInt64ToHexString(*(epicsInt64 *) pfield, message);
        break;
    case DBF_UINT64:
        if (cvttype==CT_DECIMAL)
            cvtUInt64ToString(*(epicsUInt32 *) pfield, message);
        else
            cvtUInt64ToHexString(*(epicsUInt32 *) pfield, message);
        break;
    case DBF_FLOAT:
        floatToString(*(epicsFloat32 *) pfield, message);
        break;
    case DBF_DOUBLE:
        doubleToString(*(epicsFloat64 *) pfield, message);
        break;
    case DBF_MENU:
        {
            dbMenu *pdbMenu = (dbMenu *)pflddes->ftPvt;
            epicsEnum16 choice_ind;
            char *pchoice;

            if (!pfield) {
                dbMsgCpy(pdbentry, "Field not found");
                return message;
            }
            choice_ind = *((epicsEnum16 *) pdbentry->pfield);
            if (!pdbMenu || choice_ind < 0 || choice_ind >= pdbMenu->nChoice)
                return NULL;
            pchoice = pdbMenu->papChoiceValue[choice_ind];
            dbMsgCpy(pdbentry, pchoice);
        }
        break;
    case DBF_DEVICE:
        {
            dbDeviceMenu *pdbDeviceMenu;
            epicsEnum16 choice_ind;
            char *pchoice;

            if (!pfield) {
                dbMsgCpy(pdbentry, "Field not found");
                return message;
            }
            pdbDeviceMenu = dbGetDeviceMenu(pdbentry);
            if (!pdbDeviceMenu)
                return NULL;
            choice_ind = *((epicsEnum16 *) pdbentry->pfield);
            if (choice_ind<0 || choice_ind>=pdbDeviceMenu->nChoice)
                return NULL;
            pchoice = pdbDeviceMenu->papChoice[choice_ind];
            dbMsgCpy(pdbentry, pchoice);
        }
        break;
    default:
        return NULL;
    }
    return message;
}

long dbInitRecordLinks	(	dbRecordType *	rtyp,
		struct dbCommon *	prec
	)

Definition at line 2151 of file dbStaticLib.c.

{
    short i;

    for (i=0; i<rtyp->no_links; i++) {
        dbLinkInfo link_info;
        dbFldDes *pflddes = rtyp->papFldDes[rtyp->link_ind[i]];
        DBLINK *plink = (DBLINK *)(((char *)prec) + pflddes->offset);
        devSup *devsup = NULL;

        plink->precord = prec;

        /* link fields are zero'd on allocation.
         * so are effectively CONSTANT, but with constantStr==NULL.
         * Here we initialize them to have the correct link type,
         * with zero values and empty (but non-NULL) strings.
         */

        if(pflddes->isDevLink) {
            devsup = (devSup *)ellNth(&rtyp->devList, prec->dtyp+1);
        }
        if(devsup)
            plink->type = devsup->link_type;
        else
            plink->type = CONSTANT;

        switch (plink->type) {
        /* constantStr is allowed to remain NULL if plink->text==NULL
         * constantStr==NULL has special meaning in recGblInitConstantLink()
         */
        case CONSTANT: plink->value.constantStr = NULL; break;
        case PV_LINK:  plink->value.pv_link.pvname = callocMustSucceed(1, 1, "init PV_LINK"); break;
        case JSON_LINK: plink->value.json.string = pNullString; break;
        case VME_IO: plink->value.vmeio.parm = pNullString; break;
        case CAMAC_IO: plink->value.camacio.parm = pNullString; break;
        case AB_IO: plink->value.abio.parm = pNullString; break;
        case GPIB_IO: plink->value.gpibio.parm = pNullString; break;
        case BITBUS_IO: plink->value.bitbusio.parm = pNullString; break;
        case INST_IO: plink->value.instio.string = pNullString; break;
        case BBGPIB_IO: plink->value.bbgpibio.parm = pNullString; break;
        case VXI_IO: plink->value.vxiio.parm = pNullString; break;
        }

        if(!plink->text)
            continue;

        if(dbParseLink(plink->text, pflddes->field_type, &link_info)!=0) {
            /* This was already parsed once when ->text was set.
             * Any syntax error messages were printed at that time.
             */

        } else if(dbCanSetLink(plink, &link_info, devsup)!=0) {
            errlogPrintf("Error: %s.%s: can't initialize link type %d with \"%s\" (type %d)\n",
                         prec->name, pflddes->name, plink->type, plink->text, link_info.ltype);

        } else if(dbSetLink(plink, &link_info, devsup)) {
            errlogPrintf("Error: %s.%s: failed to initialize link type %d with \"%s\" (type %d)\n",
                         prec->name, pflddes->name, plink->type, plink->text, link_info.ltype);
        }
        free(plink->text);
        plink->text = NULL;
    }
    return 0;
}

int dbIsMacroOk

(

DBENTRY *

pdbentry

)

Definition at line 217 of file dbStaticRun.c.

{ return(FALSE); }

epicsShareFunc long dbParseLink	(	const char *	str,
		short	ftype,
		dbLinkInfo *	pinfo
	)

Definition at line 2226 of file dbStaticLib.c.

{
    char *pstr;
    size_t len;
    double value;

    memset(pinfo, 0, sizeof(*pinfo));

    /* Strip leading white space */
    while (*str && isspace((int)*str)) str++;

    len = strlen(str);
    /* Strip trailing white space */
    while (len > 0 && isspace((int)str[len-1])) len--;

    pstr = malloc(len + 1);
    if (!pstr)
        return S_dbLib_outMem;
    pinfo->target = pstr;

    /* Check for Instrument I/O links */
    if (*str == '@') {
        pinfo->ltype = INST_IO;

        /* Store everything after the '@' */
        memcpy(pstr, str+1, --len);
        pstr[len] = '\0';
        return 0;
    }

    /* Store the stripped string */
    memcpy(pstr, str, len);
    pstr[len] = '\0';

    /* Check for braces => JSON */
    if (*str == '{' && str[len-1] == '}') {
        if (dbJLinkParse(str, len, ftype, &pinfo->jlink))
            goto fail;

        pinfo->ltype = JSON_LINK;
        return 0;
    }

    /* Check for other HW link types */
    if (*pstr == '#') {
        int ret;
        char junk = 0;
        char *parm = strchr(pstr, '@'); /* find start of parm string */

        if (parm) {
            *parm++ = '\0'; /* isolate the parm string for later */
            len -= (parm - pstr);
        }

        /* generalized extraction of ID charactor and integer pairs (eg. "#C15 S14") */
        ret = sscanf(pinfo->target, "# %c%d %c%d %c%d %c%d %c%d %c",
                     &pinfo->hwid[0], &pinfo->hwnums[0],
                     &pinfo->hwid[1], &pinfo->hwnums[1],
                     &pinfo->hwid[2], &pinfo->hwnums[2],
                     &pinfo->hwid[3], &pinfo->hwnums[3],
                     &pinfo->hwid[4], &pinfo->hwnums[4],
                     &junk);

        /* ret<0 when pattern not matched
         * ret==11 when extra non-space before '@'.
         * ret is odd when a number is missing
         */
        if (ret<0 || ret>10 || ret%2==1) goto fail;

        if      (strcmp(pinfo->hwid, "CS")==0)    pinfo->ltype = VME_IO;
        else if (strcmp(pinfo->hwid, "BCN")==0)   pinfo->ltype = CAMAC_IO;
        else if (strcmp(pinfo->hwid, "BCNA")==0)  pinfo->ltype = CAMAC_IO;
        else if (strcmp(pinfo->hwid, "BCNF")==0)  pinfo->ltype = CAMAC_IO;
        else if (strcmp(pinfo->hwid, "BCNAF")==0) pinfo->ltype = CAMAC_IO;
        else if (strcmp(pinfo->hwid, "RMDE")==0)  pinfo->ltype = RF_IO;
        else if (strcmp(pinfo->hwid, "LACS")==0)  pinfo->ltype = AB_IO;
        else if (strcmp(pinfo->hwid, "LA")==0)    pinfo->ltype = GPIB_IO;
        else if (strcmp(pinfo->hwid, "LNPS")==0)  pinfo->ltype = BITBUS_IO;
        else if (strcmp(pinfo->hwid, "LBG")==0)   pinfo->ltype = BBGPIB_IO;
        else if (strcmp(pinfo->hwid, "VCS")==0)   pinfo->ltype = VXI_IO;
        else if (strcmp(pinfo->hwid, "VS")==0)    pinfo->ltype = VXI_IO;
        else goto fail;

        if (pinfo->ltype != RF_IO) {
            if (!parm) {
                pinfo->target[0] = '\0';
            } else {
                /* move parm string to beginning of buffer */
                memmove(pinfo->target, parm, len + 1);
            }
        } else if (!parm && pinfo->ltype == RF_IO) {
            /* RF_IO, the string isn't needed at all */
            free(pinfo->target);
            pinfo->target = NULL;
        }
        else goto fail;

        return 0;
    }

    /* Link is a constant if empty or it holds just a number */
    if (len == 0 || epicsParseDouble(pstr, &value, NULL) == 0) {
        pinfo->ltype = CONSTANT;
        return 0;
    }

    /* Link may be an array constant */
    if (pstr[0] == '[' && pstr[len-1] == ']' &&
        (strchr(pstr, ',') || strchr(pstr, '"'))) {
        pinfo->ltype = CONSTANT;
        return 0;
    }

    pinfo->ltype = PV_LINK;
    pstr = strchr(pstr, ' '); /* find start of link modifiers (can't be seperated by tabs) */
    if (pstr) {
        *pstr++ = '\0'; /* isolate modifiers. pinfo->target is PV name only for re-use in struct pv_link */

        /* Space seperation of modifiers isn't required, and other chars are ignored.
         * Order of comparisons resolves ambiguity by checking for
         * longer matches first.
         * eg. "QQCPPXMSITT" is pvlOptCPP|pvlOptMSI
         */

        if (strstr(pstr, "NPP")) pinfo->modifiers = 0;
        else if (strstr(pstr, "CPP")) pinfo->modifiers = pvlOptCPP;
        else if (strstr(pstr, "PP")) pinfo->modifiers = pvlOptPP;
        else if (strstr(pstr, "CA")) pinfo->modifiers = pvlOptCA;
        else if (strstr(pstr, "CP")) pinfo->modifiers = pvlOptCP;

        if (strstr(pstr, "NMS")) pinfo->modifiers |= pvlOptNMS;
        else if (strstr(pstr, "MSI")) pinfo->modifiers |= pvlOptMSI;
        else if (strstr(pstr, "MSS")) pinfo->modifiers |= pvlOptMSS;
        else if (strstr(pstr, "MS")) pinfo->modifiers |= pvlOptMS;

        /* filter modifiers based on link type */
        switch(ftype) {
        case DBF_INLINK: /* accept all */ break;
        case DBF_OUTLINK: pinfo->modifiers &= ~pvlOptCPP; break;
        case DBF_FWDLINK: pinfo->modifiers &= pvlOptCA; break;
        }
    }

    return 0;
fail:
    dbFreeLinkInfo(pinfo);
    return S_dbLib_badField;
}

long dbPutStringNum	(	DBENTRY *	pdbentry,
		const char *	pstring
	)

Definition at line 383 of file dbStaticRun.c.

{
    dbFldDes *pflddes = pdbentry->pflddes;
    void *pfield = pdbentry->pfield;
    long status;
    epicsUInt64 u64;
    epicsInt64 i64;

    if (!pfield)
        return S_dbLib_fieldNotFound;

    /* empty string is the same as writing numeric zero */
    if (pstring[0] == '\0')
        pstring = "0";

    switch (pflddes->field_type) {
    case DBF_CHAR:
        if (dbConvertStrict)
            return epicsParseInt8(pstring, pfield, 0, NULL);
        goto lax_signed;

    case DBF_SHORT:
        if (dbConvertStrict)
            return epicsParseInt16(pstring, pfield, 0, NULL);
        goto lax_signed;

    case DBF_LONG:
        if (dbConvertStrict)
            return epicsParseInt32(pstring, pfield, 0, NULL);
        goto lax_signed;

    case DBF_INT64:
        if (dbConvertStrict)
            return epicsParseInt64(pstring, pfield, 0, NULL);

    lax_signed:
        status = epicsParseInt64(pstring, &i64, 0, NULL);
        if (status)
            return status;

        switch (pflddes->field_type) {
        case DBF_CHAR:  *(epicsInt8 *)pfield = (epicsInt8) i64; break;
        case DBF_SHORT: *(epicsInt16*)pfield = (epicsInt16)i64; break;
        case DBF_LONG:  *(epicsInt32*)pfield = (epicsInt32)i64; break;
        case DBF_INT64: *(epicsInt64*)pfield = (epicsInt64)i64; break;
        default: break;
        }
        return status;

    case DBF_UCHAR:
        if (dbConvertStrict)
            return epicsParseUInt8(pstring, pfield, 0, NULL);
        goto lax_unsigned;

    case DBF_ENUM:
    case DBF_USHORT:
        if (dbConvertStrict)
            return epicsParseUInt16(pstring, pfield, 0, NULL);
        goto lax_unsigned;

    case DBF_ULONG:
        if (dbConvertStrict)
            return epicsParseUInt32(pstring, pfield, 0, NULL);
        goto lax_unsigned;

    case DBF_UINT64:
        if (dbConvertStrict)
            return epicsParseUInt64(pstring, pfield, 0, NULL);

    lax_unsigned:
        status = epicsParseUInt64(pstring, &u64, 0, NULL);
        if (status)
            return status;

        switch (pflddes->field_type) {
        case DBF_UCHAR:  *(epicsUInt8 *)pfield = (epicsInt8) u64; break;
        case DBF_ENUM:
        case DBF_USHORT: *(epicsUInt16*)pfield = (epicsInt16)u64; break;
        case DBF_ULONG:  *(epicsUInt32*)pfield = (epicsInt32)u64; break;
        case DBF_UINT64: *(epicsUInt64*)pfield = (epicsInt64)u64; break;
        default: break;
        }
        return status;

    case DBF_FLOAT:
        return epicsParseFloat32(pstring, pfield, NULL);

    case DBF_DOUBLE:
        return epicsParseFloat64(pstring, pfield, NULL);

    case DBF_MENU:
    case DBF_DEVICE: {
            epicsEnum16 *field = (epicsEnum16 *) pfield;
            int index = dbGetMenuIndexFromString(pdbentry, pstring);

            if (index < 0) {
                epicsEnum16 value;
                long status = epicsParseUInt16(pstring, &value, 0, NULL);

                if (status)
                    return status;

                index = dbGetNMenuChoices(pdbentry);
                if (value > index && index > 0 && value < USHRT_MAX)
                    return S_dbLib_badField;

                *field = value;
            }
            else
                *field = index;
            return 0;
        }

    default:
        return S_dbLib_badField;
    }
}

PVDENTRY* dbPvdAdd	(	DBBASE *	pdbbase,
		dbRecordType *	precordType,
		dbRecordNode *	precnode
	)

Definition at line 105 of file dbPvdLib.c.

{
    dbPvd *ppvd = pdbbase->ppvd;
    dbPvdBucket *pbucket;
    PVDENTRY *ppvdNode;
    char *name = precnode->recordname;
    unsigned int h;

    h = epicsStrHash(name, 0) & ppvd->mask;
    pbucket = ppvd->buckets[h];
    if (pbucket == NULL) {
        pbucket = dbCalloc(1, sizeof(dbPvdBucket));
        ellInit(&pbucket->list);
        pbucket->lock = epicsMutexCreate();
        ppvd->buckets[h] = pbucket;
    }

    epicsMutexMustLock(pbucket->lock);
    ppvdNode = (PVDENTRY *) ellFirst(&pbucket->list);
    while (ppvdNode) {
        if (strcmp(name, ppvdNode->precnode->recordname) == 0) {
            epicsMutexUnlock(pbucket->lock);
            return NULL;
        }
        ppvdNode = (PVDENTRY *) ellNext((ELLNODE *)ppvdNode);
    }
    ppvdNode = dbCalloc(1, sizeof(PVDENTRY));
    ppvdNode->precordType = precordType;
    ppvdNode->precnode = precnode;
    ellAdd(&pbucket->list, (ELLNODE *)ppvdNode);
    epicsMutexUnlock(pbucket->lock);
    return ppvdNode;
}

void dbPvdDelete	(	DBBASE *	pdbbase,
		dbRecordNode *	precnode
	)

Definition at line 140 of file dbPvdLib.c.

{
    dbPvd *ppvd = pdbbase->ppvd;
    dbPvdBucket *pbucket;
    PVDENTRY *ppvdNode;
    char *name = precnode->recordname;

    pbucket = ppvd->buckets[epicsStrHash(name, 0) & ppvd->mask];
    if (pbucket == NULL) return;

    epicsMutexMustLock(pbucket->lock);
    ppvdNode = (PVDENTRY *) ellFirst(&pbucket->list);
    while (ppvdNode) {
        if (ppvdNode->precnode &&
            ppvdNode->precnode->recordname &&
            strcmp(name, ppvdNode->precnode->recordname) == 0) {
            ellDelete(&pbucket->list, (ELLNODE *)ppvdNode);
            free(ppvdNode);
            break;
        }
        ppvdNode = (PVDENTRY *) ellNext((ELLNODE *)ppvdNode);
    }
    epicsMutexUnlock(pbucket->lock);
    return;
}

PVDENTRY* dbPvdFind	(	DBBASE *	pdbbase,
		const char *	name,
		size_t	lenname
	)

Definition at line 82 of file dbPvdLib.c.

{
    dbPvd *ppvd = pdbbase->ppvd;
    dbPvdBucket *pbucket;
    PVDENTRY *ppvdNode;

    pbucket = ppvd->buckets[epicsMemHash(name, lenName, 0) & ppvd->mask];
    if (pbucket == NULL) return NULL;

    epicsMutexMustLock(pbucket->lock);
    ppvdNode = (PVDENTRY *) ellFirst(&pbucket->list);
    while (ppvdNode) {
        const char *recordname = ppvdNode->precnode->recordname;

        if (strncmp(name, recordname, lenName) == 0 &&
            strlen(recordname) == lenName)
            break;
        ppvdNode = (PVDENTRY *) ellNext((ELLNODE *)ppvdNode);
    }
    epicsMutexUnlock(pbucket->lock);
    return ppvdNode;
}

void dbPvdFreeMem

(

DBBASE *

pdbbase

)

Definition at line 166 of file dbPvdLib.c.

{
    dbPvd *ppvd = pdbbase->ppvd;
    unsigned int h;

    if (ppvd == NULL) return;
    pdbbase->ppvd = NULL;

    for (h = 0; h < ppvd->size; h++) {
        dbPvdBucket *pbucket = ppvd->buckets[h];
        PVDENTRY *ppvdNode;

        if (pbucket == NULL) continue;
        epicsMutexMustLock(pbucket->lock);
        ppvd->buckets[h] = NULL;
        while ((ppvdNode = (PVDENTRY *) ellFirst(&pbucket->list))) {
            ellDelete(&pbucket->list, (ELLNODE *)ppvdNode);
            free(ppvdNode);
        }
        epicsMutexUnlock(pbucket->lock);
        epicsMutexDestroy(pbucket->lock);
        free(pbucket);
    }
    free(ppvd->buckets);
    free(ppvd);
}

void dbPvdInitPvt

(

DBBASE *

pdbbase

)

Definition at line 63 of file dbPvdLib.c.

{
    dbPvd *ppvd;

    if (pdbbase->ppvd) return;

    if (dbPvdHashTableSize == 0) {
        dbPvdHashTableSize = DEFAULT_SIZE;
    }

    ppvd = (dbPvd *)dbMalloc(sizeof(dbPvd));
    ppvd->size    = dbPvdHashTableSize;
    ppvd->mask    = dbPvdHashTableSize - 1;
    ppvd->buckets = dbCalloc(ppvd->size, sizeof(dbPvdBucket *));

    pdbbase->ppvd = ppvd;
    return;
}

epicsShareFunc int dbPvdTableSize

(

int

size

)

Definition at line 46 of file dbPvdLib.c.

{
    if (size & (size - 1)) {
        printf("dbPvdTableSize: %d is not a power of 2\n", size);
        return -1;
    }

    if (size < MIN_SIZE)
        size = MIN_SIZE;

    if (size > MAX_SIZE)
        size = MAX_SIZE;

    dbPvdHashTableSize = size;
    return 0;
}

char* dbRecordName

(

DBENTRY *

pdbentry

)

Definition at line 201 of file dbStaticRun.c.

{
    dbRecordType *pdbRecordType = pdbentry->precordType;
    dbRecordNode *precnode = pdbentry->precnode;
    dbFldDes    *pflddes;
    char        *precord;

    if(!pdbRecordType) return(0);
    if(!precnode) return(0);
    if(!precnode->precord) return(0);
    precord = (char *)precnode->precord;
    pflddes = pdbRecordType->papFldDes[0];
    if(!pflddes) return(NULL);
    return(precord + pflddes->offset);
}

long dbSetLink	(	DBLINK *	plink,
		dbLinkInfo *	pinfo,
		devSup *	dset
	)

Definition at line 2507 of file dbStaticLib.c.

{
    int expected_type = devsup ? devsup->link_type : CONSTANT;

    if (expected_type == CONSTANT ||
        expected_type == JSON_LINK ||
        expected_type == PV_LINK) {
        switch (pinfo->ltype) {
        case CONSTANT:
            dbFreeLinkContents(plink);
            dbSetLinkConst(plink, pinfo);
            break;
        case PV_LINK:
            dbFreeLinkContents(plink);
            dbSetLinkPV(plink, pinfo);
            break;
        case JSON_LINK:
            dbFreeLinkContents(plink);
            dbSetLinkJSON(plink, pinfo);
            break;
        default:
            errlogMessage("Warning: dbSetLink: forgot to test with dbCanSetLink() or logic error");
            goto fail; /* can't assign HW link */
        }
    }
    else if (expected_type == pinfo->ltype) {
        dbFreeLinkContents(plink);
        dbSetLinkHW(plink, pinfo);
    }
    else
        goto fail;

    return 0;
fail:
    dbFreeLinkInfo(pinfo);
    return S_dbLib_badField;
}

Variable Documentation

int dbStaticDebug

Definition at line 49 of file dbStaticLib.c.