dbStaticLib.h File Reference

#include <stddef.h>
#include <stdio.h>
#include "shareLib.h"
#include "dbFldTypes.h"
#include "dbBase.h"
#include "link.h"
#include "errMdef.h"
#include "cantProceed.h"

Include dependency graph for dbStaticLib.h:

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

Go to the source code of this file.

Classes
struct	dbEntry

Macros
#define	dbCalloc(nobj, size)   callocMustSucceed(nobj,size,"dbCalloc")
#define	dbMalloc(size)   mallocMustSucceed(size,"dbMalloc")
#define	S_dbLib_recordTypeNotFound   (M_dbLib|1) /* Record Type does not exist */
#define	S_dbLib_recExists   (M_dbLib|3) /* Record Already exists */
#define	S_dbLib_recNotFound   (M_dbLib|5) /* Record Not Found */
#define	S_dbLib_flddesNotFound   (M_dbLib|7) /* Field Description Not Found */
#define	S_dbLib_fieldNotFound   (M_dbLib|9) /* Field Not Found */
#define	S_dbLib_badField   (M_dbLib|11) /* Bad Field value */
#define	S_dbLib_menuNotFound   (M_dbLib|13) /* Menu not found */
#define	S_dbLib_badLink   (M_dbLib|15) /* Bad Link Field */
#define	S_dbLib_nameLength   (M_dbLib|17) /* Record Name is too long */
#define	S_dbLib_noRecSup   (M_dbLib|19) /* Record support not found */
#define	S_dbLib_strLen   (M_dbLib|21) /* String is too long */
#define	S_dbLib_noSizeOffset   (M_dbLib|23) /* Missing SizeOffset Routine - No record support? */
#define	S_dbLib_outMem   (M_dbLib|27) /* Out of memory */
#define	S_dbLib_infoNotFound   (M_dbLib|29) /* Info item Not Found */

Typedefs
typedef dbBase	DBBASE
typedef struct dbEntry	DBENTRY

Functions
epicsShareFunc DBBASE *	dbAllocBase (void)
epicsShareFunc void	dbFreeBase (DBBASE *pdbbase)
epicsShareFunc DBENTRY *	dbAllocEntry (DBBASE *pdbbase)
epicsShareFunc void	dbFreeEntry (DBENTRY *pdbentry)
epicsShareFunc void	dbInitEntry (DBBASE *pdbbase, DBENTRY *pdbentry)
epicsShareFunc void	dbFinishEntry (DBENTRY *pdbentry)
epicsShareFunc DBENTRY *	dbCopyEntry (DBENTRY *pdbentry)
epicsShareFunc void	dbCopyEntryContents (DBENTRY *pfrom, DBENTRY *pto)
epicsShareFunc long	dbReadDatabase (DBBASE **ppdbbase, const char *filename, const char *path, const char *substitutions)
epicsShareFunc long	dbReadDatabaseFP (DBBASE **ppdbbase, FILE *fp, const char *path, const char *substitutions)
epicsShareFunc long	dbPath (DBBASE *pdbbase, const char *path)
epicsShareFunc long	dbAddPath (DBBASE *pdbbase, const char *path)
epicsShareFunc char *	dbGetPromptGroupNameFromKey (DBBASE *pdbbase, const short key)
epicsShareFunc short	dbGetPromptGroupKeyFromName (DBBASE *pdbbase, const char *name)
epicsShareFunc long	dbWriteRecord (DBBASE *ppdbbase, const char *filename, const char *precordTypename, int level)
epicsShareFunc long	dbWriteRecordFP (DBBASE *ppdbbase, FILE *fp, const char *precordTypename, int level)
epicsShareFunc long	dbWriteMenu (DBBASE *pdbbase, const char *filename, const char *menuName)
epicsShareFunc long	dbWriteMenuFP (DBBASE *pdbbase, FILE *fp, const char *menuName)
epicsShareFunc long	dbWriteRecordType (DBBASE *pdbbase, const char *filename, const char *recordTypeName)
epicsShareFunc long	dbWriteRecordTypeFP (DBBASE *pdbbase, FILE *fp, const char *recordTypeName)
epicsShareFunc long	dbWriteDevice (DBBASE *pdbbase, const char *filename)
epicsShareFunc long	dbWriteDeviceFP (DBBASE *pdbbase, FILE *fp)
epicsShareFunc long	dbWriteDriver (DBBASE *pdbbase, const char *filename)
epicsShareFunc long	dbWriteDriverFP (DBBASE *pdbbase, FILE *fp)
epicsShareFunc long	dbWriteLinkFP (DBBASE *pdbbase, FILE *fp)
epicsShareFunc long	dbWriteRegistrarFP (DBBASE *pdbbase, FILE *fp)
epicsShareFunc long	dbWriteFunctionFP (DBBASE *pdbbase, FILE *fp)
epicsShareFunc long	dbWriteVariableFP (DBBASE *pdbbase, FILE *fp)
epicsShareFunc long	dbWriteBreaktable (DBBASE *pdbbase, const char *filename)
epicsShareFunc long	dbWriteBreaktableFP (DBBASE *pdbbase, FILE *fp)
epicsShareFunc long	dbFindRecordType (DBENTRY *pdbentry, const char *recordTypename)
epicsShareFunc long	dbFirstRecordType (DBENTRY *pdbentry)
epicsShareFunc long	dbNextRecordType (DBENTRY *pdbentry)
epicsShareFunc char *	dbGetRecordTypeName (DBENTRY *pdbentry)
epicsShareFunc int	dbGetNRecordTypes (DBENTRY *pdbentry)
epicsShareFunc long	dbPutRecordAttribute (DBENTRY *pdbentry, const char *name, const char *value)
epicsShareFunc long	dbGetRecordAttribute (DBENTRY *pdbentry, const char *name)
epicsShareFunc long	dbGetAttributePart (DBENTRY *pdbentry, const char **ppname)
epicsShareFunc long	dbFirstField (DBENTRY *pdbentry, int dctonly)
epicsShareFunc long	dbNextField (DBENTRY *pdbentry, int dctonly)
epicsShareFunc int	dbGetNFields (DBENTRY *pdbentry, int dctonly)
epicsShareFunc char *	dbGetFieldName (DBENTRY *pdbentry)
epicsShareFunc int	dbGetFieldDbfType (DBENTRY *pdbentry)
epicsShareFunc char *	dbGetDefault (DBENTRY *pdbentry)
epicsShareFunc char *	dbGetPrompt (DBENTRY *pdbentry)
epicsShareFunc int	dbGetPromptGroup (DBENTRY *pdbentry)
epicsShareFunc long	dbCreateRecord (DBENTRY *pdbentry, const char *pname)
epicsShareFunc long	dbDeleteRecord (DBENTRY *pdbentry)
epicsShareFunc long	dbFreeRecords (DBBASE *pdbbase)
epicsShareFunc long	dbFindRecordPart (DBENTRY *pdbentry, const char **ppname)
epicsShareFunc long	dbFindRecord (DBENTRY *pdbentry, const char *pname)
epicsShareFunc long	dbFirstRecord (DBENTRY *pdbentry)
epicsShareFunc long	dbNextRecord (DBENTRY *pdbentry)
epicsShareFunc int	dbGetNRecords (DBENTRY *pdbentry)
epicsShareFunc int	dbGetNAliases (DBENTRY *pdbentry)
epicsShareFunc char *	dbGetRecordName (DBENTRY *pdbentry)
epicsShareFunc long	dbCopyRecord (DBENTRY *pdbentry, const char *newRecordName, int overWriteOK)
epicsShareFunc long	dbVisibleRecord (DBENTRY *pdbentry)
epicsShareFunc long	dbInvisibleRecord (DBENTRY *pdbentry)
epicsShareFunc int	dbIsVisibleRecord (DBENTRY *pdbentry)
epicsShareFunc long	dbCreateAlias (DBENTRY *pdbentry, const char *paliasName)
epicsShareFunc int	dbIsAlias (DBENTRY *pdbentry)
epicsShareFunc int	dbFollowAlias (DBENTRY *pdbentry)
epicsShareFunc long	dbDeleteAliases (DBENTRY *pdbentry)
epicsShareFunc long	dbFindFieldPart (DBENTRY *pdbentry, const char **ppname)
epicsShareFunc long	dbFindField (DBENTRY *pdbentry, const char *pfieldName)
epicsShareFunc int	dbFoundField (DBENTRY *pdbentry)
epicsShareFunc char *	dbGetString (DBENTRY *pdbentry)
epicsShareFunc long	dbPutString (DBENTRY *pdbentry, const char *pstring)
epicsShareFunc char *	dbVerify (DBENTRY *pdbentry, const char *pstring)
epicsShareFunc int	dbIsDefaultValue (DBENTRY *pdbentry)
epicsShareFunc long	dbFirstInfo (DBENTRY *pdbentry)
epicsShareFunc long	dbNextInfo (DBENTRY *pdbentry)
epicsShareFunc long	dbFindInfo (DBENTRY *pdbentry, const char *name)
epicsShareFunc long	dbNextMatchingInfo (DBENTRY *pdbentry, const char *pattern)
epicsShareFunc long	dbDeleteInfo (DBENTRY *pdbentry)
epicsShareFunc const char *	dbGetInfoName (DBENTRY *pdbentry)
epicsShareFunc const char *	dbGetInfoString (DBENTRY *pdbentry)
epicsShareFunc long	dbPutInfoString (DBENTRY *pdbentry, const char *string)
epicsShareFunc long	dbPutInfoPointer (DBENTRY *pdbentry, void *pointer)
epicsShareFunc void *	dbGetInfoPointer (DBENTRY *pdbentry)
epicsShareFunc const char *	dbGetInfo (DBENTRY *pdbentry, const char *name)
epicsShareFunc long	dbPutInfo (DBENTRY *pdbentry, const char *name, const char *string)
epicsShareFunc brkTable *	dbFindBrkTable (DBBASE *pdbbase, const char *name)
epicsShareFunc const char *	dbGetFieldTypeString (int dbfType)
epicsShareFunc int	dbFindFieldType (const char *type)
epicsShareFunc dbMenu *	dbFindMenu (DBBASE *pdbbase, const char *name)
epicsShareFunc char **	dbGetMenuChoices (DBENTRY *pdbentry)
epicsShareFunc int	dbGetMenuIndex (DBENTRY *pdbentry)
epicsShareFunc long	dbPutMenuIndex (DBENTRY *pdbentry, int index)
epicsShareFunc int	dbGetNMenuChoices (DBENTRY *pdbentry)
epicsShareFunc char *	dbGetMenuStringFromIndex (DBENTRY *pdbentry, int index)
epicsShareFunc int	dbGetMenuIndexFromString (DBENTRY *pdbentry, const char *choice)
epicsShareFunc drvSup *	dbFindDriver (dbBase *pdbbase, const char *name)
epicsShareFunc char *	dbGetRelatedField (DBENTRY *pdbentry)
epicsShareFunc linkSup *	dbFindLinkSup (dbBase *pdbbase, const char *name)
epicsShareFunc int	dbGetNLinks (DBENTRY *pdbentry)
epicsShareFunc long	dbGetLinkField (DBENTRY *pdbentry, int index)
epicsShareFunc void	dbDumpPath (DBBASE *pdbbase)
epicsShareFunc void	dbDumpRecord (DBBASE *pdbbase, const char *precordTypename, int level)
epicsShareFunc void	dbDumpMenu (DBBASE *pdbbase, const char *menuName)
epicsShareFunc void	dbDumpRecordType (DBBASE *pdbbase, const char *recordTypeName)
epicsShareFunc void	dbDumpField (DBBASE *pdbbase, const char *recordTypeName, const char *fname)
epicsShareFunc void	dbDumpDevice (DBBASE *pdbbase, const char *recordTypeName)
epicsShareFunc void	dbDumpDriver (DBBASE *pdbbase)
epicsShareFunc void	dbDumpLink (DBBASE *pdbbase)
epicsShareFunc void	dbDumpRegistrar (DBBASE *pdbbase)
epicsShareFunc void	dbDumpFunction (DBBASE *pdbbase)
epicsShareFunc void	dbDumpVariable (DBBASE *pdbbase)
epicsShareFunc void	dbDumpBreaktable (DBBASE *pdbbase, const char *name)
epicsShareFunc void	dbPvdDump (DBBASE *pdbbase, int verbose)
epicsShareFunc void	dbReportDeviceConfig (DBBASE *pdbbase, FILE *report)
epicsShareFunc void	dbCatString (char **string, int *stringLength, char *pnew, char *separator)

Variables
epicsShareExtern int	dbBptNotMonotonic
int	dbStaticDebug
int	dbConvertStrict

Macro Definition Documentation

#define dbCalloc	(		nobj,
			size
	)		callocMustSucceed(nobj,size,"dbCalloc")

Definition at line 228 of file dbStaticLib.h.

#define dbMalloc

(

size

)

mallocMustSucceed(size,"dbMalloc")

Definition at line 229 of file dbStaticLib.h.

#define S_dbLib_badField   (M_dbLib|11) /* Bad Field value */

Definition at line 241 of file dbStaticLib.h.

#define S_dbLib_badLink   (M_dbLib|15) /* Bad Link Field */

Definition at line 243 of file dbStaticLib.h.

#define S_dbLib_fieldNotFound   (M_dbLib|9) /* Field Not Found */

Definition at line 240 of file dbStaticLib.h.

#define S_dbLib_flddesNotFound   (M_dbLib|7) /* Field Description Not Found */

Definition at line 239 of file dbStaticLib.h.

#define S_dbLib_infoNotFound   (M_dbLib|29) /* Info item Not Found */

Definition at line 249 of file dbStaticLib.h.

#define S_dbLib_menuNotFound   (M_dbLib|13) /* Menu not found */

Definition at line 242 of file dbStaticLib.h.

#define S_dbLib_nameLength   (M_dbLib|17) /* Record Name is too long */

Definition at line 244 of file dbStaticLib.h.

#define S_dbLib_noRecSup   (M_dbLib|19) /* Record support not found */

Definition at line 245 of file dbStaticLib.h.

#define S_dbLib_noSizeOffset   (M_dbLib|23) /* Missing SizeOffset Routine - No record support? */

Definition at line 247 of file dbStaticLib.h.

#define S_dbLib_outMem   (M_dbLib|27) /* Out of memory */

Definition at line 248 of file dbStaticLib.h.

#define S_dbLib_recExists   (M_dbLib|3) /* Record Already exists */

Definition at line 237 of file dbStaticLib.h.

#define S_dbLib_recNotFound   (M_dbLib|5) /* Record Not Found */

Definition at line 238 of file dbStaticLib.h.

#define S_dbLib_recordTypeNotFound   (M_dbLib|1) /* Record Type does not exist */

Definition at line 236 of file dbStaticLib.h.

#define S_dbLib_strLen   (M_dbLib|21) /* String is too long */

Definition at line 246 of file dbStaticLib.h.

Typedef Documentation

typedef dbBase DBBASE

Definition at line 31 of file dbStaticLib.h.

typedef struct dbEntry DBENTRY

Function Documentation

epicsShareFunc long dbAddPath	(	DBBASE *	pdbbase,
		const char *	path
	)

Definition at line 665 of file dbStaticLib.c.

{
    ELLLIST     *ppathList;
    const char  *pcolon;
    const char  *plast;
    unsigned    expectingPath;
    unsigned    sawMissingPath;

    if(!pdbbase) return(-1);
    ppathList = (ELLLIST *)pdbbase->pathPvt;
    if(!ppathList) {
        ppathList = dbCalloc(1,sizeof(ELLLIST));
        ellInit(ppathList);
        pdbbase->pathPvt = (void *)ppathList;
    }
    if (!path) return(0); /* Empty path strings are ignored */
    /* care is taken to properly deal with white space
     * 1) preceding and trailing white space is removed from paths
     * 2) white space inbetween path separator counts as an empty name
     *      (see below)
     */
    expectingPath = FALSE;
    sawMissingPath = FALSE;
    while (*path) {
        size_t len;

        /* preceding white space is removed */
        if (isspace((int)*path)) {
            path++;
            continue;
        }
        pcolon = strstr (path, OSI_PATH_LIST_SEPARATOR);
        if (pcolon==path) {
            sawMissingPath = TRUE;
            path += strlen (OSI_PATH_LIST_SEPARATOR);
            continue;
        }
        if (pcolon) {
            plast = pcolon - 1;
            expectingPath = TRUE;
        } else {
            plast = strlen (path) + path - 1;
            expectingPath = FALSE;
        }
        /* trailing white space is removed */
        while (isspace((int)*plast)) {
            plast--;
        }

        /*
         * len is always nonzero because we found something that
         * 1) isnt white space
         * 2) isnt a path separator
         */
        len = (plast - path) + 1;
        if (dbAddOnePath (pdbbase, path, (unsigned) len)) return (-1);
        path += len;
        if (pcolon) {
            path += strlen(OSI_PATH_LIST_SEPARATOR);
        }
    }

    /*
     * an empty name at beginning, middle, or end of a path string that isnt
     * empty means current directory
     */
    if (expectingPath||sawMissingPath) {
        return dbAddOnePath (pdbbase, ".", 1);
    }
    return(0);
}

epicsShareFunc DBBASE* dbAllocBase

(

void

)

Definition at line 401 of file dbStaticLib.c.

{
    dbBase  *pdbbase;

    pdbbase = dbCalloc(1,sizeof(dbBase));
    ellInit(&pdbbase->menuList);
    ellInit(&pdbbase->recordTypeList);
    ellInit(&pdbbase->drvList);
    ellInit(&pdbbase->registrarList);
    ellInit(&pdbbase->functionList);
    ellInit(&pdbbase->variableList);
    ellInit(&pdbbase->bptList);
    ellInit(&pdbbase->filterList);
    ellInit(&pdbbase->guiGroupList);
    gphInitPvt(&pdbbase->pgpHash,256);
    dbPvdInitPvt(pdbbase);
    return (pdbbase);
}

epicsShareFunc DBENTRY* dbAllocEntry

(

DBBASE *

pdbbase

)

Definition at line 607 of file dbStaticLib.c.

{
    DBENTRY *pdbentry;

    pdbentry = dbmfMalloc(sizeof(DBENTRY));
    memset(pdbentry,'\0',sizeof(DBENTRY));
    pdbentry->pdbbase = pdbbase;
    return(pdbentry);
}

epicsShareFunc void dbCatString	(	char **	string,
		int *	stringLength,
		char *	pnew,
		char *	separator
	)

Definition at line 375 of file dbStaticLib.c.

{
    if((*string==NULL)
    || ((strlen(*string)+strlen(src)+2) > (size_t)*stringLength)) {
        char    *newString;
        size_t  size;

        size = strlen(src);
        if(*string) size += strlen(*string);
        /*Make size multiple of INC_SIZE*/
        size = ((size + 2 + INC_SIZE)/INC_SIZE) * INC_SIZE;
        newString = dbCalloc(size,sizeof(char));
        if(*string) {
            strcpy(newString,*string);
            free((void *)(*string));
        }
        *string = newString;
    }
    if(*stringLength>0) {
        strcat(*string,separator);
    *stringLength += (int) strlen(separator);
    }
    strcat(*string,src);
    *stringLength += (int) strlen(src);
}

epicsShareFunc DBENTRY* dbCopyEntry

(

DBENTRY *

pdbentry

)

Definition at line 640 of file dbStaticLib.c.

{
    DBENTRY *pnew;

    pnew = dbAllocEntry(pdbentry->pdbbase);
    *pnew = *pdbentry;
    pnew->message = NULL;
    return(pnew);
}

epicsShareFunc void dbCopyEntryContents	(	DBENTRY *	pfrom,
		DBENTRY *	pto
	)

Definition at line 650 of file dbStaticLib.c.

{
    *pto = *pfrom;
    pto->message = NULL;
}

epicsShareFunc long dbCopyRecord	(	DBENTRY *	pdbentry,
		const char *	newRecordName,
		int	overWriteOK
	)

Definition at line 1708 of file dbStaticLib.c.

{
    dbRecordType    *precordType = pdbentry->precordType;
    dbFldDes        *pdbFldDes;
    dbRecordNode    *precnode = pdbentry->precnode;
    long            status;
    DBENTRY         dbentry;
    char            *pvalue;

    if(!precordType) return(S_dbLib_recordTypeNotFound);
    /*Get size of NAME field*/
    pdbFldDes = precordType->papFldDes[0];
    if(!pdbFldDes || (strcmp(pdbFldDes->name,"NAME")!=0))
        return(S_dbLib_nameLength);
    if((int)strlen(newRecordName)>=pdbFldDes->size) return(S_dbLib_nameLength);
    if (!precnode || dbIsAlias(pdbentry)) return S_dbLib_recNotFound;
    dbInitEntry(pdbentry->pdbbase,&dbentry);
    status = dbFindRecord(&dbentry,newRecordName);
    if(!status) {
        if(!overWriteOK) {
            dbFinishEntry(&dbentry);
            return(S_dbLib_recExists);
        }
        status = dbDeleteRecord(&dbentry);
        if(status) return(status);
    }
    dbFinishEntry(&dbentry);
    if((status = dbFindRecordType(&dbentry,precordType->name))) return(status);
    if((status = dbCreateRecord(&dbentry,newRecordName))) return(status);
    if((status = dbFirstField(pdbentry,TRUE))) return(status);
    if((status = dbFirstField(&dbentry,TRUE))) return(status);
    while(!status) {
        if(!dbIsDefaultValue(pdbentry)) {
            pvalue = dbGetString(pdbentry);
            if((status = dbPutString(&dbentry,pvalue))) return(status);
        }
        status = dbNextField(pdbentry,TRUE);
        if(!status) status = dbNextField(&dbentry,TRUE);
        if(!status && (pdbentry->pflddes!=dbentry.pflddes)) {
            epicsPrintf("dbCopyRecord: Logic Error\n");
            return(-1);
        }
    }
    /*Copy the info strings too*/
    status = dbFirstInfo(pdbentry);
    while (!status) {
        status = dbPutInfo(&dbentry, dbGetInfoName(pdbentry), dbGetInfoString(pdbentry));
        if (status) return (status);
        status = dbNextInfo(pdbentry);
    }
    /*Leave pdbentry pointing to newRecordName*/
    return(dbFindRecord(pdbentry,newRecordName));
}

epicsShareFunc long dbCreateAlias	(	DBENTRY *	pdbentry,
		const char *	paliasName
	)

Definition at line 1648 of file dbStaticLib.c.

{
    dbRecordType *precordType = pdbentry->precordType;
    dbRecordNode *precnode = pdbentry->precnode;
    dbRecordNode *pnewnode;
    DBENTRY tempEntry;
    PVDENTRY *ppvd;

    if (!precordType)
        return S_dbLib_recordTypeNotFound;

    /* alias of alias still references actual record */
    while (precnode && (precnode->flags & DBRN_FLAGS_ISALIAS))
        precnode = precnode->aliasedRecnode;

    if (!precnode)
        return S_dbLib_recNotFound;

    dbInitEntry(pdbentry->pdbbase, &tempEntry);
    if (!dbFindRecord(&tempEntry, alias))
        return S_dbLib_recExists;
    dbFinishEntry(&tempEntry);

    pnewnode = dbCalloc(1, sizeof(dbRecordNode));
    pnewnode->recordname = epicsStrDup(alias);
    pnewnode->precord = precnode->precord;
    pnewnode->aliasedRecnode = precnode;
    pnewnode->flags = DBRN_FLAGS_ISALIAS;
    precnode->flags |= DBRN_FLAGS_HASALIAS;
    ellInit(&pnewnode->infoList);

    ellAdd(&precordType->recList, &pnewnode->node);
    precordType->no_aliases++;

    ppvd = dbPvdAdd(pdbentry->pdbbase, precordType, pnewnode);
    if (!ppvd) {
        errMessage(-1, "dbCreateAlias: Add to PVD failed");
        return -1;
    }

    return 0;
}

epicsShareFunc long dbCreateRecord	(	DBENTRY *	pdbentry,
		const char *	pname
	)

Definition at line 1416 of file dbStaticLib.c.

{
    dbRecordType    *precordType = pdbentry->precordType;
    dbFldDes        *pdbFldDes;
    PVDENTRY        *ppvd;
    ELLLIST         *preclist = NULL;
    dbRecordNode    *pNewRecNode = NULL;
    long            status = 0;

    if(!precordType) return(S_dbLib_recordTypeNotFound);
    /*Get size of NAME field*/
    pdbFldDes = precordType->papFldDes[0];
    if(!pdbFldDes || (strcmp(pdbFldDes->name,"NAME")!=0))
        return(S_dbLib_nameLength);
    if((int)strlen(precordName)>=pdbFldDes->size) return(S_dbLib_nameLength);
    /* clear callers entry */
    zeroDbentry(pdbentry);
    if(!dbFindRecord(pdbentry,precordName)) return (S_dbLib_recExists);
    zeroDbentry(pdbentry);
    pdbentry->precordType = precordType;
    preclist = &precordType->recList;
    /* create a recNode */
    pNewRecNode = dbCalloc(1,sizeof(dbRecordNode));
    /* create a new record of this record type */
    pdbentry->precnode = pNewRecNode;
    if((status = dbAllocRecord(pdbentry,precordName))) return(status);
    pNewRecNode->recordname = dbRecordName(pdbentry);
    ellInit(&pNewRecNode->infoList);
    ellAdd(preclist, &pNewRecNode->node);
    pdbentry->precnode = pNewRecNode;
    ppvd = dbPvdAdd(pdbentry->pdbbase,precordType,pNewRecNode);
    if(!ppvd) {errMessage(-1,"Logic Err: Could not add to PVD");return(-1);}
    return(0);
}

epicsShareFunc long dbDeleteAliases

(

DBENTRY *

pdbentry

)

Definition at line 1451 of file dbStaticLib.c.

{
    dbBase          *pdbbase = pdbentry->pdbbase;
    dbRecordType    *precordType = pdbentry->precordType;
    dbRecordNode    *precnode = pdbentry->precnode;
    ELLLIST         *preclist = &precordType->recList;
    dbRecordNode    *pAliasNode, *pAliasNodeNext;
    DBENTRY         dbentry;
    void *precord;

    if (!precnode) return S_dbLib_recNotFound;
    if (precnode->flags & DBRN_FLAGS_ISALIAS) return S_dbLib_recExists;
    precord = precnode->precord;

    dbInitEntry(pdbbase, &dbentry);
    pAliasNode = (dbRecordNode *)ellFirst(preclist);
    while (pAliasNode) {
        pAliasNodeNext = (dbRecordNode *)ellNext(&pAliasNode->node);
        if (pAliasNode->flags & DBRN_FLAGS_ISALIAS &&
            pAliasNode->precord == precord &&
            !dbFindRecord(&dbentry, pAliasNode->recordname)) {
            dbDeleteRecord(&dbentry);
        }
        pAliasNode = pAliasNodeNext;
    }
    precnode->flags &= ~DBRN_FLAGS_HASALIAS;
    return 0;
}

epicsShareFunc long dbDeleteInfo

(

DBENTRY *

pdbentry

)

Definition at line 2886 of file dbStaticLib.c.

{
    dbRecordNode    *precnode = pdbentry->precnode;
    dbInfoNode      *pinfo = pdbentry->pinfonode;

    if (!precnode) return (S_dbLib_recNotFound);
    if (!pinfo) return (S_dbLib_infoNotFound);
    ellDelete(&precnode->infoList,&pinfo->node);
    free(pinfo->name);
    free(pinfo->string);
    free(pinfo);
    pdbentry->pinfonode = NULL;
    return (0);
}

epicsShareFunc long dbDeleteRecord

(

DBENTRY *

pdbentry

)

Definition at line 1480 of file dbStaticLib.c.

{
    dbBase          *pdbbase = pdbentry->pdbbase;
    dbRecordType    *precordType = pdbentry->precordType;
    dbRecordNode    *precnode = pdbentry->precnode;
    ELLLIST         *preclist;
    long            status;

    if (!precnode) return S_dbLib_recNotFound;
    if (precnode->flags & DBRN_FLAGS_HASALIAS)
        dbDeleteAliases(pdbentry);

    preclist = &precordType->recList;
    ellDelete(preclist, &precnode->node);
    dbPvdDelete(pdbbase, precnode);
    while (!dbFirstInfo(pdbentry)) {
        dbDeleteInfo(pdbentry);
    }
    if (precnode->flags & DBRN_FLAGS_ISALIAS) {
        free(precnode->recordname);
        precordType->no_aliases--;
    } else {
        status = dbFreeRecord(pdbentry);
        if (status) return status;
    }
    free(precnode);
    pdbentry->precnode = NULL;
    return 0;
}

epicsShareFunc void dbDumpBreaktable	(	DBBASE *	pdbbase,
		const char *	name
	)

Definition at line 3460 of file dbStaticLib.c.

{
    brkTable *pbrkTable;
    brkInt   *pbrkInt;
    int      ind;

    if(!pdbbase) {
        fprintf(stderr,"pdbbase not specified\n");
        return;
    }
    for(pbrkTable = (brkTable *)ellFirst(&pdbbase->bptList);
    pbrkTable; pbrkTable = (brkTable *)ellNext(&pbrkTable->node)) {
        if (name && strcmp(name,pbrkTable->name)!=0) continue;
        printf("breaktable(%s) {\n",pbrkTable->name);
        pbrkInt = pbrkTable->paBrkInt;
        for(ind=0; ind < pbrkTable->number; ind++) {
            printf("\traw=%f slope=%e eng=%f\n",
                   pbrkInt->raw, pbrkInt->slope, pbrkInt->eng);
            pbrkInt++;
        }
        printf("}\n");
    }
    return;
}

epicsShareFunc void dbDumpDevice	(	DBBASE *	pdbbase,
		const char *	recordTypeName
	)

Definition at line 3356 of file dbStaticLib.c.

{
    dbRecordType    *pdbRecordType;
    devSup          *pdevSup;
    int             gotMatch;

    if (recordTypeName) {
        if (*recordTypeName == 0 || *recordTypeName == '*')
            recordTypeName = 0;
    }
    if(!pdbbase) {
        fprintf(stderr,"pdbbase not specified\n");
        return;
    }
    for(pdbRecordType = (dbRecordType *)ellFirst(&pdbbase->recordTypeList);
    pdbRecordType; pdbRecordType = (dbRecordType *)ellNext(&pdbRecordType->node)) {
        if(recordTypeName) {
            gotMatch = (strcmp(recordTypeName,pdbRecordType->name)==0)
                ? TRUE : FALSE;
        }else {
            gotMatch=TRUE;
        }
        if(!gotMatch) continue;
        printf("recordtype(%s)\n",pdbRecordType->name);
        for(pdevSup = (devSup *)ellFirst(&pdbRecordType->devList);
        pdevSup; pdevSup = (devSup *)ellNext(&pdevSup->node)) {
            printf("    device name:   %s\n",pdevSup->name);
            printf("\tchoice:    %s\n",pdevSup->choice);
            printf("\tlink_type: %d\n",pdevSup->link_type);
            printf("\tpdset:     %p\n",(void *)pdevSup->pdset);
            if (pdevSup->pdset) {
                static const char *names[] = {
                    " - report()",
                    " - init()",
                    " - init_record()",
                    " - get_ioint_info()"
                };
                int i, n = pdevSup->pdset->number;
                DEVSUPFUN *pfunc = &pdevSup->pdset->report;

                printf("\t    number: %d\n", n);
                for (i = 0; i < n; ++i, ++pfunc) {
                    const char *name = (i < NELEMENTS(names)) ? names[i] : "";

                    printf("\t    func %d: %p%s\n", i, (void *)*pfunc, name);
                }
            }
            printf("\tpdsxt:     %p\n",(void *)pdevSup->pdsxt);
            if (pdevSup->pdsxt) {
                printf("\t    add_record: %p\n",
                    (void *)pdevSup->pdsxt->add_record);
                printf("\t    del_record: %p\n",
                    (void *)pdevSup->pdsxt->del_record);
            }
        }
        if(recordTypeName) break;
    }
}

epicsShareFunc void dbDumpDriver

(

DBBASE *

pdbbase

)

Definition at line 3415 of file dbStaticLib.c.

{
    if(!pdbbase) {
        fprintf(stderr,"pdbbase not specified\n");
        return;
    }
    dbWriteDriverFP(pdbbase,stdout);
}

epicsShareFunc void dbDumpField	(	DBBASE *	pdbbase,
		const char *	recordTypeName,
		const char *	fname
	)

Definition at line 3273 of file dbStaticLib.c.

{
    dbRecordType        *pdbRecordType;
    dbFldDes            *pdbFldDes;
    int                 gotMatch;
    int                 i;
    dbRecordAttribute   *pAttribute;

    if(!pdbbase) {
        fprintf(stderr,"pdbbase not specified\n");
        return;
    }
    for(pdbRecordType = (dbRecordType *)ellFirst(&pdbbase->recordTypeList);
    pdbRecordType; pdbRecordType = (dbRecordType *)ellNext(&pdbRecordType->node)) {
        if(recordTypeName) {
            gotMatch = (strcmp(recordTypeName,pdbRecordType->name)==0)
                ? TRUE : FALSE;
        }else {
            gotMatch=TRUE;
        }
        if(!gotMatch) continue;
        printf("recordtype(%s) \n",pdbRecordType->name);
        for(i=0; i<pdbRecordType->no_fields; i++) {
            int j;

            pdbFldDes = pdbRecordType->papFldDes[i];
            if(fname && strcmp(fname,pdbFldDes->name)!=0) continue;
            printf("    %s\n", pdbFldDes->name);
            printf("\t         prompt: %s\n",
                (pdbFldDes->prompt ? pdbFldDes->prompt : ""));
            printf("\t          extra: %s\n",
                (pdbFldDes->extra ? pdbFldDes->extra: ""));
            printf("\t      indRecordType: %hd\n",pdbFldDes->indRecordType);
            printf("\t        special: %hd ",pdbFldDes->special);
            if(pdbFldDes->special) {
                for(j=0; j<SPC_NTYPES; j++) {
                    if(pamapspcType[j].value == pdbFldDes->special) {
                        printf("%s",pamapspcType[j].strvalue);
                        break;
                    }
                }
            }
            printf("\n");
            printf("\t     field_type: %s\n",
                dbGetFieldTypeString(pdbFldDes->field_type));
            printf("\tprocess_passive: %u\n",pdbFldDes->process_passive);
            printf("\t       property: %u\n",pdbFldDes->prop);
            printf("\t           base: %d\n",pdbFldDes->base);
            if(!pdbFldDes->promptgroup) {
                printf("\t    promptgroup: %d\n",pdbFldDes->promptgroup);
            } else {
            printf("\t    promptgroup: %s\n",
                    dbGetPromptGroupNameFromKey(pdbbase, pdbFldDes->promptgroup));
        }
            printf("\t       interest: %hd\n", pdbFldDes->interest);
            printf("\t       as_level: %d\n",pdbFldDes->as_level);
            printf("\t        initial: %s\n",
                (pdbFldDes->initial ? pdbFldDes->initial : ""));
            if(pdbFldDes->field_type==DBF_MENU) {
                if(pdbFldDes->ftPvt)
                    printf("\t\t  menu: %s\n",
                        ((dbMenu *)pdbFldDes->ftPvt)->name);
                else
                    printf("\t\t  menu: NOT FOUND\n");
            }
            if(pdbFldDes->field_type==DBF_DEVICE) {
                printf("\t          ftPvt: %p\n",pdbFldDes->ftPvt);
            }
            printf("\t           size: %hd\n",pdbFldDes->size);
            printf("\t         offset: %hd\n",pdbFldDes->offset);
        }
        pAttribute =
            (dbRecordAttribute *)ellFirst(&pdbRecordType->attributeList);
        while(pAttribute) {
            printf("Attribute: name %s value %s\n",
                pAttribute->name,pAttribute->value);
            pAttribute = (dbRecordAttribute *)ellNext(&pAttribute->node);
        }
        if(recordTypeName) break;
    }
}

epicsShareFunc void dbDumpFunction

(

DBBASE *

pdbbase

)

Definition at line 3442 of file dbStaticLib.c.

{
    if(!pdbbase) {
        fprintf(stderr,"pdbbase not specified\n");
        return;
    }
    dbWriteFunctionFP(pdbbase,stdout);
}

epicsShareFunc void dbDumpLink

(

DBBASE *

pdbbase

)

Definition at line 3424 of file dbStaticLib.c.

{
    if(!pdbbase) {
        fprintf(stderr,"pdbbase not specified\n");
        return;
    }
    dbWriteLinkFP(pdbbase,stdout);
}

epicsShareFunc void dbDumpMenu	(	DBBASE *	pdbbase,
		const char *	menuName
	)

Definition at line 3222 of file dbStaticLib.c.

{
    if(!pdbbase) {
        fprintf(stderr,"pdbbase not specified\n");
        return;
    }
    dbWriteMenuFP(pdbbase,stdout,menuName);
}

epicsShareFunc void dbDumpPath

(

DBBASE *

pdbbase

)

Definition at line 3189 of file dbStaticLib.c.

{
    ELLLIST     *ppathList;
    dbPathNode  *pdbPathNode;

    if(!pdbbase) {
        fprintf(stderr,"pdbbase not specified\n");
        return;
    }
    ppathList = (ELLLIST *)pdbbase->pathPvt;
    if(!ppathList || !(pdbPathNode = (dbPathNode *)ellFirst(ppathList))) {
        printf("no path defined\n");
        return;
    }
    while(pdbPathNode) {
        printf("%s",pdbPathNode->directory);
        pdbPathNode = (dbPathNode *)ellNext(&pdbPathNode->node);
        if(pdbPathNode) printf("%s", OSI_PATH_LIST_SEPARATOR);
    }
    printf("\n");
    return;
}

epicsShareFunc void dbDumpRecord	(	DBBASE *	pdbbase,
		const char *	precordTypename,
		int	level
	)

Definition at line 3212 of file dbStaticLib.c.

{
    if(!pdbbase) {
        fprintf(stderr,"pdbbase not specified\n");
        return;
    }
    dbWriteRecordFP(pdbbase,stdout,precordTypename,level);
}

epicsShareFunc void dbDumpRecordType	(	DBBASE *	pdbbase,
		const char *	recordTypeName
	)

Definition at line 3231 of file dbStaticLib.c.

{
    dbRecordType    *pdbRecordType;
    dbFldDes        *pdbFldDes;
    int             gotMatch;
    int             i;

    if(!pdbbase) {
        fprintf(stderr,"pdbbase not specified\n");
        return;
    }
    for(pdbRecordType = (dbRecordType *)ellFirst(&pdbbase->recordTypeList);
    pdbRecordType; pdbRecordType = (dbRecordType *)ellNext(&pdbRecordType->node)) {
        if(recordTypeName) {
            gotMatch = (strcmp(recordTypeName,pdbRecordType->name)==0)
                ? TRUE : FALSE;
        }else {
            gotMatch=TRUE;
        }
        if(!gotMatch) continue;
        printf("name(%s) no_fields(%hd) no_prompt(%hd) no_links(%hd)\n",
            pdbRecordType->name,pdbRecordType->no_fields,
            pdbRecordType->no_prompt,pdbRecordType->no_links);
        printf("index name\tsortind sortname\n");
        for(i=0; i<pdbRecordType->no_fields; i++) {
            pdbFldDes = pdbRecordType->papFldDes[i];
            printf("%5d %s\t%7d %s\n",
                i,pdbFldDes->name,
                pdbRecordType->sortFldInd[i],pdbRecordType->papsortFldName[i]);
        }
        printf("link_ind ");
        for(i=0; i<pdbRecordType->no_links; i++)
            printf(" %hd",pdbRecordType->link_ind[i]);
        printf("\n");
        printf("indvalFlddes %d name %s\n",pdbRecordType->indvalFlddes,
            pdbRecordType->pvalFldDes->name);
        printf("rset * %p rec_size %d\n",
            (void *)pdbRecordType->prset,pdbRecordType->rec_size);
        if(recordTypeName) break;
    }
}

epicsShareFunc void dbDumpRegistrar

(

DBBASE *

pdbbase

)

Definition at line 3433 of file dbStaticLib.c.

{
    if(!pdbbase) {
        fprintf(stderr,"pdbbase not specified\n");
        return;
    }
    dbWriteRegistrarFP(pdbbase,stdout);
}

epicsShareFunc void dbDumpVariable

(

DBBASE *

pdbbase

)

Definition at line 3451 of file dbStaticLib.c.

{
    if(!pdbbase) {
        fprintf(stderr,"pdbbase not specified\n");
        return;
    }
    dbWriteVariableFP(pdbbase,stdout);
}

epicsShareFunc brkTable* dbFindBrkTable	(	DBBASE *	pdbbase,
		const char *	name
	)

Definition at line 2979 of file dbStaticLib.c.

{
    GPHENTRY *pgph;

    pgph = gphFind(pdbbase->pgpHash,name,(void *)&pdbbase->bptList);
    if(!pgph) return(NULL);
    return((brkTable *)pgph->userPvt);
}

epicsShareFunc drvSup* dbFindDriver	(	dbBase *	pdbbase,
		const char *	name
	)

Definition at line 3133 of file dbStaticLib.c.

                                                         {
    GPHENTRY *pgph = gphFind(pdbbase->pgpHash,name,&pdbbase->drvList);
    if (!pgph) return NULL;
    return (drvSup *) pgph->userPvt;
}

epicsShareFunc long dbFindField	(	DBENTRY *	pdbentry,
		const char *	pfieldName
	)

Definition at line 1828 of file dbStaticLib.c.

{
    long status = dbFindFieldPart(pdbentry, &pname);
    int ch;

    if (status == S_dbLib_fieldNotFound)
        return dbGetRecordAttribute(pdbentry, pname);
    if (status) return status;

    ch = *pname;
    if (ch == 0 || isspace(ch)) return 0;
    return S_dbLib_recNotFound;
}

epicsShareFunc long dbFindFieldPart	(	DBENTRY *	pdbentry,
		const char **	ppname
	)

Definition at line 1762 of file dbStaticLib.c.

{
    dbRecordType *precordType = pdbentry->precordType;
    dbRecordNode *precnode = pdbentry->precnode;
    const char   *pname = *ppname;
    short        top, bottom, test;
    char         **papsortFldName;
    short        *sortFldInd;
    int          ch;
    size_t       nameLen;

    if (!precordType) return S_dbLib_recordTypeNotFound;
    if (!precnode) return S_dbLib_recNotFound;
    papsortFldName = precordType->papsortFldName;
    sortFldInd = precordType->sortFldInd;

    /* Measure field name length; name is a valid C identifier */
    nameLen = 0;
    if ((ch = *pname) &&
        (ch == '_' || isalpha(ch))) {
        while ((ch = pname[++nameLen]))
            if (!(ch == '_' || isalnum(ch))) break;
    }

    /* Handle absent field name */
    if (nameLen == 0) {
        dbFldDes *pflddes = precordType->pvalFldDes;

        if (!pflddes)
            return S_dbLib_recordTypeNotFound;
        pdbentry->pflddes = pflddes;
        pdbentry->indfield = precordType->indvalFlddes;
        *ppname = &pname[nameLen];
        return dbGetFieldAddress(pdbentry);
    }

    /* binary search through ordered field names */
    top = precordType->no_fields - 1;
    bottom = 0;
    test = (top + bottom) / 2;
    while (1) {
        int compare = strncmp(papsortFldName[test], pname, nameLen);
        if (compare == 0)
            compare = (int) (strlen(papsortFldName[test]) - nameLen);
        if (compare == 0) {
            dbFldDes *pflddes = precordType->papFldDes[sortFldInd[test]];

            if (!pflddes)
                return S_dbLib_recordTypeNotFound;
            pdbentry->pflddes = pflddes;
            pdbentry->indfield = sortFldInd[test];
            *ppname = &pname[nameLen];
            return dbGetFieldAddress(pdbentry);
        } else if (compare > 0) {
            top = test - 1;
            if (top < bottom) break;
            test = (top + bottom) / 2;
        } else {
            bottom = test + 1;
            if (top < bottom) break;
            test = (top + bottom) / 2;
        }
    }
    return S_dbLib_fieldNotFound;
}

epicsShareFunc int dbFindFieldType

(

const char *

type

)

Definition at line 3000 of file dbStaticLib.c.

{
    int i;

    for (i = 0; i < DBF_NTYPES; i++) {
        if (strcmp(type, pamapdbfType[i].strvalue) == 0) {
            return pamapdbfType[i].value;
        }
    }
    return -1;
}

epicsShareFunc long dbFindInfo	(	DBENTRY *	pdbentry,
		const char *	name
	)

Definition at line 2867 of file dbStaticLib.c.

{
    dbRecordNode *precnode = pdbentry->precnode;
    dbInfoNode *pinfo;

    pdbentry->pinfonode = NULL;
    if (!precnode) return(S_dbLib_recNotFound);

    pinfo = (dbInfoNode *)ellFirst(&precnode->infoList);
    while (pinfo) {
        if (!strcmp(pinfo->name, name)) {
            pdbentry->pinfonode = pinfo;
            return (0);
        }
        pinfo = (dbInfoNode *)ellNext(&pinfo->node);
    }
    return (S_dbLib_infoNotFound);
}

epicsShareFunc linkSup* dbFindLinkSup	(	dbBase *	pdbbase,
		const char *	name
	)

Definition at line 3158 of file dbStaticLib.c.

                                                          {
    GPHENTRY *pgph = gphFind(pdbbase->pgpHash,name,&pdbbase->linkList);
    if (!pgph) return NULL;
    return (linkSup *) pgph->userPvt;
}

epicsShareFunc dbMenu* dbFindMenu	(	DBBASE *	pdbbase,
		const char *	name
	)

Definition at line 3012 of file dbStaticLib.c.

{
    GPHENTRY *pgph;

    pgph = gphFind(pdbbase->pgpHash,name,(void *)&pdbbase->menuList);
    if(!pgph) return(NULL);
    return((dbMenu *)pgph->userPvt);
}

epicsShareFunc long dbFindRecord	(	DBENTRY *	pdbentry,
		const char *	pname
	)

Definition at line 1559 of file dbStaticLib.c.

{
    long status = dbFindRecordPart(pdbentry, &pname);

    if (status) return status;
    if (*pname == '.')
        return dbFindField(pdbentry, ++pname);
    return 0;
}

epicsShareFunc long dbFindRecordPart	(	DBENTRY *	pdbentry,
		const char **	ppname
	)

Definition at line 1533 of file dbStaticLib.c.

{
    dbBase      *pdbbase = pdbentry->pdbbase;
    const char  *pname = *ppname;
    const char  *pfn;
    size_t      lenName;
    PVDENTRY    *ppvdNode;

    zeroDbentry(pdbentry);
    pfn = strchr(pname, '.');
    if (pfn) {
        lenName = (size_t) (pfn - pname);
    } else {
        lenName = strlen(pname);
    }

    ppvdNode = dbPvdFind(pdbbase, pname, lenName);
    if (!ppvdNode)
        return S_dbLib_recNotFound;

    pdbentry->precnode = ppvdNode->precnode;
    pdbentry->precordType = ppvdNode->precordType;
    *ppname = pname + lenName;
    return 0;
}

epicsShareFunc long dbFindRecordType	(	DBENTRY *	pdbentry,
		const char *	recordTypename
	)

Definition at line 1186 of file dbStaticLib.c.

{
    dbBase      *pdbbase = pdbentry->pdbbase;
    GPHENTRY    *phash;

    zeroDbentry(pdbentry);
    phash = gphFind(pdbbase->pgpHash,recordType,&pdbbase->recordTypeList);
    if(!phash) return(S_dbLib_recordTypeNotFound);
    pdbentry->precordType = phash->userPvt;
    return(0);
}

epicsShareFunc void dbFinishEntry

(

DBENTRY *

pdbentry

)

Definition at line 632 of file dbStaticLib.c.

{
    if(pdbentry->message) {
        free((void *)pdbentry->message);
        pdbentry->message = NULL;
    }
}

epicsShareFunc long dbFirstField	(	DBENTRY *	pdbentry,
		int	dctonly
	)

Definition at line 1316 of file dbStaticLib.c.

{

    pdbentry->indfield = -1;
    return(dbNextField(pdbentry,dctonly));
}

epicsShareFunc long dbFirstInfo

(

DBENTRY *

pdbentry

)

Definition at line 2816 of file dbStaticLib.c.

{
    dbRecordNode *precnode = pdbentry->precnode;

    pdbentry->pinfonode = NULL;
    if (!precnode) return (S_dbLib_recNotFound);

    pdbentry->pinfonode = (dbInfoNode *)ellFirst(&precnode->infoList);
    return (pdbentry->pinfonode ? 0 : S_dbLib_infoNotFound);
}

epicsShareFunc long dbFirstRecord

(

DBENTRY *

pdbentry

)

Definition at line 1569 of file dbStaticLib.c.

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

    zeroDbentry(pdbentry);
    if(!precordType) return(S_dbLib_recordTypeNotFound);
    pdbentry->precordType = precordType;
    precnode = (dbRecordNode *)ellFirst(&precordType->recList);
    if(!precnode) return(S_dbLib_recNotFound);
    pdbentry->precnode = precnode;
    return(0);
}

epicsShareFunc long dbFirstRecordType

(

DBENTRY *

pdbentry

)

Definition at line 1198 of file dbStaticLib.c.

{
    dbRecordType *precordType;

    zeroDbentry(pdbentry);
    precordType = (dbRecordType *)ellFirst(&pdbentry->pdbbase->recordTypeList);
    if(!precordType) return(S_dbLib_recordTypeNotFound);
    pdbentry->precordType = precordType;
    return(0);
}

epicsShareFunc int dbFollowAlias

(

DBENTRY *

pdbentry

)

Definition at line 1691 of file dbStaticLib.c.

{
    if(!pdbentry->precnode)
        return S_dbLib_recNotFound;
    if(pdbentry->precnode->aliasedRecnode)
        pdbentry->precnode = pdbentry->precnode->aliasedRecnode;
    return 0;
}

epicsShareFunc int dbFoundField

(

DBENTRY *

pdbentry

)

Definition at line 1842 of file dbStaticLib.c.

{ return((pdbentry->pfield) ? TRUE : FALSE); }

epicsShareFunc void dbFreeBase

(

DBBASE *

pdbbase

)

Definition at line 419 of file dbStaticLib.c.

{
    dbMenu              *pdbMenu;
    dbMenu              *pdbMenuNext;
    dbRecordType        *pdbRecordType;
    dbRecordType        *pdbRecordTypeNext;
    dbFldDes            *pdbFldDes;
    dbRecordAttribute   *pAttribute;
    dbRecordAttribute   *pAttributeNext;
    devSup              *pdevSup;
    devSup              *pdevSupNext;
    dbText              *ptext;
    dbText              *ptextNext;
    dbVariableDef       *pvar;
    dbVariableDef       *pvarNext;
    drvSup              *pdrvSup;
    drvSup              *pdrvSupNext;
    linkSup             *plinkSup;
    brkTable            *pbrkTable;
    brkTable            *pbrkTableNext;
    chFilterPlugin      *pfilt;
    chFilterPlugin      *pfiltNext;
    dbGuiGroup          *pguiGroup;
    dbGuiGroup          *pguiGroupNext;
    int                 i;
    DBENTRY             dbentry;
    long status;

    dbInitEntry(pdbbase,&dbentry);
    status = dbFirstRecordType(&dbentry);
    while(!status) {
        /* dbDeleteRecord() will remove alias or real record node.
         * For real record nodes, also removes the nodes of all aliases.
         * This complicates safe traversal, so we re-start iteration
         * from the first record after each call.
         */
        while((status = dbFirstRecord(&dbentry))==0) {
            dbDeleteRecord(&dbentry);
        }
        assert(status==S_dbLib_recNotFound);
        status = dbNextRecordType(&dbentry);
    }
    dbFinishEntry(&dbentry);
    pdbRecordType = (dbRecordType *)ellFirst(&pdbbase->recordTypeList);
    while(pdbRecordType) {
        for(i=0; i<pdbRecordType->no_fields; i++) {
            pdbFldDes = pdbRecordType->papFldDes[i];
            free((void *)pdbFldDes->prompt);
            free((void *)pdbFldDes->name);
            free((void *)pdbFldDes->extra);
            free((void *)pdbFldDes->initial);
            if(pdbFldDes->field_type==DBF_DEVICE && pdbFldDes->ftPvt) {
                dbDeviceMenu *pdbDeviceMenu;

                pdbDeviceMenu = (dbDeviceMenu *)pdbFldDes->ftPvt;
                free((void *)pdbDeviceMenu->papChoice);
                free((void *)pdbDeviceMenu);
                pdbFldDes->ftPvt=0;
            }
            free((void *)pdbFldDes);
        }
        pdevSup = (devSup *)ellFirst(&pdbRecordType->devList);
        while(pdevSup) {
            pdevSupNext = (devSup *)ellNext(&pdevSup->node);
            ellDelete(&pdbRecordType->devList,&pdevSup->node);
            free((void *)pdevSup->name);
            free((void *)pdevSup->choice);
            free((void *)pdevSup);
            pdevSup = pdevSupNext;
        }
        ptext = (dbText *)ellFirst(&pdbRecordType->cdefList);
        while(ptext) {
            ptextNext = (dbText *)ellNext(&ptext->node);
            ellDelete(&pdbRecordType->cdefList,&ptext->node);
            free((void *)ptext->text);
            free((void *)ptext);
            ptext = ptextNext;
        }
        pAttribute =
                (dbRecordAttribute *)ellFirst(&pdbRecordType->attributeList);
        while(pAttribute) {
            pAttributeNext = (dbRecordAttribute *)ellNext(&pAttribute->node);
            ellDelete(&pdbRecordType->attributeList,&pAttribute->node);
            free((void *)pAttribute->name);
            free((void *)pAttribute->pdbFldDes);
            free(pAttribute);
            pAttribute = pAttributeNext;
        }
        pdbRecordTypeNext = (dbRecordType *)ellNext(&pdbRecordType->node);
        gphDelete(pdbbase->pgpHash,pdbRecordType->name,&pdbbase->recordTypeList);
        ellDelete(&pdbbase->recordTypeList,&pdbRecordType->node);
        free((void *)pdbRecordType->name);
        free((void *)pdbRecordType->link_ind);
        free((void *)pdbRecordType->papsortFldName);
        free((void *)pdbRecordType->sortFldInd);
        free((void *)pdbRecordType->papFldDes);
        free((void *)pdbRecordType);
        pdbRecordType = pdbRecordTypeNext;
    }
    pdbMenu = (dbMenu *)ellFirst(&pdbbase->menuList);
    while(pdbMenu) {
        pdbMenuNext = (dbMenu *)ellNext(&pdbMenu->node);
        gphDelete(pdbbase->pgpHash,pdbMenu->name,&pdbbase->menuList);
        ellDelete(&pdbbase->menuList,&pdbMenu->node);
        for(i=0; i< pdbMenu->nChoice; i++) {
            free((void *)pdbMenu->papChoiceName[i]);
            free((void *)pdbMenu->papChoiceValue[i]);
        }
        free((void *)pdbMenu->papChoiceName);
        free((void *)pdbMenu->papChoiceValue);
        free((void *)pdbMenu ->name);
        free((void *)pdbMenu);
        pdbMenu = pdbMenuNext;
    }
    pdrvSup = (drvSup *)ellFirst(&pdbbase->drvList);
    while(pdrvSup) {
        pdrvSupNext = (drvSup *)ellNext(&pdrvSup->node);
        ellDelete(&pdbbase->drvList,&pdrvSup->node);
        free((void *)pdrvSup->name);
        free((void *)pdrvSup);
        pdrvSup = pdrvSupNext;
    }
    while ((plinkSup = (linkSup *) ellGet(&pdbbase->linkList))) {
        free(plinkSup->jlif_name);
        free(plinkSup->name);
        free(plinkSup);
    }
    ptext = (dbText *)ellFirst(&pdbbase->registrarList);
    while(ptext) {
        ptextNext = (dbText *)ellNext(&ptext->node);
        ellDelete(&pdbbase->registrarList,&ptext->node);
        free((void *)ptext->text);
        free((void *)ptext);
        ptext = ptextNext;
    }
    ptext = (dbText *)ellFirst(&pdbbase->functionList);
    while(ptext) {
        ptextNext = (dbText *)ellNext(&ptext->node);
        ellDelete(&pdbbase->functionList,&ptext->node);
        free((void *)ptext->text);
        free((void *)ptext);
        ptext = ptextNext;
    }
    pvar = (dbVariableDef *)ellFirst(&pdbbase->variableList);
    while(pvar) {
        pvarNext = (dbVariableDef *)ellNext(&pvar->node);
        ellDelete(&pdbbase->variableList,&pvar->node);
        free((void *)pvar->name);
        free((void *)pvar->type);
        free((void *)pvar);
        pvar = pvarNext;
    }
    pbrkTable = (brkTable *)ellFirst(&pdbbase->bptList);
    while(pbrkTable) {
        pbrkTableNext = (brkTable *)ellNext(&pbrkTable->node);
        gphDelete(pdbbase->pgpHash,pbrkTable->name,&pdbbase->bptList);
        ellDelete(&pdbbase->bptList,&pbrkTable->node);
        free(pbrkTable->name);
        free((void *)pbrkTable->paBrkInt);
        free((void *)pbrkTable);
        pbrkTable = pbrkTableNext;
    }
    pfilt = (chFilterPlugin *)ellFirst(&pdbbase->filterList);
    while(pfilt) {
        pfiltNext = (chFilterPlugin *)ellNext(&pfilt->node);
        free((char*)pfilt->name);
        if(pfilt->fif->priv_free)
            (*pfilt->fif->priv_free)(pfilt->puser);
        free(pfilt);
        pfilt = pfiltNext;
    }
    pguiGroup = (dbGuiGroup *)ellFirst(&pdbbase->guiGroupList);
    while (pguiGroup) {
        pguiGroupNext = (dbGuiGroup *)ellNext(&pguiGroup->node);
        gphDelete(pdbbase->pgpHash, pguiGroup->name, &pdbbase->guiGroupList);
        ellDelete(&pdbbase->guiGroupList, &pguiGroup->node);
        free(pguiGroup->name);
        free((void *)pguiGroup);
        pguiGroup = pguiGroupNext;
    }
    gphFreeMem(pdbbase->pgpHash);
    dbPvdFreeMem(pdbbase);
    dbFreePath(pdbbase);
    free((void *)pdbbase);
    pdbbase = NULL;
    return;
}

epicsShareFunc void dbFreeEntry

(

DBENTRY *

pdbentry

)

Definition at line 617 of file dbStaticLib.c.

{
    if (!pdbentry)
        return;
    if (pdbentry->message)
        free((void *)pdbentry->message);
    dbmfFree(pdbentry);
}

epicsShareFunc long dbFreeRecords

(

DBBASE *

pdbbase

)

Definition at line 1510 of file dbStaticLib.c.

{
    DBENTRY         dbentry;
    dbRecordType    *pdbRecordType;
    dbRecordNode    *pdbRecordNode;
    dbRecordNode    *pdbRecordNodeNext;

    dbInitEntry(pdbbase,&dbentry);
    pdbRecordType = (dbRecordType *)ellFirst(&pdbbase->recordTypeList);
    while(pdbRecordType) {
        pdbRecordNode = (dbRecordNode *)ellFirst(&pdbRecordType->recList);
        while(pdbRecordNode) {
            pdbRecordNodeNext = (dbRecordNode *)ellNext(&pdbRecordNode->node);
            if(!dbFindRecord(&dbentry,pdbRecordNode->recordname))
                dbDeleteRecord(&dbentry);
            pdbRecordNode = pdbRecordNodeNext;
        }
        pdbRecordType = (dbRecordType *)ellNext(&pdbRecordType->node);
    }
    dbFinishEntry(&dbentry);
    return(0);
}

epicsShareFunc long dbGetAttributePart	(	DBENTRY *	pdbentry,
		const char **	ppname
	)

Definition at line 1277 of file dbStaticLib.c.

{
    dbRecordType *precordType = pdbentry->precordType;
    const char *pname = *ppname;
    dbRecordAttribute *pattribute;

    if (!precordType)
        return S_dbLib_recordTypeNotFound;

    pattribute = (dbRecordAttribute *)ellFirst(&precordType->attributeList);
    while (pattribute) {
        size_t nameLen = strlen(pattribute->name);
        int compare = strncmp(pattribute->name, pname, nameLen);

        if (compare == 0) {
            int ch = pname[nameLen];

            if (ch != '_' && !isalnum(ch)) {
                /* Any other character can't be in the attribute name */
                pdbentry->pflddes = pattribute->pdbFldDes;
                pdbentry->pfield = pattribute->value;
                *ppname = &pname[nameLen];
                return 0;
            }
            if (strlen(pname) > nameLen) {
                compare = -1;
            }
        }
        if (compare >= 0) break;
        pattribute = (dbRecordAttribute *)ellNext(&pattribute->node);
    }
    return S_dbLib_fieldNotFound;
}

epicsShareFunc char* dbGetDefault

(

DBENTRY *

pdbentry

)

Definition at line 1392 of file dbStaticLib.c.

{
    dbFldDes    *pflddes = pdbentry->pflddes;

    if(!pflddes) return(NULL);
    return(pflddes->initial);
}

epicsShareFunc int dbGetFieldDbfType

(

DBENTRY *

pdbentry

)

Definition at line 1384 of file dbStaticLib.c.

{
    dbFldDes    *pflddes = pdbentry->pflddes;

    if(!pflddes) return(-1);
    return(pflddes->field_type);
}

epicsShareFunc char* dbGetFieldName

(

DBENTRY *

pdbentry

)

Definition at line 1376 of file dbStaticLib.c.

{
    dbFldDes    *pflddes = pdbentry->pflddes;

    if(!pflddes) return(NULL);
    return(pflddes->name);
}

epicsShareFunc const char* dbGetFieldTypeString

(

int

dbfType

)

Definition at line 2988 of file dbStaticLib.c.

{
    int i;

    for (i=0; i < DBF_NTYPES; i++) {
        if (pamapdbfType[i].value == dbfType) {
            return pamapdbfType[i].strvalue;
        }
    }
    return "BAD_DBF_TYPE";
}

epicsShareFunc const char* dbGetInfo	(	DBENTRY *	pdbentry,
		const char *	name
	)

Definition at line 2942 of file dbStaticLib.c.

{
    if (dbFindInfo(pdbentry, name)) return NULL;
    return dbGetInfoString(pdbentry);
}

epicsShareFunc const char* dbGetInfoName

(

DBENTRY *

pdbentry

)

Definition at line 2901 of file dbStaticLib.c.

{
    dbInfoNode *pinfo = pdbentry->pinfonode;
    if (!pinfo) return (NULL);
    return (pinfo->name);
}

epicsShareFunc void* dbGetInfoPointer

(

DBENTRY *

pdbentry

)

Definition at line 2935 of file dbStaticLib.c.

{
    dbInfoNode *pinfo = pdbentry->pinfonode;
    if (!pinfo) return (NULL);
    return (pinfo->pointer);
}

epicsShareFunc const char* dbGetInfoString

(

DBENTRY *

pdbentry

)

Definition at line 2908 of file dbStaticLib.c.

{
    dbInfoNode *pinfo = pdbentry->pinfonode;
    if (!pinfo) return (NULL);
    return (pinfo->string);
}

epicsShareFunc long dbGetLinkField	(	DBENTRY *	pdbentry,
		int	index
	)

Definition at line 3172 of file dbStaticLib.c.

{
    dbRecordType *precordType = pdbentry->precordType;
    dbFldDes *pflddes;

    if (!precordType)
        return S_dbLib_recordTypeNotFound;

    if (index < 0 || index >= precordType->no_links)
        return S_dbLib_badLink;

    pdbentry->indfield = precordType->link_ind[index];
    pdbentry->pflddes = pflddes = precordType->papFldDes[pdbentry->indfield];
    dbGetFieldAddress(pdbentry);
    return 0;
}

epicsShareFunc char** dbGetMenuChoices

(

DBENTRY *

pdbentry

)

Definition at line 3021 of file dbStaticLib.c.

{
    dbFldDes    *pflddes = pdbentry->pflddes;

    if(!pflddes) return(NULL);
    switch (pflddes->field_type) {
    case DBF_MENU: {
            dbMenu  *pdbMenu = (dbMenu *)pflddes->ftPvt;

            if(!pdbMenu) return(NULL);
            return(pdbMenu->papChoiceValue);
        }
    case DBF_DEVICE: {
            dbDeviceMenu *pdbDeviceMenu;

            pdbDeviceMenu = dbGetDeviceMenu(pdbentry);
            if(!pdbDeviceMenu) return(NULL);
            return(pdbDeviceMenu->papChoice);
        }
    default:
        return(NULL);
    }
}

epicsShareFunc int dbGetMenuIndex

(

DBENTRY *

pdbentry

)

Definition at line 501 of file dbStaticRun.c.

{
    dbFldDes *pflddes = pdbentry->pflddes;
    void *pfield = pdbentry->pfield;

    if (!pflddes || !pfield)
        return -1;

    switch (pflddes->field_type) {
    case DBF_MENU:
    case DBF_DEVICE:
        return * (epicsEnum16 *) pfield;
    default:
        epicsPrintf("dbGetMenuIndex: Called for field type %d\n",
            pflddes->field_type);
    }
    return -1;
}

epicsShareFunc int dbGetMenuIndexFromString	(	DBENTRY *	pdbentry,
		const char *	choice
	)

Definition at line 3097 of file dbStaticLib.c.

{
    dbFldDes    *pflddes = pdbentry->pflddes;
    int         ind;
    int         nChoice = 0;
    char        **papChoice = NULL;

    if(!pflddes) return(-1);
    switch (pflddes->field_type) {
    case DBF_MENU: {
            dbMenu  *pdbMenu = (dbMenu *)pflddes->ftPvt;

            if(!pdbMenu) return(-1);
            papChoice = pdbMenu->papChoiceValue;
            nChoice = pdbMenu->nChoice;
            break;
        }
    case DBF_DEVICE: {
            dbDeviceMenu *pdbDeviceMenu;

            pdbDeviceMenu = dbGetDeviceMenu(pdbentry);
            if(!pdbDeviceMenu) return(-1);
            papChoice = pdbDeviceMenu->papChoice;
            nChoice = pdbDeviceMenu->nChoice;
            break;
        }
    default:
        return(-1);
    }
    if(nChoice<=0 || !papChoice) return(-1);
    for(ind=0; ind<nChoice; ind++) {
        if(strcmp(choice,papChoice[ind])==0) return(ind);
    }
    return (-1);
}

epicsShareFunc char* dbGetMenuStringFromIndex	(	DBENTRY *	pdbentry,
		int	index
	)

Definition at line 3070 of file dbStaticLib.c.

{
    dbFldDes    *pflddes = pdbentry->pflddes;

    if(!pflddes) return(NULL);
    switch (pflddes->field_type) {
    case DBF_MENU: {
            dbMenu  *pdbMenu = (dbMenu *)pflddes->ftPvt;

            if(!pdbMenu) return(NULL);
            if(index<0 || index>=pdbMenu->nChoice) return(NULL);
            return(pdbMenu->papChoiceValue[index]);
        }
    case DBF_DEVICE: {
            dbDeviceMenu *pdbDeviceMenu;

            pdbDeviceMenu = dbGetDeviceMenu(pdbentry);
            if(!pdbDeviceMenu) return(NULL);
            if(index<0 || index>=pdbDeviceMenu->nChoice) return(NULL);
            return(pdbDeviceMenu->papChoice[index]);
        }
    default:
        break;
    }
    return (NULL);
}

epicsShareFunc int dbGetNAliases

(

DBENTRY *

pdbentry

)

Definition at line 1604 of file dbStaticLib.c.

{
    dbRecordType    *precordType = pdbentry->precordType;

    if(!precordType) return(0);
    return(precordType->no_aliases);
}

epicsShareFunc int dbGetNFields	(	DBENTRY *	pdbentry,
		int	dctonly
	)

Definition at line 1359 of file dbStaticLib.c.

{
    dbRecordType    *precordType = pdbentry->precordType;
    dbFldDes        *pflddes;
    int             indfield,n;

    if(!precordType) return(S_dbLib_recordTypeNotFound);
    n = 0;
    for(indfield=0; indfield<precordType->no_fields; indfield++) {
        pflddes = precordType->papFldDes[indfield];
        if(dctonly && (pflddes->field_type==DBF_DEVICE)
        && (ellCount(&precordType->devList)==0) ) continue;
        if(!dctonly || pflddes->promptgroup) n++;
    }
    return(n);
}

epicsShareFunc int dbGetNLinks

(

DBENTRY *

pdbentry

)

Definition at line 3164 of file dbStaticLib.c.

{
    dbRecordType    *precordType = pdbentry->precordType;

    if(!precordType) return(S_dbLib_recordTypeNotFound);
    return((int)precordType->no_links);
}

epicsShareFunc int dbGetNMenuChoices

(

DBENTRY *

pdbentry

)

Definition at line 3045 of file dbStaticLib.c.

{
    dbFldDes    *pflddes = pdbentry->pflddes;

    if(!pflddes) return(-1);
    switch (pflddes->field_type) {
    case DBF_MENU: {
            dbMenu  *pdbMenu = (dbMenu *)pflddes->ftPvt;

            if(!pdbMenu) return(0);
            return(pdbMenu->nChoice);
        }
    case DBF_DEVICE: {
            dbDeviceMenu *pdbDeviceMenu;

            pdbDeviceMenu = dbGetDeviceMenu(pdbentry);
            if(!pdbDeviceMenu) return(0);
            return(pdbDeviceMenu->nChoice);
        }
    default:
        break;
    }
    return (-1);
}

epicsShareFunc int dbGetNRecords

(

DBENTRY *

pdbentry

)

Definition at line 1596 of file dbStaticLib.c.

{
    dbRecordType    *precordType = pdbentry->precordType;

    if(!precordType) return(0);
    return(ellCount(&precordType->recList));
}

epicsShareFunc int dbGetNRecordTypes

(

DBENTRY *

pdbentry

)

Definition at line 1225 of file dbStaticLib.c.

{
    return(ellCount(&pdbentry->pdbbase->recordTypeList));
}

epicsShareFunc char* dbGetPrompt

(

DBENTRY *

pdbentry

)

Definition at line 1400 of file dbStaticLib.c.

{
    dbFldDes    *pflddes = pdbentry->pflddes;

    if(!pflddes) return(NULL);
    return(&pflddes->prompt[0]);
}

epicsShareFunc int dbGetPromptGroup

(

DBENTRY *

pdbentry

)

Definition at line 1408 of file dbStaticLib.c.

{
    dbFldDes    *pflddes = pdbentry->pflddes;

    if(!pflddes) return(0);
    return(pflddes->promptgroup);
}

epicsShareFunc short dbGetPromptGroupKeyFromName	(	DBBASE *	pdbbase,
		const char *	name
	)

Definition at line 765 of file dbStaticLib.c.

{
    GPHENTRY   *pgphentry;

    if (!pdbbase) return 0;
    pgphentry = gphFind(pdbbase->pgpHash, name, &pdbbase->guiGroupList);
    if (!pgphentry) {
        return 0;
    } else {
        return ((dbGuiGroup*)pgphentry->userPvt)->key;
    }
}

epicsShareFunc char* dbGetPromptGroupNameFromKey	(	DBBASE *	pdbbase,
		const short	key
	)

Definition at line 753 of file dbStaticLib.c.

{
    dbGuiGroup *pdbGuiGroup;

    if (!pdbbase) return NULL;
    for (pdbGuiGroup = (dbGuiGroup *)ellFirst(&pdbbase->guiGroupList);
        pdbGuiGroup; pdbGuiGroup = (dbGuiGroup *)ellNext(&pdbGuiGroup->node)) {
        if (pdbGuiGroup->key == key) return pdbGuiGroup->name;
    }
    return NULL;
}

epicsShareFunc long dbGetRecordAttribute	(	DBENTRY *	pdbentry,
		const char *	name
	)

Definition at line 1311 of file dbStaticLib.c.

{
    return dbGetAttributePart(pdbentry, &pname);
}

epicsShareFunc char* dbGetRecordName

(

DBENTRY *

pdbentry

)

Definition at line 1612 of file dbStaticLib.c.

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

    if(!pdbRecordType) return NULL;
    if(!precnode) return NULL;
    return precnode->recordname;
}

epicsShareFunc char* dbGetRecordTypeName

(

DBENTRY *

pdbentry

)

Definition at line 1220 of file dbStaticLib.c.

{
    return(pdbentry->precordType->name);
}

epicsShareFunc char* dbGetRelatedField

(

DBENTRY *

pdbentry

)

Definition at line 3139 of file dbStaticLib.c.

{
    DBENTRY     dbEntry;
    DBENTRY     *pdbentry= &dbEntry;
    dbFldDes    *pflddes;
    char        *rtnval = NULL;
    long        status;

    pflddes = psave->pflddes;
    if(pflddes->field_type !=DBF_DEVICE) return(NULL);
    dbCopyEntryContents(psave,pdbentry);
    pflddes = pdbentry->pflddes;
    status = dbFindField(pdbentry,"INP");
    if(status) status = dbFindField(pdbentry,"OUT");
    if(!status) rtnval = pdbentry->pflddes->name;
    dbFinishEntry(pdbentry);
    return(rtnval);
}

epicsShareFunc char* dbGetString

(

DBENTRY *

pdbentry

)

Definition at line 1845 of file dbStaticLib.c.

{
    dbFldDes    *pflddes = pdbentry->pflddes;
    void        *pfield = pdbentry->pfield;
    DBLINK      *plink;

    if (!pflddes) {
        dbMsgCpy(pdbentry, "fldDes not found");
        return pdbentry->message;
    }
    switch (pflddes->field_type) {
    case DBF_STRING:
    case DBF_INLINK:
    case DBF_OUTLINK:
    case DBF_FWDLINK:
        if (!pfield) {
            dbMsgCpy(pdbentry, "Field not allocated (NULL)");
            return pdbentry->message;
        }
        break;
    default:
        break;
    }

    switch (pflddes->field_type) {
    case DBF_STRING:
        /* Protect against a missing nil-terminator */
        dbMsgNCpy(pdbentry, (char *)pfield, pflddes->size);
        break;
    case DBF_CHAR:
    case DBF_UCHAR:
    case DBF_SHORT:
    case DBF_USHORT:
    case DBF_ENUM:
    case DBF_LONG:
    case DBF_ULONG:
    case DBF_INT64:
    case DBF_UINT64:
    case DBF_FLOAT:
    case DBF_DOUBLE:
    case DBF_MENU:
    case DBF_DEVICE:
        return(dbGetStringNum(pdbentry));
    case DBF_INLINK:
    case DBF_OUTLINK:
        plink = (DBLINK *)pfield;
        switch(plink->type) {
        case CONSTANT:
            if (plink->value.constantStr) {
                dbMsgCpy(pdbentry, plink->value.constantStr);
            } else if (plink->text) {
                dbMsgCpy(pdbentry, plink->text);
            } else {
                dbMsgCpy(pdbentry, "");
            }
            break;
        case MACRO_LINK:
            if (plink->value.macro_link.macroStr) {
                dbMsgCpy(pdbentry, plink->value.macro_link.macroStr);
            } else {
                dbMsgCpy(pdbentry, "");
            }
            break;
        case JSON_LINK:
            dbMsgCpy(pdbentry, plink->value.json.string);
            break;
        case PN_LINK:
            dbMsgPrint(pdbentry, "%s%s",
                   plink->value.pv_link.pvname ? plink->value.pv_link.pvname : "",
                   msstring[plink->value.pv_link.pvlMask&pvlOptMsMode]);
            break;
        case PV_LINK:
        case CA_LINK:
        case DB_LINK: {
            int     ppind;
            short   pvlMask;

            pvlMask = plink->value.pv_link.pvlMask;
            if (pvlMask&pvlOptPP) ppind=1;
            else if(pvlMask&pvlOptCA) ppind=2;
            else if(pvlMask&pvlOptCP) ppind=3;
            else if(pvlMask&pvlOptCPP) ppind=4;
            else ppind=0;
            dbMsgPrint(pdbentry, "%s%s%s%s",
                   plink->value.pv_link.pvname ? plink->value.pv_link.pvname : "",
                   (plink->flags & DBLINK_FLAG_TSELisTIME) ? ".TIME" : "",
                   ppstring[ppind],
                   msstring[plink->value.pv_link.pvlMask&pvlOptMsMode]);
            break;
        }
        case VME_IO:
            dbMsgPrint(pdbentry, "#C%d S%d @%s",
                plink->value.vmeio.card,plink->value.vmeio.signal,
                plink->value.vmeio.parm);
            break;
        case CAMAC_IO:
            dbMsgPrint(pdbentry, "#B%d C%d N%d A%d F%d @%s",
                plink->value.camacio.b,plink->value.camacio.c,
                plink->value.camacio.n,plink->value.camacio.a,
                plink->value.camacio.f,plink->value.camacio.parm);
            break;
        case RF_IO:
            dbMsgPrint(pdbentry, "#R%d M%d D%d E%d",
                plink->value.rfio.cryo,
                plink->value.rfio.micro,
                plink->value.rfio.dataset,
                plink->value.rfio.element);
            break;
        case AB_IO:
            dbMsgPrint(pdbentry, "#L%d A%d C%d S%d @%s",
                plink->value.abio.link,plink->value.abio.adapter,
                plink->value.abio.card,plink->value.abio.signal,
                plink->value.abio.parm);
            break;
        case GPIB_IO:
            dbMsgPrint(pdbentry, "#L%d A%d @%s",
                plink->value.gpibio.link,plink->value.gpibio.addr,
                plink->value.gpibio.parm);
            break;
        case BITBUS_IO:
            dbMsgPrint(pdbentry, "#L%u N%u P%u S%u @%s",
                plink->value.bitbusio.link,plink->value.bitbusio.node,
                plink->value.bitbusio.port,plink->value.bitbusio.signal,
                plink->value.bitbusio.parm);
            break;
        case BBGPIB_IO:
            dbMsgPrint(pdbentry, "#L%u B%u G%u @%s",
                plink->value.bbgpibio.link,plink->value.bbgpibio.bbaddr,
                plink->value.bbgpibio.gpibaddr,plink->value.bbgpibio.parm);
            break;
        case INST_IO:
            dbMsgPrint(pdbentry, "@%s", plink->value.instio.string);
            break;
        case VXI_IO :
            if (plink->value.vxiio.flag == VXIDYNAMIC)
                dbMsgPrint(pdbentry, "#V%d C%d S%d @%s",
                    plink->value.vxiio.frame,plink->value.vxiio.slot,
                    plink->value.vxiio.signal,plink->value.vxiio.parm);
            else
                dbMsgPrint(pdbentry, "#V%d S%d @%s",
                    plink->value.vxiio.la,plink->value.vxiio.signal,
                    plink->value.vxiio.parm);
            break;
        default :
            return(NULL);
        }
        break;
    case DBF_FWDLINK: {
            DBLINK *plink=(DBLINK *)pfield;

            switch(plink->type) {
            case CONSTANT:
                if (plink->value.constantStr) {
                    dbMsgCpy(pdbentry, plink->value.constantStr);
                } else if (plink->text) {
                    dbMsgCpy(pdbentry, plink->text);
                } else {
                    dbMsgCpy(pdbentry, "");
                }
                break;
            case MACRO_LINK:
                if (plink->value.macro_link.macroStr) {
                    dbMsgCpy(pdbentry, plink->value.macro_link.macroStr);
                } else {
                    dbMsgCpy(pdbentry, "");
                }
                break;
            case JSON_LINK:
                dbMsgCpy(pdbentry, plink->value.json.string);
                break;
            case PV_LINK:
            case CA_LINK:
            case DB_LINK: {
                int     ppind;
                short   pvlMask;

                pvlMask = plink->value.pv_link.pvlMask;
                if (pvlMask&pvlOptCA) ppind=2;
                else ppind=0;
                dbMsgPrint(pdbentry, "%s%s",
                    plink->value.pv_link.pvname ? plink->value.pv_link.pvname : "",
                    ppind ? ppstring[ppind] : "");
                break;
            }
            default :
                return(NULL);
            }
        }
        break;
    default:
        return(NULL);
    }
    return pdbentry->message;
}

epicsShareFunc void dbInitEntry	(	DBBASE *	pdbbase,
		DBENTRY *	pdbentry
	)

Definition at line 626 of file dbStaticLib.c.

{
    memset((char *)pdbentry,'\0',sizeof(DBENTRY));
    pdbentry->pdbbase = pdbbase;
}

epicsShareFunc long dbInvisibleRecord

(

DBENTRY *

pdbentry

)

Definition at line 1631 of file dbStaticLib.c.

{
    dbRecordNode    *precnode = pdbentry->precnode;

    if(!precnode) return(S_dbLib_recNotFound);
    precnode->flags &= ~DBRN_FLAGS_VISIBLE;
    return 0;
}

epicsShareFunc int dbIsAlias

(

DBENTRY *

pdbentry

)

Definition at line 1700 of file dbStaticLib.c.

{
    dbRecordNode    *precnode = pdbentry->precnode;

    if(!precnode) return 0;
    return precnode->flags & DBRN_FLAGS_ISALIAS ? 1 : 0;
}

epicsShareFunc int dbIsDefaultValue

(

DBENTRY *

pdbentry

)

Definition at line 219 of file dbStaticRun.c.

{
    dbFldDes *pflddes = pdbentry->pflddes;
    void *pfield = pdbentry->pfield;

    if (!pflddes || !pfield)
        return FALSE;

    switch (pflddes->field_type) {
        case DBF_STRING: {
            char *p = (char *)pfield;

            return pflddes->initial ? ! strcmp(pflddes->initial, p)
                : ! strlen(p);
        }
        case DBF_CHAR: {
            epicsInt8 field = *(epicsInt8 *)pfield;
            epicsInt8 def;

            if (!pflddes->initial)
                return field == 0;

            return ! epicsParseInt8(pflddes->initial, &def, 0, NULL)
                && field == def;
        }
        case DBF_UCHAR: {
            epicsUInt8 field = *(epicsUInt8 *)pfield;
            epicsUInt8 def;

            if (!pflddes->initial)
                return field == 0;

            return ! epicsParseUInt8(pflddes->initial, &def, 0, NULL)
                && field == def;
        }
        case DBF_SHORT: {
            epicsInt16 field = *(epicsInt16 *)pfield;
            epicsInt16 def;

            if (!pflddes->initial)
                return field == 0;

            return ! epicsParseInt16(pflddes->initial, &def, 0, NULL)
                && field == def;
        }
        case DBF_ENUM:
        case DBF_USHORT: {
            epicsUInt16 field = *(epicsUInt16 *)pfield;
            epicsUInt16 def;

            if (!pflddes->initial)
                return field == 0;

            return ! epicsParseUInt16(pflddes->initial, &def, 0, NULL)
                && field == def;
        }
        case DBF_LONG: {
            epicsInt32 field = *(epicsInt32 *)pfield;
            epicsInt32 def;

            if (!pflddes->initial)
                return field == 0;

            return ! epicsParseInt32(pflddes->initial, &def, 0, NULL)
                && field == def;
        }
        case DBF_ULONG: {
            epicsUInt32 field = *(epicsUInt32 *)pfield;
            epicsUInt32 def;

            if (!pflddes->initial)
                return field == 0;

            return ! epicsParseUInt32(pflddes->initial, &def, 0, NULL)
                && field == def;
        }
        case DBF_INT64: {
            epicsInt64 field = *(epicsInt64 *)pfield;
            epicsInt64 def;

            if (!pflddes->initial)
                return field == 0;

            return ! epicsParseInt64(pflddes->initial, &def, 0, NULL)
                && field == def;
        }
        case DBF_UINT64: {
            epicsUInt64 field = *(epicsUInt64 *)pfield;
            epicsUInt64 def;

            if (!pflddes->initial)
                return field == 0;

            return ! epicsParseUInt64(pflddes->initial, &def, 0, NULL)
                && field == def;
        }
        case DBF_FLOAT: {
            epicsFloat32 field = *(epicsFloat32 *)pfield;
            epicsFloat32 def;

            if (!pflddes->initial)
                return field == 0;

            return ! epicsParseFloat32(pflddes->initial, &def, NULL)
                && field == def;
        }
        case DBF_DOUBLE: {
            epicsFloat64 field = *(epicsFloat64 *)pfield;
            epicsFloat64 def;

            if (!pflddes->initial)
                return field == 0;

            return ! epicsParseFloat64(pflddes->initial, &def, NULL)
                && field == def;
        }
        case DBF_MENU: {
            epicsEnum16 field = *(epicsEnum16 *)pfield;
            epicsEnum16 def;
            int index;

            if (!pflddes->initial)
                return field == 0;

            index = dbGetMenuIndexFromString(pdbentry, pflddes->initial);
            if (index < 0) {
                if (epicsParseUInt16(pflddes->initial, &def, 0, NULL))
                    return FALSE;
            }
            else
                def = index;
            return field == def;
        }
        case DBF_DEVICE: {
            dbRecordType *precordType = pdbentry->precordType;

            if (!precordType) {
                epicsPrintf("dbIsDefaultValue: pdbRecordType is NULL??\n");
                return FALSE;
            }
            return ellCount(&precordType->devList) == 0;
        }
        case DBF_INLINK:
        case DBF_OUTLINK:
        case DBF_FWDLINK: {
            struct link *plink = (struct link *)pfield;

            if (!plink || plink->type != CONSTANT)
                return FALSE;

            /* These conditions don't make a lot of sense... */
            if (!plink->value.constantStr)
                return TRUE;

            if (!pflddes->initial)  /* Default value for a link field? */
                return FALSE;

            return !strcmp(plink->value.constantStr, pflddes->initial);
        }
        default:
            return TRUE;
    }
}

epicsShareFunc int dbIsVisibleRecord

(

DBENTRY *

pdbentry

)

Definition at line 1640 of file dbStaticLib.c.

{
    dbRecordNode    *precnode = pdbentry->precnode;

    if(!precnode) return 0;
    return precnode->flags & DBRN_FLAGS_VISIBLE ? 1 : 0;
}

epicsShareFunc long dbNextField	(	DBENTRY *	pdbentry,
		int	dctonly
	)

Definition at line 1323 of file dbStaticLib.c.

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

    if(!precordType) return(S_dbLib_recordTypeNotFound);
    indfield++;
    while(TRUE) {
        if(indfield>=precordType->no_fields) {
            pdbentry->indfield = 0;
            pdbentry->pflddes = NULL;
            pdbentry->pfield = NULL;
            return(S_dbLib_fieldNotFound);
        }
        pflddes = precordType->papFldDes[indfield];
        if(!dctonly || pflddes->promptgroup) {
            /*Skip field if dctonly and no device support*/
            if(!dctonly || (pflddes->field_type!=DBF_DEVICE)
            || (ellCount(&precordType->devList)>0)) {
                pdbentry->indfield = indfield;
                pdbentry->pflddes = pflddes;
                pdbentry->indfield = indfield;
                if(precnode) {
                    dbGetFieldAddress(pdbentry);
                }else {
                    pdbentry->pfield = NULL;
                }
                return(0);
            }
        }
        indfield++;
    }
}

epicsShareFunc long dbNextInfo

(

DBENTRY *

pdbentry

)

Definition at line 2827 of file dbStaticLib.c.

{
    dbRecordNode *precnode = pdbentry->precnode;
    dbInfoNode *pinfo;

    if (!precnode) return (S_dbLib_recNotFound);
    pinfo = pdbentry->pinfonode;
    if (!pinfo) return (S_dbLib_infoNotFound);

    pinfo = (dbInfoNode *)ellNext(&pinfo->node);
    pdbentry->pinfonode = pinfo;
    return (pinfo ? 0 : S_dbLib_infoNotFound);
}

epicsShareFunc long dbNextMatchingInfo	(	DBENTRY *	pdbentry,
		const char *	pattern
	)

Definition at line 2841 of file dbStaticLib.c.

{
    long status;

    if (!pdbentry->precordType)
    {
        status = dbFirstRecordType(pdbentry);
        goto first;
    }
    while(1) {
        status = dbNextInfo(pdbentry);
        while (status) {
            status = dbNextRecord(pdbentry);
            while (status) {
                status = dbNextRecordType(pdbentry);
first:
                if (status) return status;
                status = dbFirstRecord(pdbentry);
            }
            status = dbFirstInfo(pdbentry);
        }
        if (!pattern || !*pattern) return 0;
        if (epicsStrGlobMatch(dbGetInfoName(pdbentry), pattern)) return 0;
    }
}

epicsShareFunc long dbNextRecord

(

DBENTRY *

pdbentry

)

Definition at line 1583 of file dbStaticLib.c.

{
    dbRecordNode    *precnode=pdbentry->precnode;
    long            status=0;

    if(!precnode) return(S_dbLib_recNotFound);
    precnode = (dbRecordNode *)ellNext(&precnode->node);
    if(!precnode) status = S_dbLib_recNotFound;
    pdbentry->precnode = precnode;
    pdbentry->pfield = NULL;
    return(status);
}

epicsShareFunc long dbNextRecordType

(

DBENTRY *

pdbentry

)

Definition at line 1209 of file dbStaticLib.c.

{
    dbRecordType *precordType = pdbentry->precordType;

    zeroDbentry(pdbentry);
    precordType = (dbRecordType *)ellNext(&precordType->node);
    if(!precordType) return(S_dbLib_recordTypeNotFound);
    pdbentry->precordType = precordType;
    return(0);
}

epicsShareFunc long dbPath	(	DBBASE *	pdbbase,
		const char *	path
	)

Definition at line 657 of file dbStaticLib.c.

{
    if(!pdbbase) return(-1);
    dbFreePath(pdbbase);
    if(!path || strlen(path)==0) return(dbAddPath(pdbbase,"."));
    return(dbAddPath(pdbbase,path));
}

epicsShareFunc long dbPutInfo	(	DBENTRY *	pdbentry,
		const char *	name,
		const char *	string
	)

Definition at line 2948 of file dbStaticLib.c.

{
    dbInfoNode *pinfo;
    dbRecordNode *precnode = pdbentry->precnode;
    if (!precnode) return (S_dbLib_recNotFound);

    dbFindInfo(pdbentry, name);
    pinfo = pdbentry->pinfonode;
    if (pinfo) return (dbPutInfoString(pdbentry, string));

    /*Create new info node*/
    pinfo = calloc(1,sizeof(dbInfoNode));
    if (!pinfo) return (S_dbLib_outMem);
    pinfo->name = calloc(1,1+strlen(name));
    if (!pinfo->name) {
        free(pinfo);
        return (S_dbLib_outMem);
    }
    strcpy(pinfo->name, name);
    pinfo->string = calloc(1,1+strlen(string));
    if (!pinfo->string) {
        free(pinfo->name);
        free(pinfo);
        return (S_dbLib_outMem);
    }
    strcpy(pinfo->string, string);
    ellAdd(&precnode->infoList,&pinfo->node);
    pdbentry->pinfonode = pinfo;
    return (0);
}

epicsShareFunc long dbPutInfoPointer	(	DBENTRY *	pdbentry,
		void *	pointer
	)

Definition at line 2927 of file dbStaticLib.c.

{
    dbInfoNode *pinfo = pdbentry->pinfonode;
    if (!pinfo) return (S_dbLib_infoNotFound);
    pinfo->pointer = pointer;
    return (0);
}

epicsShareFunc long dbPutInfoString	(	DBENTRY *	pdbentry,
		const char *	string
	)

Definition at line 2915 of file dbStaticLib.c.

{
    dbInfoNode *pinfo = pdbentry->pinfonode;
    char *newstring;
    if (!pinfo) return (S_dbLib_infoNotFound);
    newstring = realloc(pinfo->string,1+strlen(string));
    if (!newstring) return (S_dbLib_outMem);
    strcpy(newstring, string);
    pinfo->string = newstring;
    return (0);
}

epicsShareFunc long dbPutMenuIndex	(	DBENTRY *	pdbentry,
		int	index
	)

Definition at line 520 of file dbStaticRun.c.

{
    dbFldDes *pflddes = pdbentry->pflddes;
    epicsEnum16 *pfield = pdbentry->pfield;

    if (!pflddes)
        return S_dbLib_flddesNotFound;
    if (!pfield)
        return S_dbLib_fieldNotFound;

    switch (pflddes->field_type) {
    case DBF_MENU: {
        dbMenu *pdbMenu = (dbMenu *) pflddes->ftPvt;

        if (!pdbMenu)
            return S_dbLib_menuNotFound;
        if (index < 0 || index >= pdbMenu->nChoice)
            return S_dbLib_badField;

        *pfield = index;
        return 0;
    }

    case DBF_DEVICE: {
        dbDeviceMenu *pdbDeviceMenu = dbGetDeviceMenu(pdbentry);

        if (!pdbDeviceMenu)
            return S_dbLib_menuNotFound;
        if (index < 0 || index >= pdbDeviceMenu->nChoice)
            return S_dbLib_badField;

        return dbPutString(pdbentry, pdbDeviceMenu->papChoice[index]);
    }

    default:
        break;
    }
    return S_dbLib_badField;
}

epicsShareFunc long dbPutRecordAttribute	(	DBENTRY *	pdbentry,
		const char *	name,
		const char *	value
	)

Definition at line 1230 of file dbStaticLib.c.

{
    dbRecordType        *precordType = pdbentry->precordType;
    int                 createNew = TRUE;
    int                 compare;
    dbRecordAttribute   *pattribute;

    if(!precordType) return(S_dbLib_recordTypeNotFound);
    pattribute = (dbRecordAttribute *)ellFirst(&precordType->attributeList);
    /*put new attribute name in sort order*/
    while(pattribute) {
        compare = strcmp(pattribute->name,name);
        if(compare==0) {
            createNew = FALSE;
        }
        if(compare>=0) break;
        pattribute = (dbRecordAttribute *)ellNext(&pattribute->node);
    }
    if(createNew) {
        dbRecordAttribute *pnew;
        dbFldDes          *pdbFldDes;

        pnew = dbCalloc(1,sizeof(dbRecordAttribute));
        if(pattribute) {
            ellInsert(&precordType->attributeList,pattribute->node.previous,
                &pnew->node);
        } else {
            ellAdd(&precordType->attributeList,&pnew->node);
        }
        pattribute = pnew;
        pattribute->name = dbCalloc(strlen(name)+1,sizeof(char));
        strcpy(pattribute->name,name);
        pdbFldDes = dbCalloc(1,sizeof(dbFldDes));
        pdbFldDes->name = pattribute->name;
        pdbFldDes->pdbRecordType = precordType;
        pdbFldDes->special = SPC_ATTRIBUTE;
        pdbFldDes->field_type = DBF_STRING;
        pdbFldDes->as_level = ASL1;
        pdbFldDes->size = MAX_STRING_SIZE;
        pattribute->pdbFldDes = pdbFldDes;
    }
    strncpy(pattribute->value,value,MAX_STRING_SIZE);
    pattribute->value[MAX_STRING_SIZE-1] = 0;
    return(0);
}

epicsShareFunc long dbPutString	(	DBENTRY *	pdbentry,
		const char *	pstring
	)

Definition at line 2545 of file dbStaticLib.c.

{
    dbFldDes    *pflddes = pdbentry->pflddes;
    void        *pfield = pdbentry->pfield;
    long        status=0;
    int         macroIsOk;
    int         stringHasMacro=FALSE;

    if(!pflddes) return(S_dbLib_flddesNotFound);
    macroIsOk = dbIsMacroOk(pdbentry);
    stringHasMacro = strstr(pstring,"$(") || strstr(pstring,"${");
    if(!macroIsOk && stringHasMacro) {
        epicsPrintf("%s.%s Has unexpanded macro\n",
                dbGetRecordName(pdbentry),dbGetFieldName(pdbentry));
        return(S_dbLib_badField);
    }
    switch (pflddes->field_type) {
    case DBF_STRING:
        if(!pfield) return(S_dbLib_fieldNotFound);
        if(strlen(pstring) >= (size_t)pflddes->size) return S_dbLib_strLen;
        strncpy((char *)pfield, pstring, pflddes->size-1);
        ((char *)pfield)[pflddes->size-1] = 0;

        if((pflddes->special == SPC_CALC) && !stringHasMacro) {
            char  rpcl[RPCL_LEN];
            short err;

            if (postfix(pstring,rpcl,&err)) {
                status = S_dbLib_badField;
                errlogPrintf("%s in CALC expression '%s'\n",
                              calcErrorStr(err), pstring);
            }
        }
        break;

    case DBF_CHAR:
    case DBF_SHORT:
    case DBF_LONG:
    case DBF_INT64:
    case DBF_UCHAR:
    case DBF_USHORT:
    case DBF_ULONG:
    case DBF_UINT64:
    case DBF_ENUM:
    case DBF_FLOAT:
    case DBF_DOUBLE:
    case DBF_MENU:
    case DBF_DEVICE:
        status = dbPutStringNum(pdbentry,pstring);
        break;

    case DBF_INLINK:
    case DBF_OUTLINK:
    case DBF_FWDLINK: {
            dbLinkInfo link_info;
            DBLINK *plink = (DBLINK *)pfield;

            status = dbParseLink(pstring, pflddes->field_type, &link_info);
            if (status) break;

            if (plink->type==CONSTANT && plink->value.constantStr==NULL) {
                /* links not yet initialized by dbInitRecordLinks() */
                free(plink->text);
                plink->text = epicsStrDup(pstring);
                dbFreeLinkInfo(&link_info);
            } else {
                /* assignment after init (eg. autosave restore) */
                struct dbCommon *prec = pdbentry->precnode->precord;
                devSup *devsup = (devSup *)ellNth(&pdbentry->precordType->devList, prec->dtyp+1);

                status = dbCanSetLink(plink, &link_info, devsup);
                if (status == 0)
                    status = dbSetLink(plink, &link_info, devsup);
            }
        }
        break;

    default:
        return S_dbLib_badField;
    }

    if (!status && strcmp(pflddes->name, "VAL") == 0) {
        DBENTRY dbentry;

        dbCopyEntryContents(pdbentry, &dbentry);
        if (!dbFindField(&dbentry, "UDF")) {
            dbPutString(&dbentry, "0");
        }
        dbFinishEntry(&dbentry);
    }
    return(status);
}

epicsShareFunc void dbPvdDump	(	DBBASE *	pdbbase,
		int	verbose
	)

Definition at line 193 of file dbPvdLib.c.

{
    unsigned int empty = 0;
    dbPvd *ppvd;
    unsigned int h;

    if (!pdbbase) {
        fprintf(stderr,"pdbbase not specified\n");
        return;
    }
    ppvd = pdbbase->ppvd;
    if (ppvd == NULL) return;

    printf("Process Variable Directory has %u buckets", ppvd->size);

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

        if (pbucket == NULL) {
            empty++;
            continue;
        }
        epicsMutexMustLock(pbucket->lock);
        ppvdNode = (PVDENTRY *) ellFirst(&pbucket->list);
        printf("\n [%4u] %4d  ", h, ellCount(&pbucket->list));
        while (ppvdNode && verbose) {
            if (!(++i % 4))
                printf("\n         ");
            printf("  %s", ppvdNode->precnode->recordname);
            ppvdNode = (PVDENTRY *) ellNext((ELLNODE*)ppvdNode);
        }
        epicsMutexUnlock(pbucket->lock);
    }
    printf("\n%u buckets empty.\n", empty);
}

epicsShareFunc long dbReadDatabase	(	DBBASE **	ppdbbase,
		const char *	filename,
		const char *	path,
		const char *	substitutions
	)

Definition at line 336 of file dbLexRoutines.c.

{return (dbReadCOM(ppdbbase,filename,0,path,substitutions));}

epicsShareFunc long dbReadDatabaseFP	(	DBBASE **	ppdbbase,
		FILE *	fp,
		const char *	path,
		const char *	substitutions
	)

Definition at line 340 of file dbLexRoutines.c.

{return (dbReadCOM(ppdbbase,0,fp,path,substitutions));}

epicsShareFunc void dbReportDeviceConfig	(	DBBASE *	pdbbase,
		FILE *	report
	)

Definition at line 3502 of file dbStaticLib.c.

{
    DBENTRY dbentry, *pdbentry = &dbentry;
    long status;
    FILE *stream = report ? report : stdout;

    if (!pdbbase) {
        fprintf(stderr, "dbReportDeviceConfig: pdbbase not specified\n");
        return;
    }

    dbInitEntry(pdbbase,pdbentry);
    status = dbFirstRecordType(pdbentry);
    while (!status) {
        const int nlinks = dbGetNLinks(pdbentry);

        status = dbFirstRecord(pdbentry);
        while (!status) {
            int ilink;

            for (ilink=0; ilink<nlinks; ilink++) {
                char linkValue[messagesize];
                char dtypValue[50];
                char cvtValue[40];
                struct link *plink;
                int linkType;

                status = dbGetLinkField(pdbentry, ilink);
                if (status)
                    continue;

                plink = pdbentry->pfield;
                linkType = plink->type;
                if (plink->text) {  /* Not yet parsed */
                    dbLinkInfo linfo;

                    if (dbParseLink(plink->text, pdbentry->pflddes->field_type, &linfo))
                        continue;

                    linkType = linfo.ltype;
                    if (linkType && bus[linkType])
                        strncpy(linkValue, plink->text, messagesize-1);

                    dbFreeLinkInfo(&linfo);
                }
                else {
                    strncpy(linkValue, dbGetString(pdbentry), messagesize-1);
                }

                if (!linkType || !bus[linkType])
                    continue;
                linkValue[messagesize-1] = '\0';

                status = dbFindField(pdbentry, "DTYP");
                if (status)
                    break;  /* Next record type */

                strcpy(dtypValue, dbGetString(pdbentry));
                status = dbFindField(pdbentry, "LINR");
                if (status) {
                    cvtValue[0] = 0;
                }
                else {
                    if (strcmp(dbGetString(pdbentry), "LINEAR") != 0) {
                        cvtValue[0] = 0;
                    }
                    else {
                        strcpy(cvtValue,"cvt(");
                        status = dbFindField(pdbentry, "EGUL");
                        if (!status)
                            strcat(cvtValue, dbGetString(pdbentry));
                        status = dbFindField(pdbentry, "EGUF");
                        if (!status) {
                            strcat(cvtValue, ",");
                            strcat(cvtValue, dbGetString(pdbentry));
                        }
                        strcat(cvtValue, ")");
                    }
                }
                fprintf(stream,"%-8s %-20s %-20s %-20s %-s\n",
                        bus[linkType], linkValue, dtypValue,
                        dbGetRecordName(pdbentry), cvtValue);
                break;
            }
            status = dbNextRecord(pdbentry);
        }
        status = dbNextRecordType(pdbentry);
    }
    dbFinishEntry(pdbentry);
    finishOutstream(stream);
    return;
}

epicsShareFunc char* dbVerify	(	DBENTRY *	pdbentry,
		const char *	pstring
	)

Definition at line 2638 of file dbStaticLib.c.

{
    dbFldDes *pflddes = pdbentry->pflddes;
    char *message = getpMessage(pdbentry);
    long status;
    union {
        epicsInt8    i8;
        epicsUInt8   u8;
        epicsInt16   i16;
        epicsUInt16  u16;
        epicsInt32   i32;
        epicsUInt32  u32;
        epicsInt64   i64;
        epicsUInt64  u64;
        epicsFloat32 f32;
        epicsFloat64 f64;
    } val;

    if (!pflddes) {
        strcpy(message, "fldDes not found");
        return message;
    }

    if (strstr(pstring,"$(") || strstr(pstring,"${"))
        return NULL;

    switch (pflddes->field_type) {
    case DBF_STRING:
    {
        size_t length = strlen(pstring);

        if (length >= pflddes->size) {
            sprintf(message, "String too long, max %d characters",
                pflddes->size - 1);
            return message;
        }

        if (pflddes->special == SPC_CALC) {
            char  rpcl[RPCL_LEN];
            short err;

            status = postfix(pstring, rpcl, &err);
            if (status)  {
                sprintf(message,"%s in CALC expression '%s'",
                        calcErrorStr(err), pstring);
                return message;
            }
        }

        return NULL;
    }

    case DBF_CHAR:
        status = epicsParseInt8(pstring, &val.i8, 0, NULL);
        break;

    case DBF_UCHAR:
        status = epicsParseUInt8(pstring, &val.u8, 0, NULL);
        break;

    case DBF_SHORT:
        status = epicsParseInt16(pstring, &val.i16, 0, NULL);
        break;

    case DBF_ENUM:
    case DBF_USHORT:
        status = epicsParseUInt16(pstring, &val.u16, 0, NULL);
        break;

    case DBF_LONG:
        status = epicsParseInt32(pstring, &val.i32, 0, NULL);
        break;

    case DBF_ULONG:
        status = epicsParseUInt32(pstring, &val.u32, 0, NULL);
        break;

    case DBF_INT64:
        status = epicsParseInt64(pstring, &val.i64, 0, NULL);
        break;

    case DBF_UINT64:
        status = epicsParseUInt64(pstring, &val.u64, 0, NULL);
        break;

    case DBF_FLOAT:
        status = epicsParseFloat32(pstring, &val.f32, NULL);
        break;

    case DBF_DOUBLE:
        status = epicsParseFloat64(pstring, &val.f64, NULL);
        break;

    case DBF_MENU:
        {
            dbMenu *pdbMenu = (dbMenu *)pflddes->ftPvt;
            int i;

            if (!pdbMenu)
                return NULL;

            for (i = 0; i < pdbMenu->nChoice; i++) {
                const char *pchoice = pdbMenu->papChoiceValue[i];

                if (!pchoice)
                    continue;

                if (strcmp(pchoice, pstring) == 0) {
                    return NULL;
                }
            }
        }
        strcpy(message, "Not a valid menu choice");
        return message;

    case DBF_DEVICE:
        {
            dbDeviceMenu *pdbDeviceMenu = dbGetDeviceMenu(pdbentry);
            int i;

            if (!pdbDeviceMenu || pdbDeviceMenu->nChoice == 0)
                return NULL;

            for (i = 0; i < pdbDeviceMenu->nChoice; i++) {
                const char *pchoice = pdbDeviceMenu->papChoice[i];

                if (!pchoice)
                    continue;

                if (strcmp(pchoice, pstring) == 0) {
                    return NULL;
                }
            }
        }
        strcpy(message, "Not a valid device type");
        return message;

    case DBF_INLINK:
    case DBF_OUTLINK:
    case DBF_FWDLINK:
        return NULL;

    default:
        strcpy(message, "Not a valid field type");
        return message;
    }

    switch (status) {
    case 0:
        message = NULL;
        break;

    case S_stdlib_noConversion:
        strcpy(message, "Not a valid integer");
        break;

    case S_stdlib_badBase:
        strcpy(message, "Internal error (badBase)");
        break;

    case S_stdlib_overflow:
        strcpy(message, "Number too large for field type");
        break;

    case S_stdlib_underflow:
        strcpy(message, "Number too small for field type");
        break;

    case S_stdlib_extraneous:
        strcpy(message, "Extraneous characters after number");
        break;

    default:
        strcpy(message, "Unknown numeric conversion error");
    }
    return message;
}

epicsShareFunc long dbVisibleRecord

(

DBENTRY *

pdbentry

)

Definition at line 1622 of file dbStaticLib.c.

{
    dbRecordNode    *precnode = pdbentry->precnode;

    if(!precnode) return(S_dbLib_recNotFound);
    precnode->flags |= DBRN_FLAGS_VISIBLE;
    return 0;
}

epicsShareFunc long dbWriteBreaktable	(	DBBASE *	pdbbase,
		const char *	filename
	)

Definition at line 1151 of file dbStaticLib.c.

{
    FILE *stream;
    long status;

    stream = openOutstream(filename);
    status = dbWriteBreaktableFP(pdbbase,stream);
    finishOutstream(stream);
    return status;
}

epicsShareFunc long dbWriteBreaktableFP	(	DBBASE *	pdbbase,
		FILE *	fp
	)

Definition at line 1162 of file dbStaticLib.c.

{
    brkTable    *pbrkTable;
    brkInt      *pbrkInt;
    int         i;

    if (!pdbbase) {
        fprintf(stderr,"pdbbase not specified\n");
        return(-1);
    }
    for (pbrkTable = (brkTable *)ellFirst(&pdbbase->bptList);
         pbrkTable;
         pbrkTable = (brkTable *)ellNext(&pbrkTable->node)) {
        fprintf(fp,"breaktable(%s) {\n",pbrkTable->name);
        pbrkInt = pbrkTable->paBrkInt;
        for(i=0; i < pbrkTable->number; i++) {
            fprintf(fp,"\t%e, %e\n",pbrkInt->raw,pbrkInt->eng);
            pbrkInt++;
        }
        fprintf(fp,"}\n");
    }
    return(0);
}

epicsShareFunc long dbWriteDevice	(	DBBASE *	pdbbase,
		const char *	filename
	)

Definition at line 1023 of file dbStaticLib.c.

{
    FILE *stream;
    long status;

    stream = openOutstream(filename);
    status = dbWriteDeviceFP(pdbbase,stream);
    finishOutstream(stream);
    return status;
}

epicsShareFunc long dbWriteDeviceFP	(	DBBASE *	pdbbase,
		FILE *	fp
	)

Definition at line 1034 of file dbStaticLib.c.

{
    dbRecordType    *pdbRecordType;
    devSup          *pdevSup;

    if(!pdbbase) {
        fprintf(stderr,"dbWriteDeviceFP: pdbbase not specified\n");
        return(-1);
    }
    for(pdbRecordType = (dbRecordType *)ellFirst(&pdbbase->recordTypeList);
    pdbRecordType; pdbRecordType = (dbRecordType *)ellNext(&pdbRecordType->node)) {
        for(pdevSup = (devSup *)ellFirst(&pdbRecordType->devList);
        pdevSup; pdevSup = (devSup *)ellNext(&pdevSup->node)) {
            int j;

            for(j=0; j< LINK_NTYPES; j++) {
                if(pamaplinkType[j].value==pdevSup->link_type) break;
            }
            if(j>=LINK_NTYPES) {
                fprintf(fp,"link_type not valid\n");
                continue;
            }
            fprintf(fp,"device(%s,%s,%s,\"%s\")\n",
                pdbRecordType->name,
                pamaplinkType[j].strvalue,
                pdevSup->name,pdevSup->choice);
        }
    }
    return(0);
}

epicsShareFunc long dbWriteDriver	(	DBBASE *	pdbbase,
		const char *	filename
	)

Definition at line 1065 of file dbStaticLib.c.

{
    FILE *stream;
    long status;

    stream = openOutstream(filename);
    status = dbWriteDriverFP(pdbbase,stream);
    finishOutstream(stream);
    return status;
}

epicsShareFunc long dbWriteDriverFP	(	DBBASE *	pdbbase,
		FILE *	fp
	)

Definition at line 1076 of file dbStaticLib.c.

{
    drvSup  *pdrvSup;

    if(!pdbbase) {
        fprintf(stderr,"pdbbase not specified\n");
        return(-1);
    }
    for(pdrvSup = (drvSup *)ellFirst(&pdbbase->drvList);
    pdrvSup; pdrvSup = (drvSup *)ellNext(&pdrvSup->node)) {
        fprintf(fp,"driver(%s)\n",pdrvSup->name);
    }
    return(0);
}

epicsShareFunc long dbWriteFunctionFP	(	DBBASE *	pdbbase,
		FILE *	fp
	)

Definition at line 1121 of file dbStaticLib.c.

{
    dbText     *ptext;

    if(!pdbbase) {
        fprintf(stderr,"pdbbase not specified\n");
        return(-1);
    }
    for(ptext = (dbText *)ellFirst(&pdbbase->functionList);
    ptext; ptext = (dbText *)ellNext(&ptext->node)) {
        fprintf(fp,"function(%s)\n",ptext->text);
    }
    return(0);
}

epicsShareFunc long dbWriteLinkFP	(	DBBASE *	pdbbase,
		FILE *	fp
	)

Definition at line 1091 of file dbStaticLib.c.

{
    linkSup *plinkSup;

    if (!pdbbase) {
        fprintf(stderr, "pdbbase not specified\n");
        return -1;
    }
    for (plinkSup = (linkSup *) ellFirst(&pdbbase->linkList);
        plinkSup; plinkSup = (linkSup *) ellNext(&plinkSup->node)) {
        fprintf(fp, "link(%s,%s)\n", plinkSup->name, plinkSup->jlif_name);
    }
    return 0;
}

epicsShareFunc long dbWriteMenu	(	DBBASE *	pdbbase,
		const char *	filename,
		const char *	menuName
	)

Definition at line 885 of file dbStaticLib.c.

{
    FILE *stream;
    long status;

    stream = openOutstream(filename);
    status = dbWriteMenuFP(ppdbbase,stream,menuName);
    finishOutstream(stream);
    return status;
}

epicsShareFunc long dbWriteMenuFP	(	DBBASE *	pdbbase,
		FILE *	fp,
		const char *	menuName
	)

Definition at line 897 of file dbStaticLib.c.

{
    dbMenu  *pdbMenu;
    int     gotMatch;
    int     i;

    if(!pdbbase) {
        fprintf(stderr,"pdbbase not specified\n");
        return(-1);
    }
    if (menuName) {
        if (*menuName == 0 || *menuName == '*')
            menuName = 0;
    }
    pdbMenu = (dbMenu *)ellFirst(&pdbbase->menuList);
    while(pdbMenu) {
        if(menuName) {
            gotMatch = (strcmp(menuName,pdbMenu->name)==0) ? TRUE : FALSE;
        }else {
            gotMatch=TRUE;
        }
        if(gotMatch) {
            fprintf(fp,"menu(%s) {\n",pdbMenu->name);
            for(i=0; i<pdbMenu->nChoice; i++) {
                fprintf(fp,"\tchoice(%s,\"%s\")\n",pdbMenu->papChoiceName[i],
                    pdbMenu->papChoiceValue[i]);
            }
            fprintf(fp,"}\n");
            if(menuName) break;
        }
        pdbMenu = (dbMenu *)ellNext(&pdbMenu->node);
    }
    return(0);
}

epicsShareFunc long dbWriteRecord	(	DBBASE *	ppdbbase,
		const char *	filename,
		const char *	precordTypename,
		int	level
	)

Definition at line 779 of file dbStaticLib.c.

{
    FILE *stream;
    long status;

    stream = openOutstream(filename);
    if(!stream) return -1;
    status = dbWriteRecordFP(ppdbbase,stream,precordTypename,level);
    finishOutstream(stream);
    return status;
}

epicsShareFunc long dbWriteRecordFP	(	DBBASE *	ppdbbase,
		FILE *	fp,
		const char *	precordTypename,
		int	level
	)

Definition at line 792 of file dbStaticLib.c.

{
    DBENTRY dbentry;
    DBENTRY *pdbentry=&dbentry;
    long    status;
    int     dctonly;

    dctonly = ((level>1) ? FALSE : TRUE);
    dbInitEntry(pdbbase,pdbentry);
    if (precordTypename) {
        if (*precordTypename == 0 || *precordTypename == '*')
            precordTypename = 0;
    }

    if(!precordTypename) {
        status = dbFirstRecordType(pdbentry);
        if(status) {
            /* No record descriptions, so no record instances */
            dbFinishEntry(pdbentry);
            return(0);
        }
    } else {
        status = dbFindRecordType(pdbentry,precordTypename);
        if(status) {
            fprintf(stderr,"dbWriteRecordFP: No record description for %s\n",
                precordTypename);
            dbFinishEntry(pdbentry);
            return(status);
        }
    }
    while(!status) {
        status = dbFirstRecord(pdbentry);
        while(!status) {
            if (dbIsAlias(pdbentry)) {
                status = dbNextRecord(pdbentry);
                continue;
            }
            if(dbIsVisibleRecord(pdbentry))
                fprintf(fp,"grecord(%s,\"%s\") {\n",
                    dbGetRecordTypeName(pdbentry),dbGetRecordName(pdbentry));
            else
                fprintf(fp,"record(%s,\"%s\") {\n",
                    dbGetRecordTypeName(pdbentry),dbGetRecordName(pdbentry));
            status = dbFirstField(pdbentry,dctonly);
            while(!status) {
                if (!dbIsDefaultValue(pdbentry) || level>0) {
                    char *pvalstring = dbGetString(pdbentry);

                    if (!pvalstring) {
                        fprintf(fp,"\tfield(%s,\"\")\n",
                            dbGetFieldName(pdbentry));
                    } else {
                        fprintf(fp,"\tfield(%s,\"",
                            dbGetFieldName(pdbentry));
                        epicsStrPrintEscaped(fp,pvalstring,strlen(pvalstring));
                        fprintf(fp,"\")\n");
                    }
                } else if(level>0) { /*generate 0 length string*/
                    fprintf(fp,"\tfield(%s,\"\")\n",dbGetFieldName(pdbentry));
                }
                status=dbNextField(pdbentry,dctonly);
            }
            status = dbFirstInfo(pdbentry);
            while (!status) {
                const char *pinfostr = dbGetInfoString(pdbentry);

                fprintf(fp, "\tinfo(\"%s\",\"",
                    dbGetInfoName(pdbentry));
                epicsStrPrintEscaped(fp, pinfostr, strlen(pinfostr));
                fprintf(fp, "\")\n");
                status = dbNextInfo(pdbentry);
            }
            fprintf(fp,"}\n");
            status = dbNextRecord(pdbentry);
        }
        status = dbFirstRecord(pdbentry);
        while (!status) {
            if (!dbIsAlias(pdbentry)) {
                status = dbNextRecord(pdbentry);
                continue;
            }
            fprintf(fp, "alias(\"%s\",\"%s\")\n",
                dbRecordName(pdbentry), dbGetRecordName(pdbentry));
            status = dbNextRecord(pdbentry);
        }
        if(precordTypename) break;
        status = dbNextRecordType(pdbentry);
    }
    dbFinishEntry(pdbentry);
    return(0);
}

epicsShareFunc long dbWriteRecordType	(	DBBASE *	pdbbase,
		const char *	filename,
		const char *	recordTypeName
	)

Definition at line 932 of file dbStaticLib.c.

{
    FILE *stream;
    long status;

    stream = openOutstream(filename);
    status = dbWriteRecordTypeFP(pdbbase,stream,recordTypeName);
    finishOutstream(stream);
    return status;
}

epicsShareFunc long dbWriteRecordTypeFP	(	DBBASE *	pdbbase,
		FILE *	fp,
		const char *	recordTypeName
	)

Definition at line 944 of file dbStaticLib.c.

{
    dbRecordType    *pdbRecordType;
    dbFldDes        *pdbFldDes;
    int             gotMatch;
    int             i;

    if(!pdbbase) {
        fprintf(stderr,"pdbbase not specified\n");
        return(-1);
    }
    if (recordTypeName) {
        if (*recordTypeName == 0 || *recordTypeName == '*')
            recordTypeName = 0;
    }

    for(pdbRecordType = (dbRecordType *)ellFirst(&pdbbase->recordTypeList);
    pdbRecordType; pdbRecordType = (dbRecordType *)ellNext(&pdbRecordType->node)) {
        if(recordTypeName) {
            gotMatch = (strcmp(recordTypeName,pdbRecordType->name)==0)
                 ? TRUE : FALSE;
        }else {
            gotMatch=TRUE;
        }
        if(!gotMatch) continue;
        fprintf(fp,"recordtype(%s) {\n",pdbRecordType->name);
        for(i=0; i<pdbRecordType->no_fields; i++) {
            int j;

            pdbFldDes = pdbRecordType->papFldDes[i];
            fprintf(fp,"\tfield(%s,%s) {\n",pdbFldDes->name,
                dbGetFieldTypeString(pdbFldDes->field_type));
            if(pdbFldDes->prompt)
                fprintf(fp,"\t\tprompt(\"%s\")\n",pdbFldDes->prompt);
            if(pdbFldDes->initial)
                fprintf(fp,"\t\tinitial(\"%s\")\n",pdbFldDes->initial);
        if (pdbFldDes->promptgroup) {
            fprintf(fp,"\t\tpromptgroup(\"%s\")\n",
                    dbGetPromptGroupNameFromKey(pdbbase, pdbFldDes->promptgroup));
        }
        if(pdbFldDes->special) {
                if(pdbFldDes->special >= SPC_NTYPES) {
                    fprintf(fp,"\t\tspecial(%d)\n",pdbFldDes->special);
                } else for(j=0; j<SPC_NTYPES; j++) {
                    if(pamapspcType[j].value == pdbFldDes->special) {
                        fprintf(fp,"\t\tspecial(%s)\n",
                                pamapspcType[j].strvalue);
                        break;
                    }
                }
            }
            if(pdbFldDes->extra)
                fprintf(fp,"\t\textra(\"%s\")\n",pdbFldDes->extra);
            if(pdbFldDes->field_type==DBF_MENU) {
                if(pdbFldDes->ftPvt)
                    fprintf(fp,"\t\tmenu(%s)\n",
                        ((dbMenu *)pdbFldDes->ftPvt)->name);
                else
                   fprintf(stderr,"\t\t  menu: NOT FOUND\n");
            }
            if(pdbFldDes->field_type==DBF_STRING) {
                fprintf(fp,"\t\tsize(%d)\n",
                    pdbFldDes->size);
            }
            if(pdbFldDes->process_passive) fprintf(fp,"\t\tpp(TRUE)\n");
            if(pdbFldDes->prop) fprintf(fp,"\t\tprop(YES)\n");
            if(pdbFldDes->base) fprintf(fp,"\t\tbase(HEX)\n");
            if(pdbFldDes->interest)
                fprintf(fp,"\t\tinterest(%d)\n",pdbFldDes->interest);
            if(!pdbFldDes->as_level) fprintf(fp,"\t\tasl(ASL0)\n");
            fprintf(fp,"\t}\n");
        }
        fprintf(fp,"}\n");
        if(recordTypeName) break;
    }
    return(0);
}

epicsShareFunc long dbWriteRegistrarFP	(	DBBASE *	pdbbase,
		FILE *	fp
	)

Definition at line 1106 of file dbStaticLib.c.

{
    dbText  *ptext;

    if(!pdbbase) {
        fprintf(stderr,"pdbbase not specified\n");
        return(-1);
    }
    for(ptext = (dbText *)ellFirst(&pdbbase->registrarList);
    ptext; ptext = (dbText *)ellNext(&ptext->node)) {
        fprintf(fp,"registrar(%s)\n",ptext->text);
    }
    return(0);
}

epicsShareFunc long dbWriteVariableFP	(	DBBASE *	pdbbase,
		FILE *	fp
	)

Definition at line 1136 of file dbStaticLib.c.

{
    dbVariableDef   *pvar;

    if(!pdbbase) {
        fprintf(stderr,"pdbbase not specified\n");
        return(-1);
    }
    for(pvar = (dbVariableDef *)ellFirst(&pdbbase->variableList);
        pvar; pvar = (dbVariableDef *)ellNext(&pvar->node)) {
        fprintf(fp,"variable(%s,%s)\n",pvar->name,pvar->type);
    }
    return(0);
}

Variable Documentation

epicsShareExtern int dbBptNotMonotonic

Definition at line 57 of file dbStaticLib.h.

int dbConvertStrict

Definition at line 34 of file dbStaticRun.c.

int dbStaticDebug

Definition at line 49 of file dbStaticLib.c.