diff --git a/src/dbStatic/dbBase.h b/src/dbStatic/dbBase.h
index 1f6b095f4..97fb1a265 100644
--- a/src/dbStatic/dbBase.h
+++ b/src/dbStatic/dbBase.h
@@ -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;
diff --git a/src/dbStatic/dbExpandInclude.c b/src/dbStatic/dbExpandInclude.c
index 15ae5b657..09aa0847a 100644
--- a/src/dbStatic/dbExpandInclude.c
+++ b/src/dbStatic/dbExpandInclude.c
@@ -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);
diff --git a/src/dbStatic/dbLexRoutines.c b/src/dbStatic/dbLexRoutines.c
index 4492f25b6..8a74bde13 100644
--- a/src/dbStatic/dbLexRoutines.c
+++ b/src/dbStatic/dbLexRoutines.c
@@ -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);
 }
 
diff --git a/src/dbStatic/dbPvdLib.c b/src/dbStatic/dbPvdLib.c
index aa67b2294..22665cdb2 100644
--- a/src/dbStatic/dbPvdLib.c
+++ b/src/dbStatic/dbPvdLib.c
@@ -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);
 }
diff --git a/src/dbStatic/dbReadTest.c b/src/dbStatic/dbReadTest.c
index 00b49b87a..d49a42912 100644
--- a/src/dbStatic/dbReadTest.c
+++ b/src/dbStatic/dbReadTest.c
@@ -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);
diff --git a/src/dbStatic/dbStaticLib.c b/src/dbStatic/dbStaticLib.c
index 00cf7e27c..bc9ccad11 100644
--- a/src/dbStatic/dbStaticLib.c
+++ b/src/dbStatic/dbStaticLib.c
@@ -142,6 +142,33 @@ static char *promptOUT_LINK[] = {
 static char **promptAddr[OUTLINK+1];
 static int formlines[OUTLINK+1];
 
+/*Following are obsolete. Will go away next release*/
+long dbRead(DBBASE *pdbbase,FILE *fp)
+{
+    return(dbReadDatabaseFP(&pdbbase,fp,0));
+}
+long dbWrite(DBBASE *pdbbase,FILE *fpdctsdr,FILE *fp)
+{
+    fprintf(stderr,"dbWrite obsolete. It does NOTHING\n");
+    return(-1);
+}
+long dbFindRecdes(DBENTRY *pdbentry,char *recdesname)
+	{return dbFindRecordType(pdbentry,recdesname);}
+long dbFirstRecdes(DBENTRY *pdbentry)
+	{return dbFirstRecordType(pdbentry);}
+long dbNextRecdes(DBENTRY *pdbentry)
+	{return dbNextRecordType(pdbentry);}
+char *dbGetRecdesName(DBENTRY *pdbentry)
+	{return dbGetRecordTypeName(pdbentry);}
+int  dbGetNRecdes(DBENTRY *pdbentry)
+	{return dbGetNRecordTypes(pdbentry);}
+long dbFirstFielddes(DBENTRY *pdbentry,int dctonly)
+	{return dbFirstField(pdbentry,dctonly);}
+long dbNextFielddes(DBENTRY *pdbentry,int dctonly)
+	{return dbNextField(pdbentry,dctonly);}
+char **dbGetChoices(DBENTRY *pdbentry)
+	{return dbGetMenuChoices(pdbentry);}
+
 /* internal routines*/
 /*checkDevChoice initializes INP or OUT field*/
 static char *pNullString = "";
@@ -210,7 +237,8 @@ void dbFreeParmString(char **pparm)
     if(*pparm && (*pparm != pNullString)) free((void *)(*pparm));
 }
 
-static void dbFreePath(DBBASE *pdbbase) {
+void dbFreePath(DBBASE *pdbbase)
+{
     ELLLIST	*ppathList;
     dbPathNode	*pdbPathNode;
 
@@ -262,7 +290,7 @@ static void entryErrMessage(DBENTRY *pdbentry,long status,char *mess)
     char		*pname = NULL;
 
     *pmessage=0;
-    if(pdbentry->precdes) pname = pdbentry->precdes->name;
+    if(pdbentry->precordType) pname = pdbentry->precordType->name;
     if(pname) {
 	strcat(pmessage,"RecordType:");
 	strcat(pmessage,pname);
@@ -285,7 +313,7 @@ static void entryErrMessage(DBENTRY *pdbentry,long status,char *mess)
 static void zeroDbentry(DBENTRY *pdbentry)
 {
     /*NOTE that pdbbase, message, and formpvt MUST NOT be set to NULL*/
-    pdbentry->precdes=NULL;
+    pdbentry->precordType=NULL;
     pdbentry->pflddes=NULL;
     pdbentry->precnode=NULL;
     pdbentry->pfield=NULL;
@@ -330,22 +358,22 @@ static long putPvLink(DBENTRY *pdbentry,short pvlMask,char *pvname)
 /*Public only for dbStaticRun*/
 void dbInitDeviceMenu(DBENTRY *pdbentry)
 {
-    dbRecDes	*precdes = pdbentry->precdes;
+    dbRecordType	*precordType = pdbentry->precordType;
     dbFldDes	*pflddes = pdbentry->pflddes;
     dbDeviceMenu *pdbDeviceMenu;
     devSup	*pdevSup;
     int		ind;
     int		nChoice;
 
-    if(!precdes) return;
+    if(!precordType) return;
     if(!pflddes) return;
-    nChoice = ellCount(&precdes->devList);
+    nChoice = ellCount(&precordType->devList);
     if(nChoice <= 0) return;
     pdbDeviceMenu = dbCalloc(1,sizeof(dbDeviceMenu));
     pdbDeviceMenu->nChoice = nChoice;
     pflddes->ftPvt = pdbDeviceMenu;
     pdbDeviceMenu->papChoice = dbCalloc(pdbDeviceMenu->nChoice,sizeof(char *));
-    pdevSup = (devSup *)ellFirst(&precdes->devList);
+    pdevSup = (devSup *)ellFirst(&precordType->devList);
     ind = 0;
     while(pdevSup) {
 	pdbDeviceMenu->papChoice[ind] = pdevSup->choice;
@@ -390,7 +418,7 @@ dbBase *dbAllocBase(void)
 
     pdbbase = dbCalloc(1,sizeof(dbBase));
     ellInit(&pdbbase->menuList);
-    ellInit(&pdbbase->recDesList);
+    ellInit(&pdbbase->recordTypeList);
     ellInit(&pdbbase->drvList);
     ellInit(&pdbbase->bptList);
     gphInitPvt(&pdbbase->pgpHash,256);
@@ -403,8 +431,8 @@ void dbFreeBase(dbBase *pdbbase)
 {
     dbMenu	*pdbMenu;
     dbMenu	*pdbMenuNext;
-    dbRecDes	*pdbRecDes;
-    dbRecDes	*pdbRecDesNext;
+    dbRecordType	*pdbRecordType;
+    dbRecordType	*pdbRecordTypeNext;
     dbFldDes	*pdbFldDes;
     dbRecordNode *pdbRecordNode;
     dbRecordNode *pdbRecordNodeNext;
@@ -419,22 +447,22 @@ void dbFreeBase(dbBase *pdbbase)
     
 
     dbInitEntry(pdbbase,&dbentry);
-    pdbRecDes = (dbRecDes *)ellFirst(&pdbbase->recDesList);
-    while(pdbRecDes) {
-	pdbRecordNode = (dbRecordNode *)ellFirst(&pdbRecDes->recList);
+    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;
 	}
-	pdbRecDes = (dbRecDes *)ellNext(&pdbRecDes->node);
+	pdbRecordType = (dbRecordType *)ellNext(&pdbRecordType->node);
     }
     dbFinishEntry(&dbentry);
-    pdbRecDes = (dbRecDes *)ellFirst(&pdbbase->recDesList);
-    while(pdbRecDes) {
-	for(i=0; i<pdbRecDes->no_fields; i++) {
-	    pdbFldDes = pdbRecDes->papFldDes[i];
+    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);
@@ -449,25 +477,25 @@ void dbFreeBase(dbBase *pdbbase)
 	    }
 	    free((void *)pdbFldDes);
 	}
-	pdevSup = (devSup *)ellFirst(&pdbRecDes->devList);
+	pdevSup = (devSup *)ellFirst(&pdbRecordType->devList);
 	while(pdevSup) {
 	    pdevSupNext = (devSup *)ellNext(&pdevSup->node);
-	    ellDelete(&pdbRecDes->devList,&pdevSup->node);
+	    ellDelete(&pdbRecordType->devList,&pdevSup->node);
 	    free((void *)pdevSup->name);
 	    free((void *)pdevSup->choice);
 	    free((void *)pdevSup);
 	    pdevSup = pdevSupNext;
 	}
-	pdbRecDesNext = (dbRecDes *)ellNext(&pdbRecDes->node);
-	gphDelete(pdbbase->pgpHash,pdbRecDes->name,&pdbbase->recDesList);
-	ellDelete(&pdbbase->recDesList,&pdbRecDes->node);
-	free((void *)pdbRecDes->name);
-	free((void *)pdbRecDes->link_ind);
-	free((void *)pdbRecDes->papsortFldName);
-	free((void *)pdbRecDes->sortFldInd);
-	free((void *)pdbRecDes->papFldDes);
-	free((void *)pdbRecDes);
-	pdbRecDes = pdbRecDesNext;
+	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) {
@@ -548,16 +576,6 @@ DBENTRY *dbCopyEntry(DBENTRY *pdbentry)
     return(pnew);
 }
 
-long dbRead(DBBASE *pdbbase,FILE *fp)
-{
-    return(dbReadDatabaseFP(&pdbbase,fp,0));
-}
-long dbWrite(DBBASE *pdbbase,FILE *fpdctsdr,FILE *fp)
-{
-    fprintf(stderr,"dbWrite obsolete. It does NOTHING\n");
-    return(-1);
-}
-
 long dbPath(DBBASE *pdbbase,const char *path)
 {
     if(!pdbbase) return(-1);
@@ -598,7 +616,7 @@ long dbAddPath(DBBASE *pdbbase,const char *path)
 }
 
 long dbWriteRecord(DBBASE *ppdbbase,const char *filename,
-	char *precdesname,int level)
+	char *precordTypename,int level)
 {
     FILE	*outFile;
 
@@ -607,11 +625,11 @@ long dbWriteRecord(DBBASE *ppdbbase,const char *filename,
 	errPrintf(0,__FILE__,__LINE__,"Error opening %s\n",filename);
 	return(-1);
     }
-    dbWriteRecordFP(ppdbbase,outFile,precdesname,level);
+    dbWriteRecordFP(ppdbbase,outFile,precordTypename,level);
     return(fclose(outFile));
 }
 
-long dbWriteRecordFP(DBBASE *pdbbase,FILE *fp,char *precdesname,int level)
+long dbWriteRecordFP(DBBASE *pdbbase,FILE *fp,char *precordTypename,int level)
 {
     DBENTRY	dbentry;
     DBENTRY	*pdbentry=&dbentry;
@@ -620,17 +638,17 @@ long dbWriteRecordFP(DBBASE *pdbbase,FILE *fp,char *precdesname,int level)
 
     dctonly = ((level>1) ? FALSE : TRUE);
     dbInitEntry(pdbbase,pdbentry);
-    if(!precdesname) {
-	status = dbFirstRecdes(pdbentry);
+    if(!precordTypename) {
+	status = dbFirstRecordType(pdbentry);
 	if(status) {
 	    fprintf(stderr,"dbWriteRecordFP: No record descriptions\n");
 	    return(status);
 	}
     } else {
-	status = dbFindRecdes(pdbentry,precdesname);
+	status = dbFindRecordType(pdbentry,precordTypename);
 	if(status) {
 	    fprintf(stderr,"dbWriteRecordFP: No record description for %s\n",
-		precdesname);
+		precordTypename);
 	    return(status);
 	}
     }
@@ -638,20 +656,20 @@ long dbWriteRecordFP(DBBASE *pdbbase,FILE *fp,char *precdesname,int level)
 	status = dbFirstRecord(pdbentry);
 	while(!status) {
 	    fprintf(fp,"record(%s,\"%s\") {\n",
-		dbGetRecdesName(pdbentry),dbGetRecordName(pdbentry));
-	    status = dbFirstFielddes(pdbentry,dctonly);
+		dbGetRecordTypeName(pdbentry),dbGetRecordName(pdbentry));
+	    status = dbFirstField(pdbentry,dctonly);
 	    while(!status) {
 		if(!dbIsDefaultValue(pdbentry) || level>0) {
 		    fprintf(fp,"\tfield(%s,\"%s\")\n",
 			dbGetFieldName(pdbentry),dbGetString(pdbentry));
 		}
-		status=dbNextFielddes(pdbentry,dctonly);
+		status=dbNextField(pdbentry,dctonly);
 	    }
 	    fprintf(fp,"}\n");
 	    status = dbNextRecord(pdbentry);
 	}
-	if(precdesname) break;
-	status = dbNextRecdes(pdbentry);
+	if(precordTypename) break;
+	status = dbNextRecordType(pdbentry);
     }
     dbFinishEntry(pdbentry);
     return(0);
@@ -704,7 +722,7 @@ long dbWriteMenuFP(DBBASE *pdbbase,FILE *fp,char *menuName)
     return(0);
 }
 
-long dbWriteRecDes(DBBASE *pdbbase,const char *filename,char *recdesName)
+long dbWriteRecordType(DBBASE *pdbbase,const char *filename,char *recordTypeName)
 {
     FILE	*outFile;
 
@@ -713,16 +731,16 @@ long dbWriteRecDes(DBBASE *pdbbase,const char *filename,char *recdesName)
 	errPrintf(0,__FILE__,__LINE__,"Error opening %s\n",filename);
 	return(-1);
     }
-    dbWriteRecDesFP(pdbbase,outFile,recdesName);
+    dbWriteRecordTypeFP(pdbbase,outFile,recordTypeName);
     if(fclose(outFile)) {
 	errPrintf(0,__FILE__,__LINE__,"Error closing %s\n",filename);
     }
     return(0);
 }
 
-long dbWriteRecDesFP(DBBASE *pdbbase,FILE *fp,char *recdesName)
+long dbWriteRecordTypeFP(DBBASE *pdbbase,FILE *fp,char *recordTypeName)
 {
-    dbRecDes	*pdbRecDes;
+    dbRecordType	*pdbRecordType;
     dbFldDes	*pdbFldDes;
     int		gotMatch;
     int		i;
@@ -731,19 +749,19 @@ long dbWriteRecDesFP(DBBASE *pdbbase,FILE *fp,char *recdesName)
 	fprintf(stderr,"pdbbase not specified\n");
 	return(-1);
     }
-    for(pdbRecDes = (dbRecDes *)ellFirst(&pdbbase->recDesList);
-    pdbRecDes; pdbRecDes = (dbRecDes *)ellNext(&pdbRecDes->node)) {
-	if(recdesName) {
-	    gotMatch = (strcmp(recdesName,pdbRecDes->name)==0) ? TRUE : FALSE;
+    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",pdbRecDes->name);
-	for(i=0; i<pdbRecDes->no_fields; i++) {
+	fprintf(fp,"recordtype(%s) {\n",pdbRecordType->name);
+	for(i=0; i<pdbRecordType->no_fields; i++) {
 	    int	j;
 
-	    pdbFldDes = pdbRecDes->papFldDes[i];
+	    pdbFldDes = pdbRecordType->papFldDes[i];
 	    fprintf(fp,"\tfield(%s,",pdbFldDes->name);
 	    for(j=0; j<DBF_NTYPES; j++) {
 		if(pamapdbfType[j].value == pdbFldDes->field_type) break;
@@ -798,7 +816,7 @@ long dbWriteRecDesFP(DBBASE *pdbbase,FILE *fp,char *recdesName)
 	    fprintf(fp,"\t}\n");
 	}
 	fprintf(fp,"}\n");
-	if(recdesName) break;
+	if(recordTypeName) break;
     }
     return(0);
 }
@@ -821,16 +839,16 @@ long dbWriteDevice(DBBASE *pdbbase,const char *filename)
 
 long dbWriteDeviceFP(DBBASE *pdbbase,FILE *fp)
 {
-    dbRecDes	*pdbRecDes;
+    dbRecordType	*pdbRecordType;
     devSup	*pdevSup;
 
     if(!pdbbase) {
 	fprintf(stderr,"dbWriteDeviceFP: pdbbase not specified\n");
 	return(-1);
     }
-    for(pdbRecDes = (dbRecDes *)ellFirst(&pdbbase->recDesList);
-    pdbRecDes; pdbRecDes = (dbRecDes *)ellNext(&pdbRecDes->node)) {
-	for(pdevSup = (devSup *)ellFirst(&pdbRecDes->devList);
+    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;
 
@@ -842,7 +860,7 @@ long dbWriteDeviceFP(DBBASE *pdbbase,FILE *fp)
 		continue;
 	    }
 	    fprintf(fp,"device(%s,%s,%s,\"%s\")\n",
-		pdbRecDes->name,
+		pdbRecordType->name,
 		pamaplinkType[j].strvalue,
 		pdevSup->name,pdevSup->choice);
 	}
@@ -919,312 +937,79 @@ long dbWriteBreaktableFP(DBBASE *pdbbase,FILE *fp)
     return(0);
 }
 
-long dbFindRecdes(DBENTRY *pdbentry,char *rectype)
+long dbFindRecordType(DBENTRY *pdbentry,char *recordType)
 {
     dbBase	*pdbbase = pdbentry->pdbbase;
     GPHENTRY	*phash;
 
     zeroDbentry(pdbentry);
-    phash = gphFind(pdbbase->pgpHash,rectype,&pdbbase->recDesList);
-    if(!phash) return(S_dbLib_recdesNotFound);
-    pdbentry->precdes = phash->userPvt;
+    phash = gphFind(pdbbase->pgpHash,recordType,&pdbbase->recordTypeList);
+    if(!phash) return(S_dbLib_recordTypeNotFound);
+    pdbentry->precordType = phash->userPvt;
     return(0);
 }
 
-long dbFirstRecdes(DBENTRY *pdbentry)
+long dbFirstRecordType(DBENTRY *pdbentry)
 {
-    dbRecDes *precdes;
+    dbRecordType *precordType;
 
     zeroDbentry(pdbentry);
-    precdes = (dbRecDes *)ellFirst(&pdbentry->pdbbase->recDesList);
-    if(!precdes) return(S_dbLib_recdesNotFound);
-    pdbentry->precdes = precdes;
+    precordType = (dbRecordType *)ellFirst(&pdbentry->pdbbase->recordTypeList);
+    if(!precordType) return(S_dbLib_recordTypeNotFound);
+    pdbentry->precordType = precordType;
     return(0);
 }
 
-long dbNextRecdes(DBENTRY *pdbentry)
+long dbNextRecordType(DBENTRY *pdbentry)
 {
-    dbRecDes *precdes = pdbentry->precdes;
+    dbRecordType *precordType = pdbentry->precordType;
 
     zeroDbentry(pdbentry);
-    precdes = (dbRecDes *)ellNext(&precdes->node);
-    if(!precdes) return(S_dbLib_recdesNotFound);
-    pdbentry->precdes = precdes;
+    precordType = (dbRecordType *)ellNext(&precordType->node);
+    if(!precordType) return(S_dbLib_recordTypeNotFound);
+    pdbentry->precordType = precordType;
     return(0);
 }
 
-char *dbGetRecdesName(DBENTRY *pdbentry)
+char *dbGetRecordTypeName(DBENTRY *pdbentry)
 {
-    return(pdbentry->precdes->name);
+    return(pdbentry->precordType->name);
 }
 
-int dbGetNRecdes(DBENTRY *pdbentry)
+int dbGetNRecordTypes(DBENTRY *pdbentry)
 {
-    return(ellCount(&pdbentry->pdbbase->recDesList));
+    return(ellCount(&pdbentry->pdbbase->recordTypeList));
 }
 
-long dbCreateRecord(DBENTRY *pdbentry,char *precordName)
-{
-    dbRecDes		*precdes = pdbentry->precdes;
-    dbFldDes		*pdbFldDes;
-    PVDENTRY       	*ppvd;
-    ELLLIST           	*preclist = NULL;
-    dbRecordNode       	*precnode = NULL;
-    dbRecordNode       	*pNewRecNode = NULL;
-    long		status;
-    devSup		*pdevSup;
-
-    if(!precdes) return(S_dbLib_recdesNotFound);
-    /*Get size of NAME field*/
-    pdbFldDes = precdes->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->precdes = precdes;
-    preclist = &precdes->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);
-    /* install record node in list in sorted postion */
-    precnode = (dbRecordNode *)ellFirst(preclist);
-    while(precnode && strcmp(precordName,(char*)precnode->precord) > 0)
-	precnode = (dbRecordNode *)ellNext(&precnode->node);
-    if(precnode) 
-	ellInsert(preclist,ellPrevious(&precnode->node),&pNewRecNode->node);
-    else
-	ellAdd(preclist,&pNewRecNode->node);
-    pdbentry->precnode = pNewRecNode;
-    ppvd = dbPvdAdd(pdbentry->pdbbase,precdes,pNewRecNode);
-    if(!ppvd) {errMessage(-1,"Logic Err: Could not add to PVD");return(-1);}
-    /*If any device support exists let checkDevChoice give default for INP/OUT*/
-    pdevSup = (devSup *)ellFirst(&precdes->devList);
-    if(!pdevSup) return(0);
-    status = checkDevChoice(pdbentry,pdevSup->link_type);
-    return (status);
-}
-
-long dbDeleteRecord(DBENTRY *pdbentry)
-{
-    dbBase		*pdbbase = pdbentry->pdbbase;
-    dbRecDes		*precdes = pdbentry->precdes;
-    dbRecordNode	*precnode = pdbentry->precnode;
-    ELLLIST           	*preclist;
-    long		status;
-
-    if (!precnode) return (S_dbLib_recNotFound);
-    preclist = &precdes->recList;
-    ellDelete(preclist,&precnode->node);
-    dbPvdDelete(pdbbase,precnode);
-    if(status = dbFreeRecord(pdbentry)) return(status);
-    free((void *)precnode);
-    pdbentry->precnode = NULL;
-    return (0);
-}
-
-long dbFindRecord(DBENTRY *pdbentry,char *precordName)
-{
-    dbBase	*pdbbase = pdbentry->pdbbase;
-    int         lenName=0;
-    PVDENTRY    *ppvdNode;
-    char        convName[PVNAME_SZ + 1];
-    char        *pconvName = &convName[0];
-
-    
-    zeroDbentry(pdbentry);
-    /* convert the record name */
-    while (*precordName && (*precordName != '.') && (lenName < PVNAME_SZ)) {
-	*pconvName++ = *precordName++;
-	lenName++;
-    }
-    *pconvName = 0;
-    pconvName = &convName[0];
-    ppvdNode = dbPvdFind(pdbbase,pconvName,lenName);
-    if(!ppvdNode) return(S_dbLib_recNotFound);
-    pdbentry->precnode = ppvdNode->precnode;
-    pdbentry->precdes = ppvdNode->precdes;
-    if(*precordName++=='.') return(dbFindField(pdbentry, precordName));
-    return (0);
-}
-
-int dbFoundField(DBENTRY *pdbentry)
-{
-    return((pdbentry->pfield) ? TRUE : FALSE);
-}
-
-long dbFirstRecord(DBENTRY *pdbentry)
-{
-    dbRecDes		*precdes = pdbentry->precdes;
-    dbRecordNode	*precnode;
-
-    zeroDbentry(pdbentry);
-    if(!precdes) return(S_dbLib_recdesNotFound);
-    pdbentry->precdes = precdes;
-    precnode = (dbRecordNode *)ellFirst(&precdes->recList);
-    if(!precnode) return(S_dbLib_recNotFound);
-    pdbentry->precnode = precnode;
-    return(0);
-}
-
-long dbNextRecord(DBENTRY *pdbentry)
-{
-    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);
-}
-
-int dbGetNRecords(DBENTRY *pdbentry)
-{
-    dbRecDes		*precdes = pdbentry->precdes;
-
-    if(!precdes) return(0);
-    return(ellCount(&precdes->recList));
-}
-
-char *dbGetRecordName(DBENTRY *pdbentry)
-{
-    return(dbRecordName(pdbentry));
-}
-
-
-long dbRenameRecord(DBENTRY *pdbentry,char *newName)
-{
-    dbBase		*pdbbase = pdbentry->pdbbase;
-    dbRecDes		*precdes = pdbentry->precdes;
-    dbFldDes		*pdbFldDes;
-    dbRecordNode	*precnode = pdbentry->precnode;
-    PVDENTRY		*ppvd;
-    ELLLIST		*preclist;
-    dbRecordNode	*plistnode;
-    long		status;
-    DBENTRY		dbentry;
-
-    if(!precdes) return(S_dbLib_recdesNotFound);
-    /*Get size of NAME field*/
-    pdbFldDes = precdes->papFldDes[0];
-    if(!pdbFldDes || (strcmp(pdbFldDes->name,"NAME")!=0))
-	return(S_dbLib_nameLength);
-    if((int)strlen(newName)>=pdbFldDes->size) return(S_dbLib_nameLength);
-    if(!precnode) return(S_dbLib_recNotFound);
-    dbInitEntry(pdbentry->pdbbase,&dbentry);
-    status = dbFindRecord(&dbentry,newName);
-    dbFinishEntry(&dbentry);
-    if(!status) return(S_dbLib_recExists);
-    dbPvdDelete(pdbbase,precnode);
-    pdbentry->pflddes = precdes->papFldDes[0];
-    if(status = dbGetFieldAddress(pdbentry)) return(status);
-    strcpy(pdbentry->pfield,newName);
-    ppvd = dbPvdAdd(pdbbase,precdes,precnode);
-    if(!ppvd) {errMessage(-1,"Logic Err: Could not add to PVD");return(-1);}
-    /*remove from record list and reinstall in sorted order*/
-    preclist = &precdes->recList;
-    ellDelete(preclist,&precnode->node);
-    plistnode = (dbRecordNode *)ellFirst(preclist);
-    while(plistnode) {
-	pdbentry->precnode =  plistnode;
-	if(strcmp(newName,dbRecordName(pdbentry)) >=0) break;
-	plistnode = (dbRecordNode *)ellNext(&plistnode->node);
-    }
-    if(plistnode)
-	ellInsert(preclist,ellPrevious(&plistnode->node),&precnode->node);
-    else
-	ellAdd(preclist,&precnode->node);
-    return(0);
-}
-
-long dbFindField(DBENTRY *pdbentry,char *pfieldName)
-{
-    dbRecDes		*precdes = pdbentry->precdes;
-    dbRecordNode	*precnode = pdbentry->precnode;
-    char		*precord;
-    dbFldDes  		*pflddes;
-    short           	top, bottom, test;
-    char  		**papsortFldName;
-    short          	*sortFldInd;
-    long		status;
-    int			compare;
-
-    if(!precdes) return(S_dbLib_recdesNotFound);
-    if(!precnode) return(S_dbLib_recNotFound);
-    precord = precnode->precord;
-    papsortFldName = precdes->papsortFldName;
-    sortFldInd = precdes->sortFldInd;
-    /* check for default field name or VAL to be supplied */
-    if((*pfieldName==0) || (strcmp(pfieldName,"VAL")==0)) {
-	if(!(pflddes=precdes->pvalFldDes)) 
-		return(S_dbLib_recdesNotFound);
-	pdbentry->pflddes = pflddes;
-	pdbentry->indfield = precdes->indvalFlddes;
-	status = dbGetFieldAddress(pdbentry);
-	return (status);
-    }
-    /* binary search through ordered field names */
-    top = precdes->no_fields - 1;
-    bottom = 0;
-    test = (top + bottom) / 2;
-    while (1) {
-	/* check the field name */
-	compare = strcmp(papsortFldName[test],pfieldName);
-	if (compare == 0) {
-	    if(!(pflddes=precdes->papFldDes[sortFldInd[test]]))
-		return(S_dbLib_recdesNotFound);
-	    pdbentry->pflddes = pflddes;
-	    pdbentry->indfield = sortFldInd[test];
-	    status = dbGetFieldAddress(pdbentry);
-	    return (status);
-	} else if (compare > 0) {
-	    top = test - 1;
-	    if (top < bottom) return (S_dbLib_fieldNotFound);
-	    test = (top + bottom) / 2;
-	} else {
-	    bottom = test + 1;
-	    if (top < bottom) return (S_dbLib_fieldNotFound);
-	    test = (top + bottom) / 2;
-	}
-    }
-}
-
-long dbFirstFielddes(DBENTRY *pdbentry,int dctonly)
+long dbFirstField(DBENTRY *pdbentry,int dctonly)
 {
 
     pdbentry->indfield = -1;
-    return(dbNextFielddes(pdbentry,dctonly));
+    return(dbNextField(pdbentry,dctonly));
 }
 
-long dbNextFielddes(DBENTRY *pdbentry,int dctonly)
+long dbNextField(DBENTRY *pdbentry,int dctonly)
 {
-    dbRecDes		*precdes = pdbentry->precdes;
+    dbRecordType		*precordType = pdbentry->precordType;
     dbRecordNode	*precnode = pdbentry->precnode;
     dbFldDes  		*pflddes;
     short		indfield = pdbentry->indfield;
     long		status;
 
-    if(!precdes) return(S_dbLib_recdesNotFound);
+    if(!precordType) return(S_dbLib_recordTypeNotFound);
     indfield++;
     while(TRUE) {
-	if(indfield>=precdes->no_fields) {
+	if(indfield>=precordType->no_fields) {
 	    pdbentry->indfield = 0;
 	    pdbentry->pflddes = NULL;
 	    pdbentry->pfield = NULL;
 	    return(S_dbLib_fieldNotFound);
 	}
-	pflddes = precdes->papFldDes[indfield];
+	pflddes = precordType->papFldDes[indfield];
 	if(!dctonly || pflddes->promptgroup) {
 	    /*Skip field if dctonly and no device support*/
 	    if(!dctonly || (pflddes->field_type!=DBF_DEVICE)
-	    || (ellCount(&precdes->devList)>0)) {
+	    || (ellCount(&precordType->devList)>0)) {
 		pdbentry->indfield = indfield;
 		pdbentry->pflddes = pflddes;
 		pdbentry->indfield = indfield;
@@ -1255,14 +1040,14 @@ int  dbGetFieldType(DBENTRY *pdbentry)
 
 int dbGetNFields(DBENTRY *pdbentry,int dctonly)
 {
-    dbRecDes		*precdes = pdbentry->precdes;
+    dbRecordType		*precordType = pdbentry->precordType;
     dbFldDes  		*pflddes;
     int			indfield,n;
 
-    if(!precdes) return(S_dbLib_recdesNotFound);
+    if(!precordType) return(S_dbLib_recordTypeNotFound);
     n = 0;
-    for(indfield=0; indfield<precdes->no_fields; indfield++) {
-	pflddes = precdes->papFldDes[indfield];
+    for(indfield=0; indfield<precordType->no_fields; indfield++) {
+	pflddes = precordType->papFldDes[indfield];
 	if(!dctonly || pflddes->promptgroup) n++;
     }
     return(n);
@@ -1300,6 +1085,284 @@ int dbGetPromptGroup(DBENTRY *pdbentry)
     return(pflddes->promptgroup);
 }
 
+long dbCreateRecord(DBENTRY *pdbentry,char *precordName)
+{
+    dbRecordType		*precordType = pdbentry->precordType;
+    dbFldDes		*pdbFldDes;
+    PVDENTRY       	*ppvd;
+    ELLLIST           	*preclist = NULL;
+    dbRecordNode       	*precnode = NULL;
+    dbRecordNode       	*pNewRecNode = NULL;
+    long		status;
+    devSup		*pdevSup;
+
+    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);
+    /* install record node in list in sorted postion */
+    precnode = (dbRecordNode *)ellFirst(preclist);
+    while(precnode && strcmp(precordName,(char*)precnode->precord) > 0)
+	precnode = (dbRecordNode *)ellNext(&precnode->node);
+    if(precnode) 
+	ellInsert(preclist,ellPrevious(&precnode->node),&pNewRecNode->node);
+    else
+	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);}
+    /*If any device support exists let checkDevChoice give default for INP/OUT*/
+    pdevSup = (devSup *)ellFirst(&precordType->devList);
+    if(!pdevSup) return(0);
+    status = checkDevChoice(pdbentry,pdevSup->link_type);
+    return (status);
+}
+
+long dbDeleteRecord(DBENTRY *pdbentry)
+{
+    dbBase		*pdbbase = pdbentry->pdbbase;
+    dbRecordType		*precordType = pdbentry->precordType;
+    dbRecordNode	*precnode = pdbentry->precnode;
+    ELLLIST           	*preclist;
+    long		status;
+
+    if (!precnode) return (S_dbLib_recNotFound);
+    preclist = &precordType->recList;
+    ellDelete(preclist,&precnode->node);
+    dbPvdDelete(pdbbase,precnode);
+    if(status = dbFreeRecord(pdbentry)) return(status);
+    free((void *)precnode);
+    pdbentry->precnode = NULL;
+    return (0);
+}
+
+long dbFindRecord(DBENTRY *pdbentry,char *precordName)
+{
+    dbBase	*pdbbase = pdbentry->pdbbase;
+    int         lenName=0;
+    PVDENTRY    *ppvdNode;
+    char        convName[PVNAME_SZ + 1];
+    char        *pconvName = &convName[0];
+
+    
+    zeroDbentry(pdbentry);
+    /* convert the record name */
+    while (*precordName && (*precordName != '.') && (lenName < PVNAME_SZ)) {
+	*pconvName++ = *precordName++;
+	lenName++;
+    }
+    *pconvName = 0;
+    pconvName = &convName[0];
+    ppvdNode = dbPvdFind(pdbbase,pconvName,lenName);
+    if(!ppvdNode) return(S_dbLib_recNotFound);
+    pdbentry->precnode = ppvdNode->precnode;
+    pdbentry->precordType = ppvdNode->precordType;
+    if(*precordName++=='.') return(dbFindField(pdbentry, precordName));
+    return (0);
+}
+
+long dbFirstRecord(DBENTRY *pdbentry)
+{
+    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);
+}
+
+long dbNextRecord(DBENTRY *pdbentry)
+{
+    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);
+}
+
+int dbGetNRecords(DBENTRY *pdbentry)
+{
+    dbRecordType		*precordType = pdbentry->precordType;
+
+    if(!precordType) return(0);
+    return(ellCount(&precordType->recList));
+}
+
+char *dbGetRecordName(DBENTRY *pdbentry)
+{
+    return(dbRecordName(pdbentry));
+}
+
+long dbRenameRecord(DBENTRY *pdbentry,char *newName)
+{
+    dbBase		*pdbbase = pdbentry->pdbbase;
+    dbRecordType	*precordType = pdbentry->precordType;
+    dbFldDes		*pdbFldDes;
+    dbRecordNode	*precnode = pdbentry->precnode;
+    PVDENTRY		*ppvd;
+    ELLLIST		*preclist;
+    dbRecordNode	*plistnode;
+    long		status;
+    DBENTRY		dbentry;
+
+    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(newName)>=pdbFldDes->size) return(S_dbLib_nameLength);
+    if(!precnode) return(S_dbLib_recNotFound);
+    dbInitEntry(pdbentry->pdbbase,&dbentry);
+    status = dbFindRecord(&dbentry,newName);
+    dbFinishEntry(&dbentry);
+    if(!status) return(S_dbLib_recExists);
+    dbPvdDelete(pdbbase,precnode);
+    pdbentry->pflddes = precordType->papFldDes[0];
+    if(status = dbGetFieldAddress(pdbentry)) return(status);
+    strcpy(pdbentry->pfield,newName);
+    ppvd = dbPvdAdd(pdbbase,precordType,precnode);
+    if(!ppvd) {errMessage(-1,"Logic Err: Could not add to PVD");return(-1);}
+    /*remove from record list and reinstall in sorted order*/
+    preclist = &precordType->recList;
+    ellDelete(preclist,&precnode->node);
+    plistnode = (dbRecordNode *)ellFirst(preclist);
+    while(plistnode) {
+	pdbentry->precnode =  plistnode;
+	if(strcmp(newName,dbRecordName(pdbentry)) >=0) break;
+	plistnode = (dbRecordNode *)ellNext(&plistnode->node);
+    }
+    if(plistnode)
+	ellInsert(preclist,ellPrevious(&plistnode->node),&precnode->node);
+    else
+	ellAdd(preclist,&precnode->node);
+    return(0);
+}
+
+long dbCopyRecord(DBENTRY *pdbentry,char *newRecordName,int overWriteOK)
+{
+    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) 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");
+	    exit(1);
+	}
+    }
+    return(0);
+}
+
+long dbFindField(DBENTRY *pdbentry,char *pfieldName)
+{
+    dbRecordType		*precordType = pdbentry->precordType;
+    dbRecordNode	*precnode = pdbentry->precnode;
+    char		*precord;
+    dbFldDes  		*pflddes;
+    short           	top, bottom, test;
+    char  		**papsortFldName;
+    short          	*sortFldInd;
+    long		status;
+    int			compare;
+
+    if(!precordType) return(S_dbLib_recordTypeNotFound);
+    if(!precnode) return(S_dbLib_recNotFound);
+    precord = precnode->precord;
+    papsortFldName = precordType->papsortFldName;
+    sortFldInd = precordType->sortFldInd;
+    /* check for default field name or VAL to be supplied */
+    if((*pfieldName==0) || (strcmp(pfieldName,"VAL")==0)) {
+	if(!(pflddes=precordType->pvalFldDes)) 
+		return(S_dbLib_recordTypeNotFound);
+	pdbentry->pflddes = pflddes;
+	pdbentry->indfield = precordType->indvalFlddes;
+	status = dbGetFieldAddress(pdbentry);
+	return (status);
+    }
+    /* binary search through ordered field names */
+    top = precordType->no_fields - 1;
+    bottom = 0;
+    test = (top + bottom) / 2;
+    while (1) {
+	/* check the field name */
+	compare = strcmp(papsortFldName[test],pfieldName);
+	if (compare == 0) {
+	    if(!(pflddes=precordType->papFldDes[sortFldInd[test]]))
+		return(S_dbLib_recordTypeNotFound);
+	    pdbentry->pflddes = pflddes;
+	    pdbentry->indfield = sortFldInd[test];
+	    status = dbGetFieldAddress(pdbentry);
+	    return (status);
+	} else if (compare > 0) {
+	    top = test - 1;
+	    if (top < bottom) return (S_dbLib_fieldNotFound);
+	    test = (top + bottom) / 2;
+	} else {
+	    bottom = test + 1;
+	    if (top < bottom) return (S_dbLib_fieldNotFound);
+	    test = (top + bottom) / 2;
+	}
+    }
+}
+
+int dbFoundField(DBENTRY *pdbentry)
+{
+    return((pdbentry->pfield) ? TRUE : FALSE);
+}
+
 char *dbGetString(DBENTRY *pdbentry)
 {
     dbFldDes  	*pflddes = pdbentry->pflddes;
@@ -1531,7 +1594,7 @@ long dbPutString(DBENTRY *pdbentry,char *pstring)
 		    long 	link_type;
 		    devSup	*pdevSup;
 
-		    pdevSup = (devSup *)ellNth(&pdbentry->precdes->devList,i+1);
+		    pdevSup = (devSup *)ellNth(&pdbentry->precordType->devList,i+1);
 		    link_type = pdevSup->link_type;
 		    /*If no INP or OUT OK */
 		    checkDevChoice(pdbentry,link_type);
@@ -1997,7 +2060,7 @@ dbMenu *dbFindMenu(dbBase *pdbbase,char *name)
     return((dbMenu *)pgph->userPvt);
 }
 
-char   **dbGetChoices(DBENTRY *pdbentry)
+char   **dbGetMenuChoices(DBENTRY *pdbentry)
 {
     dbFldDes  	*pflddes = pdbentry->pflddes;
 
@@ -2619,21 +2682,21 @@ char  **dbVerifyForm(DBENTRY *pdbentry,char **value)
 
 int dbGetNLinks(DBENTRY *pdbentry)
 {
-    dbRecDes	*precdes = pdbentry->precdes;
+    dbRecordType	*precordType = pdbentry->precordType;
 
-    if(!precdes) return(S_dbLib_recdesNotFound);
-    return((int)precdes->no_links);
+    if(!precordType) return(S_dbLib_recordTypeNotFound);
+    return((int)precordType->no_links);
 }
 
 long dbGetLinkField(DBENTRY *pdbentry,int index)
 {
-    dbRecDes	*precdes = pdbentry->precdes;
+    dbRecordType	*precordType = pdbentry->precordType;
     dbFldDes	*pflddes;
 
-    if(!precdes) return(S_dbLib_recdesNotFound);
-    if(index<0 || index>=precdes->no_links) return(S_dbLib_badLink);
-    pdbentry->indfield = precdes->link_ind[index];
-    pdbentry->pflddes = pflddes = precdes->papFldDes[pdbentry->indfield];
+    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);
 }
@@ -2750,13 +2813,13 @@ void dbDumpPath(DBBASE *pdbbase)
     return;
 }
 
-void dbDumpRecord(dbBase *pdbbase,char *precdesname,int level)
+void dbDumpRecord(dbBase *pdbbase,char *precordTypename,int level)
 {
     if(!pdbbase) {
 	printf("pdbbase not specified\n");
 	return;
     }
-    dbWriteRecordFP(pdbbase,stdout,precdesname,level);
+    dbWriteRecordFP(pdbbase,stdout,precordTypename,level);
 }
 
 void dbDumpMenu(DBBASE *pdbbase,char *menuName)
@@ -2768,9 +2831,9 @@ void dbDumpMenu(DBBASE *pdbbase,char *menuName)
     dbWriteMenuFP(pdbbase,stdout,menuName);
 }
 
-void dbDumpRecDes(DBBASE *pdbbase,char *recdesName)
+void dbDumpRecordType(DBBASE *pdbbase,char *recordTypeName)
 {
-    dbRecDes	*pdbRecDes;
+    dbRecordType	*pdbRecordType;
     dbFldDes	*pdbFldDes;
     int		gotMatch;
     int		i;
@@ -2779,39 +2842,39 @@ void dbDumpRecDes(DBBASE *pdbbase,char *recdesName)
 	printf("pdbbase not specified\n");
 	return;
     }
-    for(pdbRecDes = (dbRecDes *)ellFirst(&pdbbase->recDesList);
-    pdbRecDes; pdbRecDes = (dbRecDes *)ellNext(&pdbRecDes->node)) {
-	if(recdesName) {
-	    gotMatch = (strcmp(recdesName,pdbRecDes->name)==0) ? TRUE : FALSE;
+    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",
-	    pdbRecDes->name,pdbRecDes->no_fields,
-	    pdbRecDes->no_prompt,pdbRecDes->no_links);
+	    pdbRecordType->name,pdbRecordType->no_fields,
+	    pdbRecordType->no_prompt,pdbRecordType->no_links);
 	printf("index name\tsortind sortname\n");
-	for(i=0; i<pdbRecDes->no_fields; i++) {
-	    pdbFldDes = pdbRecDes->papFldDes[i];
+	for(i=0; i<pdbRecordType->no_fields; i++) {
+	    pdbFldDes = pdbRecordType->papFldDes[i];
 	    printf("%5d %s\t%7d %s\n",
 		i,pdbFldDes->name,
-		pdbRecDes->sortFldInd[i],pdbRecDes->papsortFldName[i]);
+		pdbRecordType->sortFldInd[i],pdbRecordType->papsortFldName[i]);
 	}
 	printf("link_ind ");
-	for(i=0; i<pdbRecDes->no_links; i++)
-	    printf(" %hd",pdbRecDes->link_ind[i]);
+	for(i=0; i<pdbRecordType->no_links; i++)
+	    printf(" %hd",pdbRecordType->link_ind[i]);
 	printf("\n");
-	printf("indvalFlddes %d name %s\n",pdbRecDes->indvalFlddes,
-	    pdbRecDes->pvalFldDes->name);
+	printf("indvalFlddes %d name %s\n",pdbRecordType->indvalFlddes,
+	    pdbRecordType->pvalFldDes->name);
 	printf("struct rset * %p rec_size %d\n",
-	    pdbRecDes->prset,pdbRecDes->rec_size);
-	if(recdesName) break;
+	    pdbRecordType->prset,pdbRecordType->rec_size);
+	if(recordTypeName) break;
     }
 }
 
-void dbDumpFldDes(DBBASE *pdbbase,char *recdesName,char *fname)
+void dbDumpFldDes(DBBASE *pdbbase,char *recordTypeName,char *fname)
 {
-    dbRecDes	*pdbRecDes;
+    dbRecordType	*pdbRecordType;
     dbFldDes	*pdbFldDes;
     int		gotMatch;
     int		i;
@@ -2820,24 +2883,24 @@ void dbDumpFldDes(DBBASE *pdbbase,char *recdesName,char *fname)
 	printf("pdbbase not specified\n");
 	return;
     }
-    for(pdbRecDes = (dbRecDes *)ellFirst(&pdbbase->recDesList);
-    pdbRecDes; pdbRecDes = (dbRecDes *)ellNext(&pdbRecDes->node)) {
-	if(recdesName) {
-	    gotMatch = (strcmp(recdesName,pdbRecDes->name)==0) ? TRUE : FALSE;
+    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",pdbRecDes->name);
-	for(i=0; i<pdbRecDes->no_fields; i++) {
+	printf("recordtype(%s) \n",pdbRecordType->name);
+	for(i=0; i<pdbRecordType->no_fields; i++) {
 	    int	j;
 
-	    pdbFldDes = pdbRecDes->papFldDes[i];
+	    pdbFldDes = pdbRecordType->papFldDes[i];
 	    if(fname && strcmp(fname,pdbFldDes->name)!=0) continue;
 	    printf("    %s\n", pdbFldDes->name);
 	    printf("\t         prompt: %s\n",pdbFldDes->prompt);
 	    printf("\t          extra: %s\n",pdbFldDes->extra);
-	    printf("\t      indRecDes: %hd\n",pdbFldDes->indRecDes);
+	    printf("\t      indRecordType: %hd\n",pdbFldDes->indRecordType);
 	    printf("\t        special: %hd ",pdbFldDes->special);
 	    if(pdbFldDes->special) {
 		for(j=0; j<SPC_NTYPES; j++) {
@@ -2884,13 +2947,13 @@ void dbDumpFldDes(DBBASE *pdbbase,char *recdesName,char *fname)
 	    printf("\t           size: %hd\n",pdbFldDes->size);
 	    printf("\t         offset: %hd\n",pdbFldDes->offset);
 	}
-	if(recdesName) break;
+	if(recordTypeName) break;
     }
 }
 
-void dbDumpDevice(DBBASE *pdbbase,char *recdesName)
+void dbDumpDevice(DBBASE *pdbbase,char *recordTypeName)
 {
-    dbRecDes	*pdbRecDes;
+    dbRecordType	*pdbRecordType;
     devSup	*pdevSup;
     int		gotMatch;
 
@@ -2898,23 +2961,23 @@ void dbDumpDevice(DBBASE *pdbbase,char *recdesName)
 	printf("pdbbase not specified\n");
 	return;
     }
-    for(pdbRecDes = (dbRecDes *)ellFirst(&pdbbase->recDesList);
-    pdbRecDes; pdbRecDes = (dbRecDes *)ellNext(&pdbRecDes->node)) {
-	if(recdesName) {
-	    gotMatch = (strcmp(recdesName,pdbRecDes->name)==0) ? TRUE : FALSE;
+    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",pdbRecDes->name);
-	for(pdevSup = (devSup *)ellFirst(&pdbRecDes->devList);
+	printf("recordtype(%s) \n",pdbRecordType->name);
+	for(pdevSup = (devSup *)ellFirst(&pdbRecordType->devList);
 	pdevSup; pdevSup = (devSup *)ellNext(&pdevSup->node)) {
 	    printf("\t     name: %s\n",pdevSup->name);
 	    printf("\t   choice: %s\n",pdevSup->choice);
 	    printf("\tlink_type: %d\n",pdevSup->link_type);
 	    printf("\t    pdset: %p\n",pdevSup->pdset);
 	}
-	if(recdesName) break;
+	if(recordTypeName) break;
     }
 }
 
@@ -2965,7 +3028,7 @@ void dbReportDeviceConfig(dbBase *pdbbase,FILE *report)
     struct link	*plink;
 
     dbInitEntry(pdbbase,pdbentry);
-    status = dbFirstRecdes(pdbentry);
+    status = dbFirstRecordType(pdbentry);
     while(!status) {
 	status = dbFirstRecord(pdbentry);
 	while(!status) {
@@ -2998,7 +3061,7 @@ void dbReportDeviceConfig(dbBase *pdbbase,FILE *report)
 	    }
 	    status = dbNextRecord(pdbentry);
 	}
-	status = dbNextRecdes(pdbentry);
+	status = dbNextRecordType(pdbentry);
     }
     dbFinishEntry(pdbentry);
     return;
diff --git a/src/dbStatic/dbStaticLib.h b/src/dbStatic/dbStaticLib.h
index 96da95605..29ae635be 100644
--- a/src/dbStatic/dbStaticLib.h
+++ b/src/dbStatic/dbStaticLib.h
@@ -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*/
diff --git a/src/dbStatic/dbStaticNoRun.c b/src/dbStatic/dbStaticNoRun.c
index 79d78983a..58d85772e 100644
--- a/src/dbStatic/dbStaticNoRun.c
+++ b/src/dbStatic/dbStaticNoRun.c
@@ -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;
diff --git a/src/dbStatic/dbStaticPvt.h b/src/dbStatic/dbStaticPvt.h
index 5f5b397b4..3c15cd115 100644
--- a/src/dbStatic/dbStaticPvt.h
+++ b/src/dbStatic/dbStaticPvt.h
@@ -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);
diff --git a/src/dbStatic/dbStaticRun.c b/src/dbStatic/dbStaticRun.c
index 8857177ee..42a465d81 100644
--- a/src/dbStatic/dbStaticRun.c
+++ b/src/dbStatic/dbStaticRun.c
@@ -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);
 }
diff --git a/src/dbStatic/dbToMenuH.c b/src/dbStatic/dbToMenuH.c
index e0d82decd..4d7eb48c4 100644
--- a/src/dbStatic/dbToMenuH.c
+++ b/src/dbStatic/dbToMenuH.c
@@ -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");
diff --git a/src/dbStatic/dbToRecordtypeH.c b/src/dbStatic/dbToRecordtypeH.c
index a90b7eda3..52de14305 100644
--- a/src/dbStatic/dbToRecordtypeH.c
+++ b/src/dbStatic/dbToRecordtypeH.c
@@ -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");
     }
diff --git a/src/dbStatic/dbYacc.y b/src/dbStatic/dbYacc.y
index 0b4cf53db..03003940f 100644
--- a/src/dbStatic/dbYacc.y
+++ b/src/dbStatic/dbYacc.y
@@ -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);