void dbRegisterFilter(const char *name, const chFilterIf *fif, void *puser)
{
GPHENTRY *pgph;
chFilterPlugin *pfilt;
if (!pdbbase) {
printf("dbRegisterFilter: pdbbase not set!\n");
return;
}
pgph = gphFind(pdbbase->pgpHash, name, &pdbbase->filterList);
if (pgph)
return;
pfilt = dbCalloc(1, sizeof(chFilterPlugin));
pfilt->name = epicsStrDup(name);
pfilt->fif = fif;
pfilt->puser = puser;
ellAdd(&pdbbase->filterList, &pfilt->node);
pgph = gphAdd(pdbbase->pgpHash, pfilt->name, &pdbbase->filterList);
if (!pgph) {
free((void *) pfilt->name);
free(pfilt);
printf("dbRegisterFilter: gphAdd failed\n");
return;
}
pgph->userPvt = pfilt;
}
epicsShareFunc int
asynOctetConnect(const char *entry, const char *port, int addr,
int timeout, int buffer_len, const char *drvInfo)
{
asynIOPvt *pPvt;
asynUser *pasynUser;
asynStatus status;
GPHENTRY *hashEntry;
pPvt = asynFindEntry(entry);
if (pPvt) {
printf("Entry already connected\n");
return(-1);
}
status = pasynOctetSyncIO->connect(port, addr, &pasynUser,drvInfo);
if (status) {
printf("connect failed %s\n",pasynUser->errorMessage);
pasynOctetSyncIO->disconnect(pasynUser);
return(-1);
}
hashEntry = gphAdd(asynHash, epicsStrDup(entry), NULL);
pPvt = (asynIOPvt *)calloc(1, sizeof(asynIOPvt));
hashEntry->userPvt = pPvt;
pPvt->pasynUser = pasynUser;
pPvt->timeout = timeout ? (double)timeout : READ_TIMEOUT;
pPvt->write_buffer_len = buffer_len ? buffer_len : BUFFER_SIZE;
pPvt->write_buffer = calloc(1, pPvt->write_buffer_len);
pPvt->read_buffer_len = pPvt->write_buffer_len;
pPvt->read_buffer = calloc(1, pPvt->read_buffer_len);
return(0);
}
epicsShareFunc int epicsShareAPI registryAdd(
void *registryID,const char *name,void *data)
{
GPHENTRY *pentry;
if(!gphPvt) registryInit(0);
pentry = gphAdd(gphPvt,name,registryID);
if(!pentry) return(FALSE);
pentry->userPvt = data;
return(TRUE);
}
static void dbFunction(char *name)
{
dbText *ptext;
GPHENTRY *pgphentry;
pgphentry = gphFind(pdbbase->pgpHash,name,&pdbbase->functionList);
if(pgphentry) {
return;
}
ptext = dbCalloc(1,sizeof(dbText));
ptext->text = epicsStrDup(name);
pgphentry = gphAdd(pdbbase->pgpHash,ptext->text,&pdbbase->functionList);
if(!pgphentry) {
yyerrorAbort("gphAdd failed");
}
pgphentry->userPvt = ptext;
ellAdd(&pdbbase->functionList,&ptext->node);
}
static void dbDriver(char *name)
{
drvSup *pdrvSup;
GPHENTRY *pgphentry;
pgphentry = gphFind(pdbbase->pgpHash,name,&pdbbase->drvList);
if(pgphentry) {
return;
}
pdrvSup = dbCalloc(1,sizeof(drvSup));
pdrvSup->name = epicsStrDup(name);
pgphentry = gphAdd(pdbbase->pgpHash,pdrvSup->name,&pdbbase->drvList);
if(!pgphentry) {
yyerrorAbort("gphAdd failed");
}
pgphentry->userPvt = pdrvSup;
ellAdd(&pdbbase->drvList,&pdrvSup->node);
}
static void dbDevice(char *recordtype,char *linktype,
char *dsetname,char *choicestring)
{
devSup *pdevSup;
dbRecordType *pdbRecordType;
GPHENTRY *pgphentry;
int i,link_type;
pgphentry = gphFind(pdbbase->pgpHash,recordtype,&pdbbase->recordTypeList);
if(!pgphentry) {
epicsPrintf("Record type \"%s\" not found for device \"%s\"\n",
recordtype, choicestring);
yyerror(NULL);
return;
}
link_type=-1;
for(i=0; i<LINK_NTYPES; i++) {
if(strcmp(pamaplinkType[i].strvalue,linktype)==0) {
link_type = pamaplinkType[i].value;
break;
}
}
if(link_type==-1) {
epicsPrintf("Bad link type \"%s\" for device \"%s\"\n",
linktype, choicestring);
yyerror(NULL);
return;
}
pdbRecordType = (dbRecordType *)pgphentry->userPvt;
pgphentry = gphFind(pdbbase->pgpHash,choicestring,&pdbRecordType->devList);
if(pgphentry) {
return;
}
pdevSup = dbCalloc(1,sizeof(devSup));
pdevSup->name = epicsStrDup(dsetname);
pdevSup->choice = epicsStrDup(choicestring);
pdevSup->link_type = link_type;
pgphentry = gphAdd(pdbbase->pgpHash,pdevSup->choice,&pdbRecordType->devList);
if(!pgphentry) {
yyerrorAbort("gphAdd failed");
} else {
pgphentry->userPvt = pdevSup;
}
ellAdd(&pdbRecordType->devList,&pdevSup->node);
}
static void dbVariable(char *name, char *type)
{
dbVariableDef *pvar;
GPHENTRY *pgphentry;
pgphentry = gphFind(pdbbase->pgpHash,name,&pdbbase->variableList);
if(pgphentry) {
return;
}
pvar = dbCalloc(1,sizeof(dbVariableDef));
pvar->name = epicsStrDup(name);
pvar->type = epicsStrDup(type);
pgphentry = gphAdd(pdbbase->pgpHash,pvar->name,&pdbbase->variableList);
if(!pgphentry) {
yyerrorAbort("gphAdd failed");
}
pgphentry->userPvt = pvar;
ellAdd(&pdbbase->variableList,&pvar->node);
}
void *sym_table_insert(SymTable st, const char *name, void *type, void *value)
{
GPHENTRY *pentry;
assert(st.table);
if (!value)
{
return 0;
}
pentry = gphAdd(st.table, name, type);
if (pentry) /* success, value was inserted */
{
pentry->userPvt = value; /* maintain invariant */
return pentry->userPvt;
}
else /* failed, there is already such a key */
{
return 0;
}
}
static void dbMenuBody(void)
{
dbMenu *pnewMenu;
dbMenu *pMenu;
int nChoice;
int i;
GPHENTRY *pgphentry;
if(duplicate) {
duplicate = FALSE;
return;
}
pnewMenu = (dbMenu *)popFirstTemp();
pnewMenu->nChoice = nChoice = ellCount(&tempList)/2;
pnewMenu->papChoiceName = dbCalloc(pnewMenu->nChoice,sizeof(char *));
pnewMenu->papChoiceValue = dbCalloc(pnewMenu->nChoice,sizeof(char *));
for(i=0; i<nChoice; i++) {
pnewMenu->papChoiceName[i] = (char *)popFirstTemp();
pnewMenu->papChoiceValue[i] = (char *)popFirstTemp();
}
if(ellCount(&tempList)) yyerrorAbort("dbMenuBody: tempList not empty");
/* Add menu in sorted order */
pMenu = (dbMenu *)ellFirst(&pdbbase->menuList);
while(pMenu && strcmp(pMenu->name,pnewMenu->name) >0 )
pMenu = (dbMenu *)ellNext(&pMenu->node);
if(pMenu)
ellInsert(&pdbbase->menuList,ellPrevious(&pMenu->node),&pnewMenu->node);
else
ellAdd(&pdbbase->menuList,&pnewMenu->node);
pgphentry = gphAdd(pdbbase->pgpHash,pnewMenu->name,&pdbbase->menuList);
if(!pgphentry) {
yyerrorAbort("gphAdd failed");
} else {
pgphentry->userPvt = pnewMenu;
}
}
static void dbBreakBody(void)
{
brkTable *pnewbrkTable;
brkInt *paBrkInt;
brkTable *pbrkTable;
int number, down=0;
int i;
GPHENTRY *pgphentry;
if (duplicate) {
duplicate = FALSE;
return;
}
pnewbrkTable = (brkTable *)popFirstTemp();
number = ellCount(&tempList);
if (number % 2) {
yyerrorAbort("breaktable: Raw value missing");
return;
}
number /= 2;
if (number < 2) {
yyerrorAbort("breaktable: Must have at least two points!");
return;
}
pnewbrkTable->number = number;
pnewbrkTable->paBrkInt = paBrkInt = dbCalloc(number, sizeof(brkInt));
for (i=0; i<number; i++) {
char *str;
str = (char *)popFirstTemp();
epicsScanDouble(str, &paBrkInt[i].raw);
free(str);
str = (char *)popFirstTemp();
epicsScanDouble(str, &paBrkInt[i].eng);
free(str);
}
/* Compute slopes */
for (i=0; i<number-1; i++) {
double slope =
(paBrkInt[i+1].eng - paBrkInt[i].eng)/
(paBrkInt[i+1].raw - paBrkInt[i].raw);
if (!dbBptNotMonotonic && slope == 0) {
yyerrorAbort("breaktable slope is zero");
return;
}
if (i == 0) {
down = (slope < 0);
} else if (!dbBptNotMonotonic && down != (slope < 0)) {
yyerrorAbort("breaktable slope changes sign");
return;
}
paBrkInt[i].slope = slope;
}
/* Continue with last slope beyond the final point */
paBrkInt[number-1].slope = paBrkInt[number-2].slope;
/* Add brkTable in sorted order */
pbrkTable = (brkTable *)ellFirst(&pdbbase->bptList);
while (pbrkTable) {
if (strcmp(pbrkTable->name, pnewbrkTable->name) > 0) {
ellInsert(&pdbbase->bptList, ellPrevious((ELLNODE *)pbrkTable),
(ELLNODE *)pnewbrkTable);
break;
}
pbrkTable = (brkTable *)ellNext(&pbrkTable->node);
}
if (!pbrkTable) ellAdd(&pdbbase->bptList, &pnewbrkTable->node);
pgphentry = gphAdd(pdbbase->pgpHash,pnewbrkTable->name,&pdbbase->bptList);
if (!pgphentry) {
yyerrorAbort("dbBreakBody: gphAdd failed");
return;
}
pgphentry->userPvt = pnewbrkTable;
}
static void dbRecordtypeBody(void)
{
dbRecordType *pdbRecordType;
dbFldDes *pdbFldDes;
int i,j,ilink;
GPHENTRY *pgphentry;
int no_fields,no_prompt,no_links;
dbfType field_type;
char *psortFldNameTemp;
short psortFldIndTemp;
char **papsortFldName;
short *sortFldInd;
if(duplicate) {
duplicate = FALSE;
return;
}
pdbRecordType= (dbRecordType *)popFirstTemp();
pdbRecordType->no_fields = no_fields = ellCount(&tempList);
pdbRecordType->papFldDes = dbCalloc(no_fields,sizeof(dbFldDes *));
pdbRecordType->papsortFldName = dbCalloc(no_fields,sizeof(char *));
pdbRecordType->sortFldInd = dbCalloc(no_fields,sizeof(short));
no_prompt = no_links = 0;
for(i=0; i<no_fields; i++) {
pdbFldDes = (dbFldDes *)popFirstTemp();
pdbFldDes->pdbRecordType = pdbRecordType;
pdbFldDes->indRecordType = i;
pdbRecordType->papFldDes[i] = pdbFldDes;
if(pdbFldDes->promptgroup) no_prompt++;
field_type = pdbFldDes->field_type;
if((field_type>=DBF_INLINK) && (field_type<=DBF_FWDLINK))no_links++;
if((field_type==DBF_STRING) && (pdbFldDes->size==0))
fprintf(stderr,"recordtype(%s).%s size not specified\n",
pdbRecordType->name,pdbFldDes->name);
if((field_type==DBF_NOACCESS) && (pdbFldDes->extra==0))
fprintf(stderr,"recordtype(%s).%s extra not specified\n",
pdbRecordType->name,pdbFldDes->name);
}
if(ellCount(&tempList)) yyerrorAbort("dbMenuBody: tempList not empty");
pdbRecordType->no_prompt = no_prompt;
pdbRecordType->no_links = no_links;
pdbRecordType->link_ind = dbCalloc(no_links,sizeof(short));
ilink = 0;
for(i=0; i<no_fields; i++) {
pdbFldDes = pdbRecordType->papFldDes[i];
/* if prompt is null make it a null string */
if(!pdbFldDes->prompt) pdbFldDes->prompt = dbCalloc(1,sizeof(char));
field_type = pdbFldDes->field_type;
if((field_type>=DBF_INLINK) && (field_type<=DBF_FWDLINK))
pdbRecordType->link_ind[ilink++] = i;
if(strcmp(pdbFldDes->name,"VAL")==0) {
pdbRecordType->pvalFldDes = pdbRecordType->papFldDes[i];
pdbRecordType->indvalFlddes = i;
}
pdbRecordType->papsortFldName[i] = pdbFldDes->name;
pdbRecordType->sortFldInd[i] = i;
}
/*Now sort fields. Sorry dumb sort algorithm */
papsortFldName = pdbRecordType->papsortFldName;
sortFldInd = pdbRecordType->sortFldInd;
for(i=0; i<no_fields; i++) {
for(j=i+1; j<no_fields; j++) {
if(strcmp(papsortFldName[j],papsortFldName[i])<0 ) {
psortFldNameTemp = papsortFldName[j];
psortFldIndTemp = sortFldInd[j];
papsortFldName[j] = papsortFldName[i];
sortFldInd[j] = sortFldInd[i];
papsortFldName[i] = psortFldNameTemp;
sortFldInd[i] = psortFldIndTemp;
}
}
}
/*Initialize lists*/
ellInit(&pdbRecordType->attributeList);
ellInit(&pdbRecordType->recList);
ellInit(&pdbRecordType->devList);
pgphentry = gphAdd(pdbbase->pgpHash,pdbRecordType->name,
&pdbbase->recordTypeList);
if(!pgphentry) {
yyerrorAbort("gphAdd failed");
} else {
pgphentry->userPvt = pdbRecordType;
}
ellAdd(&pdbbase->recordTypeList,&pdbRecordType->node);
}
