epics/pcas
0
0
Fork 0
Code Issues Pull Requests Projects Wiki Activity

main changes is recdes => recordType

Browse Source
This commit is contained in:
Marty Kraimer
1996-06-24 13:20:20 +00:00
parent 6f2acd5645
commit 4376d7b186
13 changed files with 742 additions and 606 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
src/dbStatic/dbBase.h
View File

@@ -89,8 +89,8 @@ typedef struct dbFldDes{ /* field description */
char *prompt; /*Prompt string for DCT*/
char *name; /*Field name*/
char *extra; /*C def for DBF_NOACCESS*/
struct dbRecDes *pdbRecDes;
short indRecDes; /*within dbRecDes.papFldDes */
struct dbRecordType *pdbRecordType;
short indRecordType; /*within dbRecordType.papFldDes */
short special; /*Special processing requirements */
dbfType field_type; /*Field type as defined in dbFldTypes.h */
short process_passive;/*should dbPutField process passive */
@@ -113,7 +113,7 @@ typedef struct dbRecordNode {
char *recordname;
}dbRecordNode;
typedef struct dbRecDes {
typedef struct dbRecordType {
ELLNODE node;
ELLLIST recList; /*LIST head of sorted dbRecordNodes*/
ELLLIST devList; /*List of associated device support*/
@@ -130,11 +130,11 @@ typedef struct dbRecDes {
/*The following are only available on run time system*/
struct rset *prset;
int rec_size; /*record size in bytes */
}dbRecDes;
}dbRecordType;
typedef struct dbBase {
ELLLIST menuList;
ELLLIST recDesList;
ELLLIST recordTypeList;
ELLLIST drvList;
ELLLIST bptList; /*Break Point Table Head*/
void *pathPvt;

38
src/dbStatic/dbExpandInclude.c
View File

@@ -19,6 +19,7 @@ of this distribution.
#include <stdlib.h>
#include <stddef.h>
#include <stdio.h>
#include <string.h>
#include <epicsPrint.h>
#include <errMdef.h>
#include <dbStaticLib.h>
@@ -27,30 +28,41 @@ of this distribution.
#include <gpHash.h>
DBBASE *pdbbase = NULL;
#define MAX_PATH_LENGTH 256
static void addPath(char *path,char *newdir)
{
if((strlen(path)+strlen(newdir)+2) > (size_t)MAX_PATH_LENGTH) {
fprintf(stderr,"path > 256 characters\n");
exit(-1);
}
if(strlen(path) > (size_t)0) strcat(path,":");
strcat(path,newdir);
}
int main(int argc,char **argv)
{
int arg,strip;
char *path=0;
int strip;
char path[MAX_PATH_LENGTH];
long status;
int i;
/*Look for path, i.e. -I path or -Ipath*/
for(arg=1; arg<argc; arg++) {
if(strncmp(argv[arg],"-I",2)!=0) continue;
if(strlen(argv[arg])==2) {
path = argv[arg+1];
/*Look for path, i.e. -I dir or -Idir*/
path[0] = 0;
while(strncmp(argv[1],"-I",2)==0) {
if(strlen(argv[1])==2) {
addPath(path,argv[2]);
strip = 2;
} else {
path = argv[arg] + 2;
addPath(path,argv[1]+2);
strip = 1;
}
argc -= strip;
for(i=arg; i<argc; i++) argv[i] = argv[i + strip];
break;
for(i=1; i<argc; i++) argv[i] = argv[i + strip];
}
if(argc<2) {
printf("usage: dbExpandInclude -Ipath file1.db file2.db ...\n");
if(argc<2 || (strncmp(argv[1],"-",1)==0)) {
fprintf(stderr,
"usage: dbExpandInclude -Idir -Idir file1.dbd file2.dbd ...\n");
exit(0);
}
for(i=1; i<argc; i++) {
@@ -60,7 +72,7 @@ int main(int argc,char **argv)
errMessage(status,"from dbReadDatabase");
}
dbWriteMenuFP(pdbbase,stdout,0);
dbWriteRecDesFP(pdbbase,stdout,0);
dbWriteRecordTypeFP(pdbbase,stdout,0);
dbWriteDeviceFP(pdbbase,stdout);
dbWriteDriverFP(pdbbase,stdout);
dbWriteBreaktableFP(pdbbase,stdout);

109
src/dbStatic/dbLexRoutines.c
View File

@@ -67,7 +67,7 @@ static void dbBreakHead(char *name);
static void dbBreakItem(char *value);
static void dbBreakBody(void);
static void dbRecordHead(char *rectype,char*name);
static void dbRecordHead(char *recordType,char*name);
static void dbRecordField(char *name,char *value);
static void dbRecordBody(void);
@@ -99,8 +99,7 @@ static int duplicate = FALSE;
static void yyerrorAbort(char *str)
{
yyerror(str);
free((void *)my_buffer);
exit(-1);
yyAbort = TRUE;
}
static void allocTemp(void *pvoid)
@@ -158,6 +157,21 @@ static char *dbOpenFile(DBBASE *pdbbase,const char *filename,FILE **fp)
}
return(0);
}
static void freeInputFileList(void)
{
inputFile *pinputFileNow;
while(pinputFileNow=(inputFile *)ellFirst(&inputFileList)) {
if(fclose(pinputFileNow->fp))
errPrintf(0,__FILE__, __LINE__,
"Closing file %s",pinputFileNow->filename);
free((void *)pinputFileNow->filename);
ellDelete(&inputFileList,(ELLNODE *)pinputFileNow);
free((void *)pinputFileNow);
}
}
static long dbReadCOM(DBBASE **ppdbbase,const char *filename, FILE *fp,
const char *path)
@@ -214,7 +228,9 @@ static long dbReadCOM(DBBASE **ppdbbase,const char *filename, FILE *fp,
}
freeListCleanup(freeListPvt);
free((void *)my_buffer);
return(0);
freeInputFileList();
dbFreePath(pdbbase);
return(status);
}
long dbReadDatabase(DBBASE **ppdbbase,const char *filename,const char *path)
@@ -227,6 +243,7 @@ static int db_yyinput(char *buf, int max_size)
{
int l,n;
if(yyAbort) return(0);
if(*my_buffer_ptr==0) {
while(fgets(my_buffer,MY_BUFFER_SIZE,pinputFileNow->fp)==NULL) {
if(fclose(pinputFileNow->fp))
@@ -374,20 +391,20 @@ static void dbMenuBody(void)
static void dbRecordtypeHead(char *name)
{
dbRecDes *pdbRecDes;
dbRecordType *pdbRecordType;
GPHENTRY *pgphentry;
pgphentry = gphFind(pdbbase->pgpHash,name,&pdbbase->recDesList);
pgphentry = gphFind(pdbbase->pgpHash,name,&pdbbase->recordTypeList);
if(pgphentry) {
duplicate = TRUE;
free((void *)name);
return;
}
pdbRecDes = dbCalloc(1,sizeof(dbRecDes));
pdbRecDes->name = name;
pdbRecordType = dbCalloc(1,sizeof(dbRecordType));
pdbRecordType->name = name;
if(ellCount(&tempList))
yyerrorAbort("dbRecordtypeHead tempList not empty");
allocTemp(pdbRecDes);
allocTemp(pdbRecordType);
}
static void dbRecordtypeFieldHead(char *name,char *type)
@@ -533,7 +550,7 @@ static void dbRecordtypeFieldItem(char *name,char *value)
static void dbRecordtypeBody(void)
{
dbRecDes *pdbRecDes;
dbRecordType *pdbRecordType;
dbFldDes *pdbFldDes;
int i,j,ilink;
GPHENTRY *pgphentry;
@@ -548,47 +565,47 @@ static void dbRecordtypeBody(void)
duplicate = FALSE;
return;
}
pdbRecDes= (dbRecDes *)popFirstTemp();
pdbRecDes->no_fields = no_fields = ellCount(&tempList);
pdbRecDes->papFldDes = dbCalloc(no_fields,sizeof(dbFldDes *));
pdbRecDes->papsortFldName = dbCalloc(no_fields,sizeof(char *));
pdbRecDes->sortFldInd = dbCalloc(no_fields,sizeof(short));
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->pdbRecDes = pdbRecDes;
pdbFldDes->indRecDes = i;
pdbRecDes->papFldDes[i] = pdbFldDes;
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",
pdbRecDes->name,pdbFldDes->name);
pdbRecordType->name,pdbFldDes->name);
if((field_type==DBF_NOACCESS) && (pdbFldDes->extra==0))
fprintf(stderr,"recordtype(%s).%s extra not specified\n",
pdbRecDes->name,pdbFldDes->name);
pdbRecordType->name,pdbFldDes->name);
}
if(ellCount(&tempList)) yyerrorAbort("dbMenuBody: tempList not empty");
pdbRecDes->no_prompt = no_prompt;
pdbRecDes->no_links = no_links;
pdbRecDes->link_ind = dbCalloc(no_prompt,sizeof(short));
pdbRecordType->no_prompt = no_prompt;
pdbRecordType->no_links = no_links;
pdbRecordType->link_ind = dbCalloc(no_prompt,sizeof(short));
ilink = 0;
for(i=0; i<no_fields; i++) {
pdbFldDes = pdbRecDes->papFldDes[i];
pdbFldDes = pdbRecordType->papFldDes[i];
field_type = pdbFldDes->field_type;
if((field_type>=DBF_INLINK) && (field_type<=DBF_FWDLINK))
pdbRecDes->link_ind[ilink++] = i;
pdbRecordType->link_ind[ilink++] = i;
if(strcmp(pdbFldDes->name,"VAL")==0) {
pdbRecDes->pvalFldDes = pdbRecDes->papFldDes[i];
pdbRecDes->indvalFlddes = i;
pdbRecordType->pvalFldDes = pdbRecordType->papFldDes[i];
pdbRecordType->indvalFlddes = i;
}
pdbRecDes->papsortFldName[i] = pdbFldDes->name;
pdbRecDes->sortFldInd[i] = i;
pdbRecordType->papsortFldName[i] = pdbFldDes->name;
pdbRecordType->sortFldInd[i] = i;
}
/*Now sort fields. Sorry dumb sort algorithm */
papsortFldName = pdbRecDes->papsortFldName;
sortFldInd = pdbRecDes->sortFldInd;
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 ) {
@@ -602,27 +619,27 @@ static void dbRecordtypeBody(void)
}
}
/*Initialize lists*/
ellInit(&pdbRecDes->recList);
ellInit(&pdbRecDes->devList);
pgphentry = gphAdd(pdbbase->pgpHash,pdbRecDes->name,&pdbbase->recDesList);
ellInit(&pdbRecordType->recList);
ellInit(&pdbRecordType->devList);
pgphentry = gphAdd(pdbbase->pgpHash,pdbRecordType->name,&pdbbase->recordTypeList);
if(!pgphentry) {
yyerrorAbort("gphAdd failed");
} else {
pgphentry->userPvt = pdbRecDes;
pgphentry->userPvt = pdbRecordType;
}
ellAdd(&pdbbase->recDesList,&pdbRecDes->node);
dbGetRecordtypeSizeOffset(pdbRecDes);
ellAdd(&pdbbase->recordTypeList,&pdbRecordType->node);
dbGetRecordtypeSizeOffset(pdbRecordType);
}
static void dbDevice(char *recordtype,char *linktype,
char *dsetname,char *choicestring)
{
devSup *pdevSup;
dbRecDes *pdbRecDes;
dbRecordType *pdbRecordType;
GPHENTRY *pgphentry;
int i,link_type;
pgphentry = gphFind(pdbbase->pgpHash,recordtype,&pdbbase->recDesList);
pgphentry = gphFind(pdbbase->pgpHash,recordtype,&pdbbase->recordTypeList);
if(!pgphentry) {
yyerror(" record type not found");
free((void *)recordtype);
@@ -644,8 +661,8 @@ static void dbDevice(char *recordtype,char *linktype,
yyerror("Illegal link type");
return;
}
pdbRecDes = (dbRecDes *)pgphentry->userPvt;
pgphentry = gphFind(pdbbase->pgpHash,choicestring,&pdbRecDes->devList);
pdbRecordType = (dbRecordType *)pgphentry->userPvt;
pgphentry = gphFind(pdbbase->pgpHash,choicestring,&pdbRecordType->devList);
if(pgphentry) {
free((void *)dsetname);
free((void *)choicestring);
@@ -655,13 +672,13 @@ static void dbDevice(char *recordtype,char *linktype,
pdevSup->name = dsetname;
pdevSup->choice = choicestring;
pdevSup->link_type = link_type;
pgphentry = gphAdd(pdbbase->pgpHash,choicestring,&pdbRecDes->devList);
pgphentry = gphAdd(pdbbase->pgpHash,choicestring,&pdbRecordType->devList);
if(!pgphentry) {
yyerror("gphAdd failed");
} else {
pgphentry->userPvt = pdevSup;
}
ellAdd(&pdbRecDes->devList,&pdevSup->node);
ellAdd(&pdbRecordType->devList,&pdevSup->node);
}
static void dbDriver(char *name)
@@ -774,7 +791,7 @@ static void dbBreakBody(void)
if(!pbrkTable) ellAdd(&pdbbase->bptList,&pnewbrkTable->node);
}
static void dbRecordHead(char *rectype,char *name)
static void dbRecordHead(char *recordType,char *name)
{
DBENTRY *pdbentry;
long status;
@@ -783,7 +800,7 @@ static void dbRecordHead(char *rectype,char *name)
if(ellCount(&tempList))
yyerrorAbort("dbRecordHead: tempList not empty");
allocTemp(pdbentry);
status = dbFindRecdes(pdbentry,rectype);
status = dbFindRecordType(pdbentry,recordType);
if(status) {
errMessage(status,"");
yyerrorAbort(NULL);
@@ -791,7 +808,7 @@ static void dbRecordHead(char *rectype,char *name)
}
/*Duplicate records ok. Thus dont check return status.*/
dbCreateRecord(pdbentry,name);
free((void *)rectype);
free((void *)recordType);
free((void *)name);
}

4
src/dbStatic/dbPvdLib.c
View File

@@ -137,7 +137,7 @@ PVDENTRY *dbPvdFind(dbBase *pdbbase,char *name,int lenName)
return (NULL);
}
PVDENTRY *dbPvdAdd(dbBase *pdbbase,dbRecDes *precdes,dbRecordNode *precnode)
PVDENTRY *dbPvdAdd(dbBase *pdbbase,dbRecordType *precordType,dbRecordNode *precnode)
{
unsigned short hashInd;
ELLLIST **ppvd = (ELLLIST **) pdbbase->ppvd;
@@ -160,7 +160,7 @@ PVDENTRY *dbPvdAdd(dbBase *pdbbase,dbRecDes *precdes,dbRecordNode *precnode)
}
ppvdNode = dbCalloc(1, sizeof(PVDENTRY));
ellAdd(ppvdlist, (ELLNODE*)ppvdNode);
ppvdNode->precdes = precdes;
ppvdNode->precordType = precordType;
ppvdNode->precnode = precnode;
return (ppvdNode);
}

53
src/dbStatic/dbReadTest.c
View File

@@ -27,30 +27,41 @@ of this distribution.
#include <gpHash.h>
DBBASE *pdbbase = NULL;
#define MAX_PATH_LENGTH 256
static void addPath(char *path,char *newdir)
{
if((strlen(path)+strlen(newdir)+2) > (size_t)MAX_PATH_LENGTH) {
fprintf(stderr,"path > 256 characters\n");
exit(-1);
}
if(strlen(path) > (size_t)0) strcat(path,":");
strcat(path,newdir);
}
int main(int argc,char **argv)
{
long status;
int i;
int arg,strip;
char *path=0;
long status;
int strip;
char path[MAX_PATH_LENGTH];
int i;
/*Look for path, i.e. -I path or -Ipath*/
for(arg=1; arg<argc; arg++) {
if(strncmp(argv[arg],"-I",2)!=0) continue;
if(strlen(argv[arg])==2) {
path = argv[arg+1];
strip = 2;
} else {
path = argv[arg] + 2;
strip = 1;
}
argc -= strip;
for(i=arg; i<argc; i++) argv[i] = argv[i + strip];
break;
/*Look for path, i.e. -I dir or -Idir*/
path[0] = 0;
while(strncmp(argv[1],"-I",2)==0) {
if(strlen(argv[1])==2) {
addPath(path,argv[2]);
strip = 2;
} else {
addPath(path,argv[1]+2);
strip = 1;
}
argc -= strip;
for(i=1; i<argc; i++) argv[i] = argv[i + strip];
}
if(argc<2) {
printf("usage: dbReadTest file1.db file2.db ...\n");
if(argc<2 || (strncmp(argv[1],"-",1)==0)) {
printf("usage: dbReadTest -Idir -Idir file.dbd file.dbd \n");
exit(0);
}
for(i=1; i<argc; i++) {
@@ -60,8 +71,8 @@ int main(int argc,char **argv)
errMessage(status,"from dbReadDatabase");
}
/*
dbDumpRecDes(pdbbase,"ai");
dbDumpRecDes(pdbbase,NULL);
dbDumpRecordType(pdbbase,"ai");
dbDumpRecordType(pdbbase,NULL);
dbPvdDump(pdbbase);
gphDump(pdbbase->pgpHash);
dbDumpMenu(pdbbase,NULL);

829
src/dbStatic/dbStaticLib.c
View File

File diff suppressed because it is too large Load Diff

61
src/dbStatic/dbStaticLib.h
View File

@@ -62,15 +62,11 @@
#define DCT_LINK_PV 2
#define DCT_LINK_DEVICE 3
/*options for dbRead and dbWrite*/
#define DB_RECDES_IO 0x1
#define DB_RECORD_IO 0x2
typedef dbBase DBBASE;
typedef struct{
DBBASE *pdbbase;
dbRecDes *precdes;
dbRecordType *precordType;
dbFldDes *pflddes;
dbRecordNode *precnode;
void *pfield;
@@ -93,13 +89,13 @@ long dbReadDatabaseFP(DBBASE **ppdbbase,FILE *fp,const char *path);
long dbPath(DBBASE *pdbbase,const char *path);
long dbAddPath(DBBASE *pdbbase,const char *path);
long dbWriteRecord(DBBASE *ppdbbase,const char *filename,
char *precdesname,int level);
char *precordTypename,int level);
long dbWriteRecordFP(DBBASE *ppdbbase,FILE *fp,
char *precdesname,int level);
char *precordTypename,int level);
long dbWriteMenu(DBBASE *pdbbase,const char *filename,char *menuName);
long dbWriteMenuFP(DBBASE *pdbbase,FILE *fp,char *menuName);
long dbWriteRecDes(DBBASE *pdbbase,const char *filename,char *recdesName);
long dbWriteRecDesFP(DBBASE *pdbbase,FILE *fp,char *recdesName);
long dbWriteRecordType(DBBASE *pdbbase,const char *filename,char *recordTypeName);
long dbWriteRecordTypeFP(DBBASE *pdbbase,FILE *fp,char *recordTypeName);
long dbWriteDevice(DBBASE *pdbbase,const char *filename);
long dbWriteDeviceFP(DBBASE *pdbbase,FILE *fp);
long dbWriteDriver(DBBASE *pdbbase,const char *filename);
@@ -107,16 +103,36 @@ long dbWriteDriverFP(DBBASE *pdbbase,FILE *fp);
long dbWriteBreaktable(DBBASE *pdbbase,const char *filename);
long dbWriteBreaktableFP(DBBASE *pdbbase,FILE *fp);
/*Following two routines are obsolete. For now dbRead calls dbAsciiRead.*/
/*Following are obsolete. For now dbRead calls dbAsciiRead.*/
/* dbWrite does nothing */
#define DB_RECORDTYPE_IO 0x1
#define DB_RECORD_IO 0x2
long dbRead(DBBASE *pdbbase,FILE *fp);
long dbWrite(DBBASE *pdbbase,FILE *fpdctsdr,FILE *fp);
long dbFindRecdes(DBENTRY *pdbentry,char *recdesname);
long dbFirstRecdes(DBENTRY *pdbentry);
long dbNextRecdes(DBENTRY *pdbentry);
char *dbGetRecdesName(DBENTRY *pdbentry);
int dbGetNRecdes(DBENTRY *pdbentry);
long dbFirstFielddes(DBENTRY *pdbentry,int dctonly);
long dbNextFielddes(DBENTRY *pdbentry,int dctonly);
char **dbGetChoices(DBENTRY *pdbentry);
/*End obsolete routines*/
long dbFindRecordType(DBENTRY *pdbentry,char *recordTypename);
long dbFirstRecordType(DBENTRY *pdbentry);
long dbNextRecordType(DBENTRY *pdbentry);
char *dbGetRecordTypeName(DBENTRY *pdbentry);
int dbGetNRecordTypes(DBENTRY *pdbentry);
long dbFirstField(DBENTRY *pdbentry,int dctonly);
long dbNextField(DBENTRY *pdbentry,int dctonly);
int dbGetFieldType(DBENTRY *pdbentry);
int dbGetNFields(DBENTRY *pdbentry,int dctonly);
char *dbGetFieldName(DBENTRY *pdbentry);
char *dbGetDefault(DBENTRY *pdbentry);
char *dbGetPrompt(DBENTRY *pdbentry);
int dbGetPromptGroup(DBENTRY *pdbentry);
long dbCreateRecord(DBENTRY *pdbentry,char *precordName);
long dbDeleteRecord(DBENTRY *pdbentry);
@@ -126,17 +142,10 @@ long dbNextRecord(DBENTRY *pdbentry);
int dbGetNRecords(DBENTRY *pdbentry);
char *dbGetRecordName(DBENTRY *pdbentry);
long dbRenameRecord(DBENTRY *pdbentry,char *newName);
long dbFirstFielddes(DBENTRY *pdbentry,int dctonly);
long dbNextFielddes(DBENTRY *pdbentry,int dctonly);
int dbGetFieldType(DBENTRY *pdbentry);
int dbGetNFields(DBENTRY *pdbentry,int dctonly);
char *dbGetFieldName(DBENTRY *pdbentry);
char *dbGetDefault(DBENTRY *pdbentry);
char *dbGetPrompt(DBENTRY *pdbentry);
int dbGetPromptGroup(DBENTRY *pdbentry);
long dbCopyRecord(DBENTRY *pdbentry,char *newRecordName,int overWriteOK);
long dbFindField(DBENTRY *pdbentry,char *pfieldName);
int dbFoundField(DBENTRY *pdbentry);
char *dbGetString(DBENTRY *pdbentry);
long dbPutString(DBENTRY *pdbentry,char *pstring);
char *dbVerify(DBENTRY *pdbentry,char *pstring);
@@ -146,7 +155,7 @@ int dbIsDefaultValue(DBENTRY *pdbentry);
brkTable *dbFindBrkTable(DBBASE *pdbbase,char *name);
dbMenu *dbFindMenu(DBBASE *pdbbase,char *name);
char **dbGetChoices(DBENTRY *pdbentry);
char **dbGetMenuChoices(DBENTRY *pdbentry);
int dbGetMenuIndex(DBENTRY *pdbentry);
long dbPutMenuIndex(DBENTRY *pdbentry,int index);
int dbGetNMenuChoices(DBENTRY *pdbentry);
@@ -166,11 +175,11 @@ long dbCvtLinkToPvlink(DBENTRY *pdbentry);
/*dump routines*/
void dbDumpPath(DBBASE *pdbbase);
void dbDumpRecord(DBBASE *pdbbase,char *precdesname,int level);
void dbDumpRecord(DBBASE *pdbbase,char *precordTypename,int level);
void dbDumpMenu(DBBASE *pdbbase,char *menuName);
void dbDumpRecDes(DBBASE *pdbbase,char *recdesName);
void dbDumpFldDes(DBBASE *pdbbase,char *recdesName,char *fname);
void dbDumpDevice(DBBASE *pdbbase,char *recdesName);
void dbDumpRecordType(DBBASE *pdbbase,char *recordTypeName);
void dbDumpFldDes(DBBASE *pdbbase,char *recordTypeName,char *fname);
void dbDumpDevice(DBBASE *pdbbase,char *recordTypeName);
void dbDumpDriver(DBBASE *pdbbase);
void dbDumpBreaktable(DBBASE *pdbbase,char *name);
void dbPvdDump(DBBASE *pdbbase,int verbose);
@@ -184,7 +193,7 @@ void *dbMalloc(size_t size);
extern int dbStaticDebug;
#define S_dbLib_recdesNotFound (M_dbLib| 1) /*Record Type does not exist*/
#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*/

46
src/dbStatic/dbStaticNoRun.c
View File

@@ -31,31 +31,31 @@ of this distribution.
long dbAllocRecord(DBENTRY *pdbentry,char *precordName)
{
dbRecDes *pdbRecDes = pdbentry->precdes;
dbRecordType *pdbRecordType = pdbentry->precordType;
dbRecordNode *precnode = pdbentry->precnode;
dbFldDes *pflddes;
void **papField;
int i;
char *pstr;
if(!pdbRecDes) return(S_dbLib_recdesNotFound);
if(!pdbRecordType) return(S_dbLib_recordTypeNotFound);
if(!precnode) return(S_dbLib_recNotFound);
precnode->precord = dbCalloc(pdbRecDes->no_fields,sizeof(void *));
precnode->precord = dbCalloc(pdbRecordType->no_fields,sizeof(void *));
papField = (void **)precnode->precord;
for(i=0; i<pdbRecDes->no_fields; i++) {
pflddes = pdbRecDes->papFldDes[i];
for(i=0; i<pdbRecordType->no_fields; i++) {
pflddes = pdbRecordType->papFldDes[i];
if(!pflddes) continue;
switch(pflddes->field_type) {
case DBF_STRING:
if(pflddes->size <= 0) {
fprintf(stderr,"size=0 for %s.%s\n",pdbRecDes->name,pflddes->name);
fprintf(stderr,"size=0 for %s.%s\n",pdbRecordType->name,pflddes->name);
pflddes->size = 1;
}
papField[i] = dbCalloc(pflddes->size,sizeof(char));
if(pflddes->initial) {
if(strlen(pflddes->initial) >= (unsigned)(pflddes->size)) {
fprintf(stderr,"initial size > size for %s.%s\n",
pdbRecDes->name,pflddes->name);
pdbRecordType->name,pflddes->name);
} else {
strcpy((char *)papField[i],pflddes->initial);
}
@@ -107,19 +107,19 @@ long dbAllocRecord(DBENTRY *pdbentry,char *precordName)
long dbFreeRecord(DBENTRY *pdbentry)
{
dbRecDes *pdbRecDes = pdbentry->precdes;
dbRecordType *pdbRecordType = pdbentry->precordType;
dbRecordNode *precnode = pdbentry->precnode;
dbFldDes *pflddes = pdbentry->pflddes;
void **pap;
int i,field_type;
if(!pdbRecDes) return(S_dbLib_recdesNotFound);
if(!pdbRecordType) return(S_dbLib_recordTypeNotFound);
if(!precnode) return(S_dbLib_recNotFound);
if(!precnode->precord) return(S_dbLib_recNotFound);
pap = (void **)precnode->precord;
precnode->precord = NULL;
for(i=0; i<pdbRecDes->no_fields; i++) {
pflddes = pdbRecDes->papFldDes[i];
for(i=0; i<pdbRecordType->no_fields; i++) {
pflddes = pdbRecordType->papFldDes[i];
field_type = pflddes->field_type;
if(field_type==DBF_INLINK
|| field_type==DBF_OUTLINK
@@ -147,27 +147,27 @@ long dbFreeRecord(DBENTRY *pdbentry)
long dbGetFieldAddress(DBENTRY *pdbentry)
{
dbRecDes *pdbRecDes = pdbentry->precdes;
dbRecordType *pdbRecordType = pdbentry->precordType;
dbRecordNode *precnode = pdbentry->precnode;
dbFldDes *pflddes = pdbentry->pflddes;
void **pap;
if(!pdbRecDes) return(S_dbLib_recdesNotFound);
if(!pdbRecordType) return(S_dbLib_recordTypeNotFound);
if(!precnode) return(S_dbLib_recNotFound);
if(!pflddes) return(S_dbLib_flddesNotFound);
if(!precnode->precord) return(0);
pap = (void **)precnode->precord;
pdbentry->pfield = pap[pflddes->indRecDes];
pdbentry->pfield = pap[pflddes->indRecordType];
return(0);
}
char *dbRecordName(DBENTRY *pdbentry)
{
dbRecDes *pdbRecDes = pdbentry->precdes;
dbRecordType *pdbRecordType = pdbentry->precordType;
dbRecordNode *precnode = pdbentry->precnode;
void **pap;
if(!pdbRecDes) return(0);
if(!pdbRecordType) return(0);
if(!precnode) return(0);
if(!precnode->precord) return(0);
pap = (void **)precnode->precord;
@@ -208,14 +208,14 @@ int dbIsDefaultValue(DBENTRY *pdbentry)
return((val==ival)?TRUE:FALSE);
}
case DBF_DEVICE: {
dbRecDes *pdbRecDes = pdbentry->precdes;
dbRecordType *pdbRecordType = pdbentry->precordType;
devSup *pdevSup;
if(!pdbRecDes) {
epicsPrintf("dbIsDefaultValue: pdbRecDes is NULL??\n");
if(!pdbRecordType) {
epicsPrintf("dbIsDefaultValue: pdbRecordType is NULL??\n");
return(FALSE);
}
pdevSup = (devSup *)ellFirst(&pdbRecDes->devList);
pdevSup = (devSup *)ellFirst(&pdbRecordType->devList);
if(!pdevSup) return(TRUE);
return(FALSE);
}
@@ -249,7 +249,7 @@ char *dbGetStringNum(DBENTRY *pdbentry)
if(!pflddes) return(0);
pap = (void **)precnode->precord;
if(!pfield) return(zero);
return((char *)pap[pflddes->indRecDes]);
return((char *)pap[pflddes->indRecordType]);
}
long dbPutStringNum(DBENTRY *pdbentry,char *pstring)
@@ -273,13 +273,13 @@ long dbPutStringNum(DBENTRY *pdbentry,char *pstring)
strcpy(pfield,pstring);
pdbentry->pfield = pfield;
pap = (void **)precnode->precord;
pap[pflddes->indRecDes] = pfield;
pap[pflddes->indRecordType] = pfield;
}
strcpy(pfield,pstring);
return(0);
}
void dbGetRecordtypeSizeOffset(dbRecDes *pdbRecDes)
void dbGetRecordtypeSizeOffset(dbRecordType *pdbRecordType)
{
/*For no run cant and dont need to set size and offset*/
return;

7
src/dbStatic/dbStaticPvt.h
View File

@@ -35,6 +35,7 @@
/*Following are not intended for client code */
void dbInitDeviceMenu(DBENTRY *pdbentry);
void dbFreeParmString(char **pparm);
void dbFreePath(DBBASE *pdbbase);
/*The following routines have different versions for run-time no-run-time*/
long dbAllocRecord(DBENTRY *pdbentry,char *precordName);
@@ -46,7 +47,7 @@ char *dbRecordName(DBENTRY *pdbentry);
char *dbGetStringNum(DBENTRY *pdbentry);
long dbPutStringNum(DBENTRY *pdbentry,char *pstring);
void dbGetRecordtypeSizeOffset(dbRecDes *pdbRecDes);
void dbGetRecordtypeSizeOffset(dbRecordType *pdbRecordType);
/* The following is for path */
typedef struct dbPathNode {
@@ -58,14 +59,14 @@ typedef struct dbPathNode {
/*directory*/
typedef struct{
ELLNODE node;
dbRecDes *precdes;
dbRecordType *precordType;
dbRecordNode *precnode;
}PVDENTRY;
int dbPvdTableSize(int size);
extern int dbStaticDebug;
void dbPvdInitPvt(DBBASE *pdbbase);
PVDENTRY *dbPvdFind(DBBASE *pdbbase,char *name,int lenname);
PVDENTRY *dbPvdAdd(DBBASE *pdbbase,dbRecDes *precdes,dbRecordNode *precnode);
PVDENTRY *dbPvdAdd(DBBASE *pdbbase,dbRecordType *precordType,dbRecordNode *precnode);
void dbPvdDelete(DBBASE *pdbbase,dbRecordNode *precnode);
void dbPvdFreeMem(DBBASE *pdbbase);
void dbPvdDump(DBBASE *pdbbase,int verbose);

52
src/dbStatic/dbStaticRun.c
View File

@@ -152,23 +152,23 @@ static void doubleToString(double value,char *preturn)
long dbAllocRecord(DBENTRY *pdbentry,char *precordName)
{
dbRecDes *pdbRecDes = pdbentry->precdes;
dbRecordType *pdbRecordType = pdbentry->precordType;
dbRecordNode *precnode = pdbentry->precnode;
dbFldDes *pflddes;
int i;
char *precord;
char *pfield;
if(!pdbRecDes) return(S_dbLib_recdesNotFound);
if(!pdbRecordType) return(S_dbLib_recordTypeNotFound);
if(!precnode) return(S_dbLib_recNotFound);
precnode->precord = dbCalloc(1,pdbRecDes->rec_size);
precnode->precord = dbCalloc(1,pdbRecordType->rec_size);
precord = (char *)precnode->precord;
if(pdbRecDes->rec_size == 0) {
if(pdbRecordType->rec_size == 0) {
epicsPrintf("dbAllocRecord(%s) record_size =0\n",
pdbRecDes->name);
pdbRecordType->name);
return(S_dbLib_noRecSup);
}
pflddes = pdbRecDes->papFldDes[0];
pflddes = pdbRecordType->papFldDes[0];
if(!pflddes) {
epicsPrintf("dbAllocRecord pflddes for NAME not found\n");
return(S_dbLib_flddesNotFound);
@@ -179,9 +179,9 @@ long dbAllocRecord(DBENTRY *pdbentry,char *precordName)
}
pfield = precord + pflddes->offset;
strcpy(pfield,precordName);
for(i=1; i<pdbRecDes->no_fields; i++) {
for(i=1; i<pdbRecordType->no_fields; i++) {
pflddes = pdbRecDes->papFldDes[i];
pflddes = pdbRecordType->papFldDes[i];
if(!pflddes) continue;
pfield = precord + pflddes->offset;
pdbentry->pfield = (void *)pfield;
@@ -192,7 +192,7 @@ long dbAllocRecord(DBENTRY *pdbentry,char *precordName)
if(pflddes->initial) {
if(strlen(pflddes->initial) >= pflddes->size) {
epicsPrintf("initial size > size for %s.%s\n",
pdbRecDes->name,pflddes->name);
pdbRecordType->name,pflddes->name);
} else {
strcpy(pfield,pflddes->initial);
}
@@ -214,7 +214,7 @@ long dbAllocRecord(DBENTRY *pdbentry,char *precordName)
status = dbPutStringNum(pdbentry,pflddes->initial);
if(status)
epicsPrintf("Error initializing %s.%s initial %s\n",
pdbRecDes->name,pflddes->name,pflddes->initial);
pdbRecordType->name,pflddes->name,pflddes->initial);
}
break;
case DBF_DEVICE:
@@ -243,10 +243,10 @@ long dbAllocRecord(DBENTRY *pdbentry,char *precordName)
long dbFreeRecord(DBENTRY *pdbentry)
{
dbRecDes *pdbRecDes = pdbentry->precdes;
dbRecordType *pdbRecordType = pdbentry->precordType;
dbRecordNode *precnode = pdbentry->precnode;
if(!pdbRecDes) return(S_dbLib_recdesNotFound);
if(!pdbRecordType) return(S_dbLib_recordTypeNotFound);
if(!precnode) return(S_dbLib_recNotFound);
if(!precnode->precord) return(S_dbLib_recNotFound);
free(precnode->precord);
@@ -256,11 +256,11 @@ long dbFreeRecord(DBENTRY *pdbentry)
long dbGetFieldAddress(DBENTRY *pdbentry)
{
dbRecDes *pdbRecDes = pdbentry->precdes;
dbRecordType *pdbRecordType = pdbentry->precordType;
dbRecordNode *precnode = pdbentry->precnode;
dbFldDes *pflddes = pdbentry->pflddes;
if(!pdbRecDes) return(S_dbLib_recdesNotFound);
if(!pdbRecordType) return(S_dbLib_recordTypeNotFound);
if(!precnode) return(S_dbLib_recNotFound);
if(!pflddes) return(S_dbLib_flddesNotFound);
if(!precnode->precord) return(0);
@@ -270,16 +270,16 @@ long dbGetFieldAddress(DBENTRY *pdbentry)
char *dbRecordName(DBENTRY *pdbentry)
{
dbRecDes *pdbRecDes = pdbentry->precdes;
dbRecordType *pdbRecordType = pdbentry->precordType;
dbRecordNode *precnode = pdbentry->precnode;
dbFldDes *pflddes;
char *precord;
if(!pdbRecDes) return(0);
if(!pdbRecordType) return(0);
if(!precnode) return(0);
if(!precnode->precord) return(0);
precord = (char *)precnode->precord;
pflddes = pdbRecDes->papFldDes[0];
pflddes = pdbRecordType->papFldDes[0];
if(!pflddes) return(NULL);
return(precord + pflddes->offset);
}
@@ -389,14 +389,14 @@ int dbIsDefaultValue(DBENTRY *pdbentry)
return((field==0));
}
case DBF_DEVICE: {
dbRecDes *pdbRecDes = pdbentry->precdes;
dbRecordType *pdbRecordType = pdbentry->precordType;
devSup *pdevSup;
if(!pdbRecDes) {
epicsPrintf("dbIsDefaultValue: pdbRecDes is NULL??\n");
if(!pdbRecordType) {
epicsPrintf("dbIsDefaultValue: pdbRecordType is NULL??\n");
return(FALSE);
}
pdevSup = (devSup *)ellFirst(&pdbRecDes->devList);
pdevSup = (devSup *)ellFirst(&pdbRecordType->devList);
if(!pdevSup) return(TRUE);
return(FALSE);
}
@@ -589,23 +589,23 @@ long dbPutStringNum(DBENTRY *pdbentry,char *pstring)
return(status);
}
void dbGetRecordtypeSizeOffset(dbRecDes *pdbRecDes)
void dbGetRecordtypeSizeOffset(dbRecordType *pdbRecordType)
{
char name[60];
SYM_TYPE type;
STATUS vxstatus;
long status;
int (*sizeOffset)(dbRecDes *pdbRecDes);
int (*sizeOffset)(dbRecordType *pdbRecordType);
strcpy(name,"_");
strcat(name,pdbRecDes->name);
strcat(name,pdbRecordType->name);
strcat(name,"RecordSizeOffset");
vxstatus = symFindByName(sysSymTbl, name,
(void *)&sizeOffset, &type);
if (vxstatus != OK) {
status = S_rec_noSizeOffset;
errPrintf(status,__FILE__,__LINE__,"%s",name);
exit(1);
taskSuspend(0);
}
sizeOffset(pdbRecDes);
sizeOffset(pdbRecordType);
}

43
src/dbStatic/dbToMenuH.c
View File

@@ -28,45 +28,56 @@ of this distribution.
DBBASE *pdbbase = NULL;
#define MAX_PATH_LENGTH 256
static void addPath(char *path,char *newdir)
{
if((strlen(path)+strlen(newdir)+2) > (size_t)MAX_PATH_LENGTH) {
fprintf(stderr,"path > 256 characters\n");
exit(-1);
}
if(strlen(path) > (size_t)0) strcat(path,":");
strcat(path,newdir);
}
int main(int argc,char **argv)
{
int arg,strip;
char *path=0;
long status;
dbMenu *pdbMenu;
char *outFilename;
char *pext;
FILE *outFile;
int i;
char *plastSlash;
/*Look for path, i.e. -I path or -Ipath*/
for(arg=1; arg<argc; arg++) {
if(strncmp(argv[arg],"-I",2)!=0) continue;
if(strlen(argv[arg])==2) {
path = argv[arg+1];
int strip;
char path[MAX_PATH_LENGTH];
int i;
/*Look for path, i.e. -I dir or -Idir*/
path[0] = 0;
while(strncmp(argv[1],"-I",2)==0) {
if(strlen(argv[1])==2) {
addPath(path,argv[2]);
strip = 2;
} else {
path = argv[arg] + 2;
addPath(path,argv[1]+2);
strip = 1;
}
argc -= strip;
for(i=arg; i<argc; i++) argv[i] = argv[i + strip];
break;
for(i=1; i<argc; i++) argv[i] = argv[i + strip];
}
if(argc!=2) {
fprintf(stderr,"usage: dbToMenu -Ipath file.db\n");
exit(-1);
if(argc!=2 || (strncmp(argv[1],"-",1)==0)) {
fprintf(stderr,"usage: dbToMenu -Idir -Idir file.dbd\n");
exit(0);
}
/*remove path so that outFile is created where program is executed*/
plastSlash = strrchr(argv[1],'/');
plastSlash = (plastSlash ? plastSlash+1 : argv[1]);
outFilename = dbCalloc(1,strlen(plastSlash)+1);
strcpy(outFilename,plastSlash);
pext = strstr(outFilename,".db");
pext = strstr(outFilename,".dbd");
if(!pext) {
fprintf(stderr,"Input file MUST have .db extension\n");
fprintf(stderr,"Input file MUST have .dbd extension\n");
exit(-1);
}
strcpy(pext,".h");

94
src/dbStatic/dbToRecordtypeH.c
View File

@@ -27,48 +27,58 @@ of this distribution.
#include <gpHash.h>
DBBASE *pdbbase = NULL;
#define MAX_PATH_LENGTH 256
static void addPath(char *path,char *newdir)
{
if((strlen(path)+strlen(newdir)+2) > (size_t)MAX_PATH_LENGTH) {
fprintf(stderr,"path > 256 characters\n");
exit(-1);
}
if(strlen(path) > (size_t)0) strcat(path,":");
strcat(path,newdir);
}
int main(int argc,char **argv)
{
int arg,strip;
char *path=0;
int strip;
char path[MAX_PATH_LENGTH];
int i;
long status;
char *outFilename;
char *pext;
FILE *outFile;
int i;
dbMenu *pdbMenu;
dbRecDes *pdbRecDes;
dbRecordType *pdbRecordType;
dbFldDes *pdbFldDes;
int isdbCommonRecord = FALSE;
char *plastSlash;
/*Look for path, i.e. -I path or -Ipath*/
for(arg=1; arg<argc; arg++) {
if(strncmp(argv[arg],"-I",2)!=0) continue;
if(strlen(argv[arg])==2) {
path = argv[arg+1];
/*Look for path, i.e. -I dir or -Idir*/
path[0] = 0;
while(strncmp(argv[1],"-I",2)==0) {
if(strlen(argv[1])==2) {
addPath(path,argv[2]);
strip = 2;
} else {
path = argv[arg] + 2;
addPath(path,argv[1]+2);
strip = 1;
}
argc -= strip;
for(i=arg; i<argc; i++) argv[i] = argv[i + strip];
break;
for(i=1; i<argc; i++) argv[i] = argv[i + strip];
}
if(argc!=2) {
fprintf(stderr,"usage: dbToRecordtypeH -Ipath file.db\n");
exit(-1);
if(argc<2 || (strncmp(argv[1],"-",1)==0)) {
fprintf(stderr,"usage: dbToRecordtypeH -Idir -Idir file.dbd\n");
exit(0);
}
/*remove path so that outFile is created where program is executed*/
plastSlash = strrchr(argv[1],'/');
plastSlash = (plastSlash ? plastSlash+1 : argv[1]);
outFilename = dbCalloc(1,strlen(plastSlash)+1);
strcpy(outFilename,plastSlash);
pext = strstr(outFilename,".db");
pext = strstr(outFilename,".dbd");
if(!pext) {
fprintf(stderr,"Input file MUST have .db extension\n");
fprintf(stderr,"Input file MUST have .dbd extension\n");
exit(-1);
}
strcpy(pext,".h");
@@ -106,18 +116,18 @@ int main(int argc,char **argv)
fprintf(outFile,"#endif /*INC%sH*/\n",pdbMenu->name);
pdbMenu = (dbMenu *)ellNext(&pdbMenu->node);
}
pdbRecDes = (dbRecDes *)ellFirst(&pdbbase->recDesList);
while(pdbRecDes) {
fprintf(outFile,"#ifndef INC%sH\n",pdbRecDes->name);
fprintf(outFile,"#define INC%sH\n",pdbRecDes->name);
fprintf(outFile,"typedef struct %s",pdbRecDes->name);
pdbRecordType = (dbRecordType *)ellFirst(&pdbbase->recordTypeList);
while(pdbRecordType) {
fprintf(outFile,"#ifndef INC%sH\n",pdbRecordType->name);
fprintf(outFile,"#define INC%sH\n",pdbRecordType->name);
fprintf(outFile,"typedef struct %s",pdbRecordType->name);
if(!isdbCommonRecord) fprintf(outFile,"Record");
fprintf(outFile," {\n");
for(i=0; i<pdbRecDes->no_fields; i++) {
for(i=0; i<pdbRecordType->no_fields; i++) {
char name[256];
int j;
pdbFldDes = pdbRecDes->papFldDes[i];
pdbFldDes = pdbRecordType->papFldDes[i];
for(j=0; j< (int)strlen(pdbFldDes->name); j++)
name[j] = tolower(pdbFldDes->name[j]);
name[strlen(pdbFldDes->name)] = 0;
@@ -178,46 +188,46 @@ int main(int argc,char **argv)
fprintf(outFile,"ILLEGAL FIELD TYPE\n");
}
}
fprintf(outFile,"} %s",pdbRecDes->name);
fprintf(outFile,"} %s",pdbRecordType->name);
if(!isdbCommonRecord) fprintf(outFile,"Record");
fprintf(outFile,";\n");
if(!isdbCommonRecord) {
for(i=0; i<pdbRecDes->no_fields; i++) {
pdbFldDes = pdbRecDes->papFldDes[i];
for(i=0; i<pdbRecordType->no_fields; i++) {
pdbFldDes = pdbRecordType->papFldDes[i];
fprintf(outFile,"#define %sRecord%s\t%d\n",
pdbRecDes->name,pdbFldDes->name,pdbFldDes->indRecDes);
pdbRecordType->name,pdbFldDes->name,pdbFldDes->indRecordType);
}
}
fprintf(outFile,"#endif /*INC%sH*/\n",pdbRecDes->name);
pdbRecDes = (dbRecDes *)ellNext(&pdbRecDes->node);
if(pdbRecDes) fprintf(outFile,"\n");
fprintf(outFile,"#endif /*INC%sH*/\n",pdbRecordType->name);
pdbRecordType = (dbRecordType *)ellNext(&pdbRecordType->node);
if(pdbRecordType) fprintf(outFile,"\n");
}
if(!isdbCommonRecord) {
fprintf(outFile,"#ifdef GEN_SIZE_OFFSET\n");
pdbRecDes = (dbRecDes *)ellFirst(&pdbbase->recDesList);
while(pdbRecDes) {
fprintf(outFile,"int %sRecordSizeOffset(dbRecDes *pdbRecDes)\n{\n",
pdbRecDes->name);
fprintf(outFile," %sRecord *prec = 0;\n",pdbRecDes->name);
for(i=0; i<pdbRecDes->no_fields; i++) {
pdbRecordType = (dbRecordType *)ellFirst(&pdbbase->recordTypeList);
while(pdbRecordType) {
fprintf(outFile,"int %sRecordSizeOffset(dbRecordType *pdbRecordType)\n{\n",
pdbRecordType->name);
fprintf(outFile," %sRecord *prec = 0;\n",pdbRecordType->name);
for(i=0; i<pdbRecordType->no_fields; i++) {
char name[256];
int j;
pdbFldDes = pdbRecDes->papFldDes[i];
pdbFldDes = pdbRecordType->papFldDes[i];
for(j=0; j< (int)strlen(pdbFldDes->name); j++)
name[j] = tolower(pdbFldDes->name[j]);
name[strlen(pdbFldDes->name)] = 0;
fprintf(outFile,
" pdbRecDes->papFldDes[%d]->size=sizeof(prec->%s);\n",
" pdbRecordType->papFldDes[%d]->size=sizeof(prec->%s);\n",
i,name);
fprintf(outFile," pdbRecDes->papFldDes[%d]->offset=",i);
fprintf(outFile," pdbRecordType->papFldDes[%d]->offset=",i);
fprintf(outFile,
"(short)((char *)&prec->%s - (char *)prec);\n",name);
}
fprintf(outFile," pdbRecDes->rec_size = sizeof(*prec);\n");
fprintf(outFile," pdbRecordType->rec_size = sizeof(*prec);\n");
fprintf(outFile," return(0);\n");
fprintf(outFile,"}\n");
pdbRecDes = (dbRecDes *)ellNext(&pdbRecDes->node);
pdbRecordType = (dbRecordType *)ellNext(&pdbRecordType->node);
}
fprintf(outFile,"#endif /*GEN_SIZE_OFFSET*/\n");
}

2
src/dbStatic/dbYacc.y
View File

@@ -3,6 +3,7 @@ static int yyerror();
static int yy_start;
static long pvt_yy_parse(void);
static int yyFailed = 0;
static int yyAbort = 0;
#include "dbLexRoutines.c"
static char *menuString = "menu";
%}
@@ -198,6 +199,7 @@ static long pvt_yy_parse(void)
long rtnval;
if (!FirstFlag) {
yyAbort = FALSE;
yyFailed = FALSE;
yyreset();
yyrestart(NULL);