Change all instances of ioccrf' to iocsh' to reflect the added

capabilities of the IOC shell routines.
2001-05-17 18:16:49 +00:00
parent 84cd107ad9
commit d99fb7029d
20 changed files with 520 additions and 520 deletions
--- a/src/iocsh/Makefile
+++ b/src/iocsh/Makefile
@@ -4,7 +4,7 @@ include $(TOP)/configure/CONFIG
 #	includes to install from this sub-project
 #

-INC += ioccrf.h
+INC += iocsh.h
 INC += osiRegister.h
 INC += iocUtilRegister.h
 INC += dbStaticRegister.h
@@ -13,7 +13,7 @@ INC += dbBkptRegister.h
 INC += dbCaTestRegister.h
 INC += caTestRegister.h
 INC += dbAccessRegister.h
-INC += ioccrfRegisterCommon.h
+INC += iocshRegisterCommon.h
 INC += asTestRegister.h
 INC += envRegister.h

@@ -25,7 +25,7 @@ INC += envRegister.h
 #	2) where to find the sources: ., ./os/<ARCH_CLASS>, ./os/generic, ...
 #

-LIBSRCS += ioccrf.cpp
+LIBSRCS += iocsh.cpp
 LIBSRCS += osiRegister.c
 LIBSRCS += dbStaticRegister.c
 LIBSRCS += dbTestRegister.c
@@ -33,7 +33,7 @@ LIBSRCS += dbBkptRegister.c
 LIBSRCS += dbCaTestRegister.c
 LIBSRCS += caTestRegister.c
 LIBSRCS += dbAccessRegister.c
-LIBSRCS += ioccrfRegisterCommon.c
+LIBSRCS += iocshRegisterCommon.c
 LIBSRCS += asTestRegister.c
 LIBSRCS += envRegister.c
 LIBSRCS += iocUtil.c
--- a/src/iocsh/asTestRegister.c
+++ b/src/iocsh/asTestRegister.c
@@ -14,87 +14,87 @@ of this distribution.

 #include "asDbLib.h"
 #define epicsExportSharedSymbols
-#include "ioccrf.h"
+#include "iocsh.h"
 #include "asTestRegister.h"

 /* asSetFilename */
-static const ioccrfArg asSetFilenameArg0 = { "ascf",ioccrfArgString};
-static const ioccrfArg * const asSetFilenameArgs[1] = {&asSetFilenameArg0};
-static const ioccrfFuncDef asSetFilenameFuncDef =
+static const iocshArg asSetFilenameArg0 = { "ascf",iocshArgString};
+static const iocshArg * const asSetFilenameArgs[1] = {&asSetFilenameArg0};
+static const iocshFuncDef asSetFilenameFuncDef =
    {"asSetFilename",1,asSetFilenameArgs};
-static void asSetFilenameCallFunc(const ioccrfArgBuf *args)
+static void asSetFilenameCallFunc(const iocshArgBuf *args)
 {
    asSetFilename(args[0].sval);
 }

 /* asSetSubstitutions */
-static const ioccrfArg asSetSubstitutionsArg0 = { "substitutions",ioccrfArgString};
-static const ioccrfArg * const asSetSubstitutionsArgs[1] = {&asSetSubstitutionsArg0};
-static const ioccrfFuncDef asSetSubstitutionsFuncDef =
+static const iocshArg asSetSubstitutionsArg0 = { "substitutions",iocshArgString};
+static const iocshArg * const asSetSubstitutionsArgs[1] = {&asSetSubstitutionsArg0};
+static const iocshFuncDef asSetSubstitutionsFuncDef =
    {"asSetSubstitutions",1,asSetSubstitutionsArgs};
-static void asSetSubstitutionsCallFunc(const ioccrfArgBuf *args)
+static void asSetSubstitutionsCallFunc(const iocshArgBuf *args)
 {
    asSetSubstitutions(args[0].sval);
 }

 /* asInit */
-static const ioccrfFuncDef asInitFuncDef = {"asInit",0};
-static void asInitCallFunc(const ioccrfArgBuf *args)
+static const iocshFuncDef asInitFuncDef = {"asInit",0};
+static void asInitCallFunc(const iocshArgBuf *args)
 {
    asInit();
 }

 /* asdbdump */
-static const ioccrfFuncDef asdbdumpFuncDef = {"asdbdump",0};
-static void asdbdumpCallFunc(const ioccrfArgBuf *args)
+static const iocshFuncDef asdbdumpFuncDef = {"asdbdump",0};
+static void asdbdumpCallFunc(const iocshArgBuf *args)
 {
    asdbdump();
 }

 /* aspuag */
-static const ioccrfArg aspuagArg0 = { "uagname",ioccrfArgString};
-static const ioccrfArg * const aspuagArgs[1] = {&aspuagArg0};
-static const ioccrfFuncDef aspuagFuncDef = {"aspuag",1,aspuagArgs};
-static void aspuagCallFunc(const ioccrfArgBuf *args)
+static const iocshArg aspuagArg0 = { "uagname",iocshArgString};
+static const iocshArg * const aspuagArgs[1] = {&aspuagArg0};
+static const iocshFuncDef aspuagFuncDef = {"aspuag",1,aspuagArgs};
+static void aspuagCallFunc(const iocshArgBuf *args)
 {
    aspuag(args[0].sval);
 }

 /* asphag */
-static const ioccrfArg asphagArg0 = { "hagname",ioccrfArgString};
-static const ioccrfArg * const asphagArgs[1] = {&asphagArg0};
-static const ioccrfFuncDef asphagFuncDef = {"asphag",1,asphagArgs};
-static void asphagCallFunc(const ioccrfArgBuf *args)
+static const iocshArg asphagArg0 = { "hagname",iocshArgString};
+static const iocshArg * const asphagArgs[1] = {&asphagArg0};
+static const iocshFuncDef asphagFuncDef = {"asphag",1,asphagArgs};
+static void asphagCallFunc(const iocshArgBuf *args)
 {
    asphag(args[0].sval);
 }

 /* asprules */
-static const ioccrfArg asprulesArg0 = { "asgname",ioccrfArgString};
-static const ioccrfArg * const asprulesArgs[1] = {&asprulesArg0};
-static const ioccrfFuncDef asprulesFuncDef = {"asprules",1,asprulesArgs};
-static void asprulesCallFunc(const ioccrfArgBuf *args)
+static const iocshArg asprulesArg0 = { "asgname",iocshArgString};
+static const iocshArg * const asprulesArgs[1] = {&asprulesArg0};
+static const iocshFuncDef asprulesFuncDef = {"asprules",1,asprulesArgs};
+static void asprulesCallFunc(const iocshArgBuf *args)
 {
    asprules(args[0].sval);
 }

 /* aspmem */
-static const ioccrfArg aspmemArg0 = { "asgname",ioccrfArgString};
-static const ioccrfArg aspmemArg1 = { "clients",ioccrfArgInt};
-static const ioccrfArg * const aspmemArgs[2] = {&aspmemArg0,&aspmemArg1};
-static const ioccrfFuncDef aspmemFuncDef = {"aspmem",2,aspmemArgs};
-static void aspmemCallFunc(const ioccrfArgBuf *args)
+static const iocshArg aspmemArg0 = { "asgname",iocshArgString};
+static const iocshArg aspmemArg1 = { "clients",iocshArgInt};
+static const iocshArg * const aspmemArgs[2] = {&aspmemArg0,&aspmemArg1};
+static const iocshFuncDef aspmemFuncDef = {"aspmem",2,aspmemArgs};
+static void aspmemCallFunc(const iocshArgBuf *args)
 {
    aspmem(args[0].sval,args[1].ival);
 }

 /* astac */
-static const ioccrfArg astacArg0 = { "recordname",ioccrfArgString};
-static const ioccrfArg astacArg1 = { "user",ioccrfArgString};
-static const ioccrfArg astacArg2 = { "location",ioccrfArgString};
-static const ioccrfArg * const astacArgs[3] = {&astacArg0,&astacArg1,&astacArg2};
-static const ioccrfFuncDef astacFuncDef = {"astac",3,astacArgs};
-static void astacCallFunc(const ioccrfArgBuf *args)
+static const iocshArg astacArg0 = { "recordname",iocshArgString};
+static const iocshArg astacArg1 = { "user",iocshArgString};
+static const iocshArg astacArg2 = { "location",iocshArgString};
+static const iocshArg * const astacArgs[3] = {&astacArg0,&astacArg1,&astacArg2};
+static const iocshFuncDef astacFuncDef = {"astac",3,astacArgs};
+static void astacCallFunc(const iocshArgBuf *args)
 {
    astac(args[0].sval,args[1].sval,args[2].sval);
 }
@@ -102,13 +102,13 @@ static void astacCallFunc(const ioccrfArgBuf *args)

 void epicsShareAPI asTestRegister(void)
 {
-    ioccrfRegister(&asSetFilenameFuncDef,asSetFilenameCallFunc);
-    ioccrfRegister(&asSetSubstitutionsFuncDef,asSetSubstitutionsCallFunc);
-    ioccrfRegister(&asInitFuncDef,asInitCallFunc);
-    ioccrfRegister(&asdbdumpFuncDef,asdbdumpCallFunc);
-    ioccrfRegister(&aspuagFuncDef,aspuagCallFunc);
-    ioccrfRegister(&asphagFuncDef,asphagCallFunc);
-    ioccrfRegister(&asprulesFuncDef,asprulesCallFunc);
-    ioccrfRegister(&aspmemFuncDef,aspmemCallFunc);
-    ioccrfRegister(&astacFuncDef,astacCallFunc);
+    iocshRegister(&asSetFilenameFuncDef,asSetFilenameCallFunc);
+    iocshRegister(&asSetSubstitutionsFuncDef,asSetSubstitutionsCallFunc);
+    iocshRegister(&asInitFuncDef,asInitCallFunc);
+    iocshRegister(&asdbdumpFuncDef,asdbdumpCallFunc);
+    iocshRegister(&aspuagFuncDef,aspuagCallFunc);
+    iocshRegister(&asphagFuncDef,asphagCallFunc);
+    iocshRegister(&asprulesFuncDef,asprulesCallFunc);
+    iocshRegister(&aspmemFuncDef,aspmemCallFunc);
+    iocshRegister(&astacFuncDef,astacCallFunc);
 }
--- a/src/iocsh/caTestRegister.c
+++ b/src/iocsh/caTestRegister.c
@@ -15,24 +15,24 @@ of this distribution.
 #include "rsrv.h"
 #include "dbEvent.h"
 #define epicsExportSharedSymbols
-#include "ioccrf.h"
+#include "iocsh.h"
 #include "caTestRegister.h"

 /* casr */
-static const ioccrfArg casrArg0 = { "level",ioccrfArgInt};
-static const ioccrfArg * const casrArgs[1] = {&casrArg0};
-static const ioccrfFuncDef casrFuncDef = {"casr",1,casrArgs};
-static void casrCallFunc(const ioccrfArgBuf *args)
+static const iocshArg casrArg0 = { "level",iocshArgInt};
+static const iocshArg * const casrArgs[1] = {&casrArg0};
+static const iocshFuncDef casrFuncDef = {"casr",1,casrArgs};
+static void casrCallFunc(const iocshArgBuf *args)
 {
    casr(args[0].ival);
 }

 /* dbel */
-static const ioccrfArg dbelArg0 = { "record name",ioccrfArgString};
-static const ioccrfArg dbelArg1 = { "level",ioccrfArgInt};
-static const ioccrfArg * const dbelArgs[2] = {&dbelArg0,&dbelArg1};
-static const ioccrfFuncDef dbelFuncDef = {"dbel",2,dbelArgs};
-static void dbelCallFunc(const ioccrfArgBuf *args)
+static const iocshArg dbelArg0 = { "record name",iocshArgString};
+static const iocshArg dbelArg1 = { "level",iocshArgInt};
+static const iocshArg * const dbelArgs[2] = {&dbelArg0,&dbelArg1};
+static const iocshFuncDef dbelFuncDef = {"dbel",2,dbelArgs};
+static void dbelCallFunc(const iocshArgBuf *args)
 {
    dbel(args[0].sval, args[1].ival);
 }
@@ -40,6 +40,6 @@ static void dbelCallFunc(const ioccrfArgBuf *args)

 void epicsShareAPI caTestRegister(void)
 {
-    ioccrfRegister(&casrFuncDef,casrCallFunc);
-    ioccrfRegister(&dbelFuncDef,dbelCallFunc);
+    iocshRegister(&casrFuncDef,casrCallFunc);
+    iocshRegister(&dbelFuncDef,dbelCallFunc);
 }
--- a/src/iocsh/dbAccessRegister.c
+++ b/src/iocsh/dbAccessRegister.c
@@ -16,58 +16,58 @@ of this distribution.
 #include "iocInit.h"
 #include "dbLoadTemplate.h"
 #define epicsExportSharedSymbols
-#include "ioccrf.h"
+#include "iocsh.h"
 #include "registryRecordType.h"
 #include "dbAccessRegister.h"
-#include "ioccrf.h"
+#include "iocsh.h"

 /* dbLoadDatabase */
-static const ioccrfArg dbLoadDatabaseArg0 = { "file name",ioccrfArgString};
-static const ioccrfArg dbLoadDatabaseArg1 = { "path",ioccrfArgString};
-static const ioccrfArg dbLoadDatabaseArg2 = { "substitutions",ioccrfArgString};
-static const ioccrfArg * const dbLoadDatabaseArgs[3] =
+static const iocshArg dbLoadDatabaseArg0 = { "file name",iocshArgString};
+static const iocshArg dbLoadDatabaseArg1 = { "path",iocshArgString};
+static const iocshArg dbLoadDatabaseArg2 = { "substitutions",iocshArgString};
+static const iocshArg * const dbLoadDatabaseArgs[3] =
 {
    &dbLoadDatabaseArg0,&dbLoadDatabaseArg1,&dbLoadDatabaseArg2
 };
-static const ioccrfFuncDef dbLoadDatabaseFuncDef =
+static const iocshFuncDef dbLoadDatabaseFuncDef =
    {"dbLoadDatabase",3,dbLoadDatabaseArgs};
-static void dbLoadDatabaseCallFunc(const ioccrfArgBuf *args)
+static void dbLoadDatabaseCallFunc(const iocshArgBuf *args)
 {
    dbLoadDatabase(args[0].sval,args[1].sval,args[2].sval);
 }

 /* dbLoadRecords */
-static const ioccrfArg dbLoadRecordsArg0 = { "file name",ioccrfArgString};
-static const ioccrfArg dbLoadRecordsArg1 = { "substitutions",ioccrfArgString};
-static const ioccrfArg * const dbLoadRecordsArgs[2] = {&dbLoadRecordsArg0,&dbLoadRecordsArg1};
-static const ioccrfFuncDef dbLoadRecordsFuncDef = {"dbLoadRecords",2,dbLoadRecordsArgs};
-static void dbLoadRecordsCallFunc(const ioccrfArgBuf *args)
+static const iocshArg dbLoadRecordsArg0 = { "file name",iocshArgString};
+static const iocshArg dbLoadRecordsArg1 = { "substitutions",iocshArgString};
+static const iocshArg * const dbLoadRecordsArgs[2] = {&dbLoadRecordsArg0,&dbLoadRecordsArg1};
+static const iocshFuncDef dbLoadRecordsFuncDef = {"dbLoadRecords",2,dbLoadRecordsArgs};
+static void dbLoadRecordsCallFunc(const iocshArgBuf *args)
 {
    dbLoadRecords(args[0].sval,args[1].sval);
 }

 /* dbLoadTemplate */
-static const ioccrfArg dbLoadTemplateArg0 = { "file name",ioccrfArgString};
-static const ioccrfArg * const dbLoadTemplateArgs[1] = {&dbLoadTemplateArg0};
-static const ioccrfFuncDef dbLoadTemplateFuncDef =
+static const iocshArg dbLoadTemplateArg0 = { "file name",iocshArgString};
+static const iocshArg * const dbLoadTemplateArgs[1] = {&dbLoadTemplateArg0};
+static const iocshFuncDef dbLoadTemplateFuncDef =
    {"dbLoadTemplate",1,dbLoadTemplateArgs};
-static void dbLoadTemplateCallFunc(const ioccrfArgBuf *args)
+static void dbLoadTemplateCallFunc(const iocshArgBuf *args)
 {
    dbLoadTemplate(args[0].sval);
 }

 /* iocInit */
-static const ioccrfFuncDef iocInitFuncDef =
+static const iocshFuncDef iocInitFuncDef =
    {"iocInit",0,0};
-static void iocInitCallFunc(const ioccrfArgBuf *args)
+static void iocInitCallFunc(const iocshArgBuf *args)
 {
    iocInit();
 }

 void epicsShareAPI dbAccessRegister(void)
 {
-    ioccrfRegister(&dbLoadDatabaseFuncDef,dbLoadDatabaseCallFunc);
-    ioccrfRegister(&dbLoadRecordsFuncDef,dbLoadRecordsCallFunc);
-    ioccrfRegister(&dbLoadTemplateFuncDef,dbLoadTemplateCallFunc);
-    ioccrfRegister(&iocInitFuncDef,iocInitCallFunc);
+    iocshRegister(&dbLoadDatabaseFuncDef,dbLoadDatabaseCallFunc);
+    iocshRegister(&dbLoadRecordsFuncDef,dbLoadRecordsCallFunc);
+    iocshRegister(&dbLoadTemplateFuncDef,dbLoadTemplateCallFunc);
+    iocshRegister(&iocInitFuncDef,iocInitCallFunc);
 }
--- a/src/iocsh/dbBkptRegister.c
+++ b/src/iocsh/dbBkptRegister.c
@@ -21,57 +21,57 @@ of this distribution.
 #include "dbCommon.h"
 #include "dbBkpt.h"
 #define epicsExportSharedSymbols
-#include "ioccrf.h"
+#include "iocsh.h"
 #include "dbBkptRegister.h"

 /* dbb */
-static const ioccrfArg dbbArg0 = { "record name",ioccrfArgString};
-static const ioccrfArg * const dbbArgs[1] = {&dbbArg0};
-static const ioccrfFuncDef dbbFuncDef = {"dbb",1,dbbArgs};
-static void dbbCallFunc(const ioccrfArgBuf *args) { dbb(args[0].sval);}
+static const iocshArg dbbArg0 = { "record name",iocshArgString};
+static const iocshArg * const dbbArgs[1] = {&dbbArg0};
+static const iocshFuncDef dbbFuncDef = {"dbb",1,dbbArgs};
+static void dbbCallFunc(const iocshArgBuf *args) { dbb(args[0].sval);}

 /* dbd */
-static const ioccrfArg dbdArg0 = { "record name",ioccrfArgString};
-static const ioccrfArg * const dbdArgs[1] = {&dbdArg0};
-static const ioccrfFuncDef dbdFuncDef = {"dbd",1,dbdArgs};
-static void dbdCallFunc(const ioccrfArgBuf *args) { dbd(args[0].sval);}
+static const iocshArg dbdArg0 = { "record name",iocshArgString};
+static const iocshArg * const dbdArgs[1] = {&dbdArg0};
+static const iocshFuncDef dbdFuncDef = {"dbd",1,dbdArgs};
+static void dbdCallFunc(const iocshArgBuf *args) { dbd(args[0].sval);}

 /* dbc */
-static const ioccrfArg dbcArg0 = { "record name",ioccrfArgString};
-static const ioccrfArg * const dbcArgs[1] = {&dbcArg0};
-static const ioccrfFuncDef dbcFuncDef = {"dbc",1,dbcArgs};
-static void dbcCallFunc(const ioccrfArgBuf *args) { dbc(args[0].sval);}
+static const iocshArg dbcArg0 = { "record name",iocshArgString};
+static const iocshArg * const dbcArgs[1] = {&dbcArg0};
+static const iocshFuncDef dbcFuncDef = {"dbc",1,dbcArgs};
+static void dbcCallFunc(const iocshArgBuf *args) { dbc(args[0].sval);}

 /* dbs */
-static const ioccrfArg dbsArg0 = { "record name",ioccrfArgString};
-static const ioccrfArg * const dbsArgs[1] = {&dbsArg0};
-static const ioccrfFuncDef dbsFuncDef = {"dbs",1,dbsArgs};
-static void dbsCallFunc(const ioccrfArgBuf *args) { dbs(args[0].sval);}
+static const iocshArg dbsArg0 = { "record name",iocshArgString};
+static const iocshArg * const dbsArgs[1] = {&dbsArg0};
+static const iocshFuncDef dbsFuncDef = {"dbs",1,dbsArgs};
+static void dbsCallFunc(const iocshArgBuf *args) { dbs(args[0].sval);}

-static const ioccrfFuncDef dbstatFuncDef = {"dbstat",0};
-static void dbstatCallFunc(const ioccrfArgBuf *args) { dbstat();}
+static const iocshFuncDef dbstatFuncDef = {"dbstat",0};
+static void dbstatCallFunc(const iocshArgBuf *args) { dbstat();}

 /* dbp */
-static const ioccrfArg dbpArg0 = { "record name",ioccrfArgString};
-static const ioccrfArg dbpArg1 = { "interest level",ioccrfArgInt};
-static const ioccrfArg * const dbpArgs[2] = {&dbpArg0,&dbpArg1};
-static const ioccrfFuncDef dbpFuncDef = {"dbp",2,dbpArgs};
-static void dbpCallFunc(const ioccrfArgBuf *args)
+static const iocshArg dbpArg0 = { "record name",iocshArgString};
+static const iocshArg dbpArg1 = { "interest level",iocshArgInt};
+static const iocshArg * const dbpArgs[2] = {&dbpArg0,&dbpArg1};
+static const iocshFuncDef dbpFuncDef = {"dbp",2,dbpArgs};
+static void dbpCallFunc(const iocshArgBuf *args)
 { dbp(args[0].sval,args[1].ival);}

 /* dbap */
-static const ioccrfArg dbapArg0 = { "record name",ioccrfArgString};
-static const ioccrfArg * const dbapArgs[1] = {&dbapArg0};
-static const ioccrfFuncDef dbapFuncDef = {"dbap",1,dbapArgs};
-static void dbapCallFunc(const ioccrfArgBuf *args) { dbap(args[0].sval);}
+static const iocshArg dbapArg0 = { "record name",iocshArgString};
+static const iocshArg * const dbapArgs[1] = {&dbapArg0};
+static const iocshFuncDef dbapFuncDef = {"dbap",1,dbapArgs};
+static void dbapCallFunc(const iocshArgBuf *args) { dbap(args[0].sval);}

 void epicsShareAPI dbBkptRegister(void)
 {
-    ioccrfRegister(&dbbFuncDef,dbbCallFunc);
-    ioccrfRegister(&dbdFuncDef,dbdCallFunc);
-    ioccrfRegister(&dbcFuncDef,dbcCallFunc);
-    ioccrfRegister(&dbsFuncDef,dbsCallFunc);
-    ioccrfRegister(&dbstatFuncDef,dbstatCallFunc);
-    ioccrfRegister(&dbpFuncDef,dbpCallFunc);
-    ioccrfRegister(&dbapFuncDef,dbapCallFunc);
+    iocshRegister(&dbbFuncDef,dbbCallFunc);
+    iocshRegister(&dbdFuncDef,dbdCallFunc);
+    iocshRegister(&dbcFuncDef,dbcCallFunc);
+    iocshRegister(&dbsFuncDef,dbsCallFunc);
+    iocshRegister(&dbstatFuncDef,dbstatCallFunc);
+    iocshRegister(&dbpFuncDef,dbpCallFunc);
+    iocshRegister(&dbapFuncDef,dbapCallFunc);
 }
--- a/src/iocsh/dbCaTestRegister.c
+++ b/src/iocsh/dbCaTestRegister.c
@@ -14,15 +14,15 @@ of this distribution.

 #include "dbCaTest.h"
 #define epicsExportSharedSymbols
-#include "ioccrf.h"
+#include "iocsh.h"
 #include "dbCaTestRegister.h"

 /* dbcar */
-static const ioccrfArg dbcarArg0 = { "record name",ioccrfArgString};
-static const ioccrfArg dbcarArg1 = { "level",ioccrfArgInt};
-static const ioccrfArg * const dbcarArgs[2] = {&dbcarArg0,&dbcarArg1};
-static const ioccrfFuncDef dbcarFuncDef = {"dbcar",2,dbcarArgs};
-static void dbcarCallFunc(const ioccrfArgBuf *args)
+static const iocshArg dbcarArg0 = { "record name",iocshArgString};
+static const iocshArg dbcarArg1 = { "level",iocshArgInt};
+static const iocshArg * const dbcarArgs[2] = {&dbcarArg0,&dbcarArg1};
+static const iocshFuncDef dbcarFuncDef = {"dbcar",2,dbcarArgs};
+static void dbcarCallFunc(const iocshArgBuf *args)
 {
    dbcar(args[0].sval,args[1].ival);
 }
@@ -30,5 +30,5 @@ static void dbcarCallFunc(const ioccrfArgBuf *args)

 void epicsShareAPI dbCaTestRegister(void)
 {
-    ioccrfRegister(&dbcarFuncDef,dbcarCallFunc);
+    iocshRegister(&dbcarFuncDef,dbcarCallFunc);
 }
--- a/src/iocsh/dbStaticRegister.c
+++ b/src/iocsh/dbStaticRegister.c
@@ -16,125 +16,125 @@ of this distribution.
 #include "dbStaticLib.h"
 #define epicsExportSharedSymbols
 #include "registryRecordType.h"
-#include "ioccrf.h"
+#include "iocsh.h"
 #include "dbStaticRegister.h"

 /* dbDumpRecDes */
-static const ioccrfArg dbDumpRecDesArg0 = { "pdbbase",ioccrfArgPdbbase};
-static const ioccrfArg dbDumpRecDesArg1 = { "recordTypeName",ioccrfArgString};
-static const ioccrfArg * const dbDumpRecDesArgs[2] = {&dbDumpRecDesArg0,&dbDumpRecDesArg1};
-static const ioccrfFuncDef dbDumpRecDesFuncDef = {"dbDumpRecDes",2,dbDumpRecDesArgs};
-static void dbDumpRecDesCallFunc(const ioccrfArgBuf *args)
+static const iocshArg dbDumpRecDesArg0 = { "pdbbase",iocshArgPdbbase};
+static const iocshArg dbDumpRecDesArg1 = { "recordTypeName",iocshArgString};
+static const iocshArg * const dbDumpRecDesArgs[2] = {&dbDumpRecDesArg0,&dbDumpRecDesArg1};
+static const iocshFuncDef dbDumpRecDesFuncDef = {"dbDumpRecDes",2,dbDumpRecDesArgs};
+static void dbDumpRecDesCallFunc(const iocshArgBuf *args)
 {
    dbDumpRecDes(pdbbase,args[1].sval);
 }

 /* dbDumpPath */
-static const ioccrfArg dbDumpPathArg0 = { "pdbbase",ioccrfArgPdbbase};
-static const ioccrfArg * const dbDumpPathArgs[1] = {&dbDumpPathArg0};
-static const ioccrfFuncDef dbDumpPathFuncDef = {"dbDumpPath",1,dbDumpPathArgs};
-static void dbDumpPathCallFunc(const ioccrfArgBuf *args)
+static const iocshArg dbDumpPathArg0 = { "pdbbase",iocshArgPdbbase};
+static const iocshArg * const dbDumpPathArgs[1] = {&dbDumpPathArg0};
+static const iocshFuncDef dbDumpPathFuncDef = {"dbDumpPath",1,dbDumpPathArgs};
+static void dbDumpPathCallFunc(const iocshArgBuf *args)
 {
    dbDumpPath(pdbbase);
 }

 /* dbDumpRecord */
-static const ioccrfArg dbDumpRecordArg0 = { "pdbbase",ioccrfArgPdbbase};
-static const ioccrfArg dbDumpRecordArg1 = { "recordTypeName",ioccrfArgString};
-static const ioccrfArg dbDumpRecordArg2 = { "interest level",ioccrfArgInt};
-static const ioccrfArg * const dbDumpRecordArgs[3] =
+static const iocshArg dbDumpRecordArg0 = { "pdbbase",iocshArgPdbbase};
+static const iocshArg dbDumpRecordArg1 = { "recordTypeName",iocshArgString};
+static const iocshArg dbDumpRecordArg2 = { "interest level",iocshArgInt};
+static const iocshArg * const dbDumpRecordArgs[3] =
    {&dbDumpRecordArg0,&dbDumpRecordArg1,&dbDumpRecordArg2};
-static const ioccrfFuncDef dbDumpRecordFuncDef = {"dbDumpRecord",3,dbDumpRecordArgs};
-static void dbDumpRecordCallFunc(const ioccrfArgBuf *args)
+static const iocshFuncDef dbDumpRecordFuncDef = {"dbDumpRecord",3,dbDumpRecordArgs};
+static void dbDumpRecordCallFunc(const iocshArgBuf *args)
 {
    dbDumpRecord(pdbbase,args[1].sval,args[2].ival);
 }

 /* dbDumpMenu */
-static const ioccrfArg dbDumpMenuArg0 = { "pdbbase",ioccrfArgPdbbase};
-static const ioccrfArg dbDumpMenuArg1 = { "menuName",ioccrfArgString};
-static const ioccrfArg * const dbDumpMenuArgs[2] = {&dbDumpMenuArg0,&dbDumpMenuArg1};
-static const ioccrfFuncDef dbDumpMenuFuncDef = {"dbDumpMenu",2,dbDumpMenuArgs};
-static void dbDumpMenuCallFunc(const ioccrfArgBuf *args)
+static const iocshArg dbDumpMenuArg0 = { "pdbbase",iocshArgPdbbase};
+static const iocshArg dbDumpMenuArg1 = { "menuName",iocshArgString};
+static const iocshArg * const dbDumpMenuArgs[2] = {&dbDumpMenuArg0,&dbDumpMenuArg1};
+static const iocshFuncDef dbDumpMenuFuncDef = {"dbDumpMenu",2,dbDumpMenuArgs};
+static void dbDumpMenuCallFunc(const iocshArgBuf *args)
 {
    dbDumpMenu(pdbbase,args[1].sval);
 }

 /* dbDumpRecordType */
-static const ioccrfArg dbDumpRecordTypeArg0 = { "pdbbase",ioccrfArgPdbbase};
-static const ioccrfArg dbDumpRecordTypeArg1 = { "recordTypeName",ioccrfArgString};
-static const ioccrfArg * const dbDumpRecordTypeArgs[2] =
+static const iocshArg dbDumpRecordTypeArg0 = { "pdbbase",iocshArgPdbbase};
+static const iocshArg dbDumpRecordTypeArg1 = { "recordTypeName",iocshArgString};
+static const iocshArg * const dbDumpRecordTypeArgs[2] =
    {&dbDumpRecordTypeArg0,&dbDumpRecordTypeArg1};
-static const ioccrfFuncDef dbDumpRecordTypeFuncDef =
+static const iocshFuncDef dbDumpRecordTypeFuncDef =
    {"dbDumpRecordType",2,dbDumpRecordTypeArgs};
-static void dbDumpRecordTypeCallFunc(const ioccrfArgBuf *args)
+static void dbDumpRecordTypeCallFunc(const iocshArgBuf *args)
 {
    dbDumpRecordType(pdbbase,args[1].sval);
 }

 /* dbDumpFldDes */
-static const ioccrfArg dbDumpFldDesArg0 = { "pdbbase",ioccrfArgPdbbase};
-static const ioccrfArg dbDumpFldDesArg1 = { "recordTypeName",ioccrfArgString};
-static const ioccrfArg dbDumpFldDesArg2 = { "fieldName",ioccrfArgString};
-static const ioccrfArg * const dbDumpFldDesArgs[3] =
+static const iocshArg dbDumpFldDesArg0 = { "pdbbase",iocshArgPdbbase};
+static const iocshArg dbDumpFldDesArg1 = { "recordTypeName",iocshArgString};
+static const iocshArg dbDumpFldDesArg2 = { "fieldName",iocshArgString};
+static const iocshArg * const dbDumpFldDesArgs[3] =
    {&dbDumpFldDesArg0,&dbDumpFldDesArg1,&dbDumpFldDesArg2};
-static const ioccrfFuncDef dbDumpFldDesFuncDef = {"dbDumpFldDes",3,dbDumpFldDesArgs};
-static void dbDumpFldDesCallFunc(const ioccrfArgBuf *args)
+static const iocshFuncDef dbDumpFldDesFuncDef = {"dbDumpFldDes",3,dbDumpFldDesArgs};
+static void dbDumpFldDesCallFunc(const iocshArgBuf *args)
 {
    dbDumpFldDes(pdbbase,args[1].sval,args[2].sval);
 }

 /* dbDumpDevice */
-static const ioccrfArg dbDumpDeviceArg0 = { "pdbbase",ioccrfArgPdbbase};
-static const ioccrfArg dbDumpDeviceArg1 = { "recordTypeName",ioccrfArgString};
-static const ioccrfArg * const dbDumpDeviceArgs[2] = {&dbDumpDeviceArg0,&dbDumpDeviceArg1};
-static const ioccrfFuncDef dbDumpDeviceFuncDef = {"dbDumpDevice",2,dbDumpDeviceArgs};
-static void dbDumpDeviceCallFunc(const ioccrfArgBuf *args)
+static const iocshArg dbDumpDeviceArg0 = { "pdbbase",iocshArgPdbbase};
+static const iocshArg dbDumpDeviceArg1 = { "recordTypeName",iocshArgString};
+static const iocshArg * const dbDumpDeviceArgs[2] = {&dbDumpDeviceArg0,&dbDumpDeviceArg1};
+static const iocshFuncDef dbDumpDeviceFuncDef = {"dbDumpDevice",2,dbDumpDeviceArgs};
+static void dbDumpDeviceCallFunc(const iocshArgBuf *args)
 {
    dbDumpDevice(pdbbase,args[1].sval);
 }

 /* dbDumpDriver */
-static const ioccrfArg dbDumpDriverArg0 = { "pdbbase",ioccrfArgPdbbase};
-static const ioccrfArg * const dbDumpDriverArgs[1] = {&dbDumpDriverArg0};
-static const ioccrfFuncDef dbDumpDriverFuncDef = {"dbDumpDriver",1,dbDumpDriverArgs};
-static void dbDumpDriverCallFunc(const ioccrfArgBuf *args)
+static const iocshArg dbDumpDriverArg0 = { "pdbbase",iocshArgPdbbase};
+static const iocshArg * const dbDumpDriverArgs[1] = {&dbDumpDriverArg0};
+static const iocshFuncDef dbDumpDriverFuncDef = {"dbDumpDriver",1,dbDumpDriverArgs};
+static void dbDumpDriverCallFunc(const iocshArgBuf *args)
 {
    dbDumpDriver(pdbbase);
 }

 /* dbDumpBreaktable */
-static const ioccrfArg dbDumpBreaktableArg0 = { "pdbbase",ioccrfArgPdbbase};
-static const ioccrfArg dbDumpBreaktableArg1 = { "tableName",ioccrfArgString};
-static const ioccrfArg * const dbDumpBreaktableArgs[2] =
+static const iocshArg dbDumpBreaktableArg0 = { "pdbbase",iocshArgPdbbase};
+static const iocshArg dbDumpBreaktableArg1 = { "tableName",iocshArgString};
+static const iocshArg * const dbDumpBreaktableArgs[2] =
    {&dbDumpBreaktableArg0,&dbDumpBreaktableArg1};
-static const ioccrfFuncDef dbDumpBreaktableFuncDef =
+static const iocshFuncDef dbDumpBreaktableFuncDef =
    {"dbDumpBreaktable",2,dbDumpBreaktableArgs};
-static void dbDumpBreaktableCallFunc(const ioccrfArgBuf *args)
+static void dbDumpBreaktableCallFunc(const iocshArgBuf *args)
 {
    dbDumpBreaktable(pdbbase,args[1].sval);
 }

 /* dbPvdDump */
-static const ioccrfArg dbPvdDumpArg0 = { "pdbbase",ioccrfArgPdbbase};
-static const ioccrfArg dbPvdDumpArg1 = { "verbose",ioccrfArgInt};
-static const ioccrfArg * const dbPvdDumpArgs[2] = {&dbPvdDumpArg0,&dbPvdDumpArg1};
-static const ioccrfFuncDef dbPvdDumpFuncDef = {"dbPvdDump",2,dbPvdDumpArgs};
-static void dbPvdDumpCallFunc(const ioccrfArgBuf *args)
+static const iocshArg dbPvdDumpArg0 = { "pdbbase",iocshArgPdbbase};
+static const iocshArg dbPvdDumpArg1 = { "verbose",iocshArgInt};
+static const iocshArg * const dbPvdDumpArgs[2] = {&dbPvdDumpArg0,&dbPvdDumpArg1};
+static const iocshFuncDef dbPvdDumpFuncDef = {"dbPvdDump",2,dbPvdDumpArgs};
+static void dbPvdDumpCallFunc(const iocshArgBuf *args)
 {
    dbPvdDump(pdbbase,args[1].ival);
 }

 void epicsShareAPI dbStaticRegister(void)
 {
-    ioccrfRegister(&dbDumpRecDesFuncDef,dbDumpRecDesCallFunc);
-    ioccrfRegister(&dbDumpPathFuncDef,dbDumpPathCallFunc);
-    ioccrfRegister(&dbDumpRecordFuncDef,dbDumpRecordCallFunc);
-    ioccrfRegister(&dbDumpMenuFuncDef,dbDumpMenuCallFunc);
-    ioccrfRegister(&dbDumpRecordTypeFuncDef,dbDumpRecordTypeCallFunc);
-    ioccrfRegister(&dbDumpFldDesFuncDef,dbDumpFldDesCallFunc);
-    ioccrfRegister(&dbDumpDeviceFuncDef,dbDumpDeviceCallFunc);
-    ioccrfRegister(&dbDumpDriverFuncDef,dbDumpDriverCallFunc);
-    ioccrfRegister(&dbDumpBreaktableFuncDef,dbDumpBreaktableCallFunc);
-    ioccrfRegister(&dbPvdDumpFuncDef,dbPvdDumpCallFunc);
+    iocshRegister(&dbDumpRecDesFuncDef,dbDumpRecDesCallFunc);
+    iocshRegister(&dbDumpPathFuncDef,dbDumpPathCallFunc);
+    iocshRegister(&dbDumpRecordFuncDef,dbDumpRecordCallFunc);
+    iocshRegister(&dbDumpMenuFuncDef,dbDumpMenuCallFunc);
+    iocshRegister(&dbDumpRecordTypeFuncDef,dbDumpRecordTypeCallFunc);
+    iocshRegister(&dbDumpFldDesFuncDef,dbDumpFldDesCallFunc);
+    iocshRegister(&dbDumpDeviceFuncDef,dbDumpDeviceCallFunc);
+    iocshRegister(&dbDumpDriverFuncDef,dbDumpDriverCallFunc);
+    iocshRegister(&dbDumpBreaktableFuncDef,dbDumpBreaktableCallFunc);
+    iocshRegister(&dbPvdDumpFuncDef,dbPvdDumpCallFunc);
 }
--- a/src/iocsh/dbTestRegister.c
+++ b/src/iocsh/dbTestRegister.c
@@ -19,170 +19,170 @@ of this distribution.
 #include "ellLib.h"
 #include "dbNotify.h"
 #define epicsExportSharedSymbols
-#include "ioccrf.h"
+#include "iocsh.h"
 #include "dbTestRegister.h"

 /* dba */
-static const ioccrfArg dbaArg0 = { "record name",ioccrfArgString};
-static const ioccrfArg * const dbaArgs[1] = {&dbaArg0};
-static const ioccrfFuncDef dbaFuncDef = {"dba",1,dbaArgs};
-static void dbaCallFunc(const ioccrfArgBuf *args) { dba(args[0].sval);}
+static const iocshArg dbaArg0 = { "record name",iocshArgString};
+static const iocshArg * const dbaArgs[1] = {&dbaArg0};
+static const iocshFuncDef dbaFuncDef = {"dba",1,dbaArgs};
+static void dbaCallFunc(const iocshArgBuf *args) { dba(args[0].sval);}

 /* dbl */
-static const ioccrfArg dblArg0 = { "record type",ioccrfArgString};
-static const ioccrfArg dblArg1 = { "output file",ioccrfArgString};
-static const ioccrfArg dblArg2 = { "fields",ioccrfArgString};
-static const ioccrfArg * const dblArgs[3] = {&dblArg0,&dblArg1,&dblArg2};
-static const ioccrfFuncDef dblFuncDef = {"dbl",3,dblArgs};
-static void dblCallFunc(const ioccrfArgBuf *args)
+static const iocshArg dblArg0 = { "record type",iocshArgString};
+static const iocshArg dblArg1 = { "output file",iocshArgString};
+static const iocshArg dblArg2 = { "fields",iocshArgString};
+static const iocshArg * const dblArgs[3] = {&dblArg0,&dblArg1,&dblArg2};
+static const iocshFuncDef dblFuncDef = {"dbl",3,dblArgs};
+static void dblCallFunc(const iocshArgBuf *args)
 {
    dbl(args[0].sval,args[1].sval,args[2].sval);
 }

 /* dbnr */
-static const ioccrfArg dbnrArg0 = { "verbose",ioccrfArgInt};
-static const ioccrfArg * const dbnrArgs[1] = {&dbnrArg0};
-static const ioccrfFuncDef dbnrFuncDef = {"dbnr",1,dbnrArgs};
-static void dbnrCallFunc(const ioccrfArgBuf *args) { dbnr(args[0].ival);}
+static const iocshArg dbnrArg0 = { "verbose",iocshArgInt};
+static const iocshArg * const dbnrArgs[1] = {&dbnrArg0};
+static const iocshFuncDef dbnrFuncDef = {"dbnr",1,dbnrArgs};
+static void dbnrCallFunc(const iocshArgBuf *args) { dbnr(args[0].ival);}

 /* dbgrep */
-static const ioccrfArg dbgrepArg0 = { "record name",ioccrfArgString};
-static const ioccrfArg * const dbgrepArgs[1] = {&dbgrepArg0};
-static const ioccrfFuncDef dbgrepFuncDef = {"dbgrep",1,dbgrepArgs};
-static void dbgrepCallFunc(const ioccrfArgBuf *args) { dbgrep(args[0].sval);}
+static const iocshArg dbgrepArg0 = { "record name",iocshArgString};
+static const iocshArg * const dbgrepArgs[1] = {&dbgrepArg0};
+static const iocshFuncDef dbgrepFuncDef = {"dbgrep",1,dbgrepArgs};
+static void dbgrepCallFunc(const iocshArgBuf *args) { dbgrep(args[0].sval);}

 /* dbgf */
-static const ioccrfArg dbgfArg0 = { "record name",ioccrfArgString};
-static const ioccrfArg * const dbgfArgs[1] = {&dbgfArg0};
-static const ioccrfFuncDef dbgfFuncDef = {"dbgf",1,dbgfArgs};
-static void dbgfCallFunc(const ioccrfArgBuf *args) { dbgf(args[0].sval);}
+static const iocshArg dbgfArg0 = { "record name",iocshArgString};
+static const iocshArg * const dbgfArgs[1] = {&dbgfArg0};
+static const iocshFuncDef dbgfFuncDef = {"dbgf",1,dbgfArgs};
+static void dbgfCallFunc(const iocshArgBuf *args) { dbgf(args[0].sval);}

 /* dbpf */
-static const ioccrfArg dbpfArg0 = { "record name",ioccrfArgString};
-static const ioccrfArg dbpfArg1 = { "value",ioccrfArgString};
-static const ioccrfArg * const dbpfArgs[2] = {&dbpfArg0,&dbpfArg1};
-static const ioccrfFuncDef dbpfFuncDef = {"dbpf",2,dbpfArgs};
-static void dbpfCallFunc(const ioccrfArgBuf *args)
+static const iocshArg dbpfArg0 = { "record name",iocshArgString};
+static const iocshArg dbpfArg1 = { "value",iocshArgString};
+static const iocshArg * const dbpfArgs[2] = {&dbpfArg0,&dbpfArg1};
+static const iocshFuncDef dbpfFuncDef = {"dbpf",2,dbpfArgs};
+static void dbpfCallFunc(const iocshArgBuf *args)
 { dbpf(args[0].sval,args[1].sval);}

 /* dbpr */
-static const ioccrfArg dbprArg0 = { "record name",ioccrfArgString};
-static const ioccrfArg dbprArg1 = { "interest level",ioccrfArgInt};
-static const ioccrfArg * const dbprArgs[2] = {&dbprArg0,&dbprArg1};
-static const ioccrfFuncDef dbprFuncDef = {"dbpr",2,dbprArgs};
-static void dbprCallFunc(const ioccrfArgBuf *args)
+static const iocshArg dbprArg0 = { "record name",iocshArgString};
+static const iocshArg dbprArg1 = { "interest level",iocshArgInt};
+static const iocshArg * const dbprArgs[2] = {&dbprArg0,&dbprArg1};
+static const iocshFuncDef dbprFuncDef = {"dbpr",2,dbprArgs};
+static void dbprCallFunc(const iocshArgBuf *args)
 { dbpr(args[0].sval,args[1].ival);}

 /* dbtr */
-static const ioccrfArg dbtrArg0 = { "record name",ioccrfArgString};
-static const ioccrfArg * const dbtrArgs[1] = {&dbtrArg0};
-static const ioccrfFuncDef dbtrFuncDef = {"dbtr",1,dbtrArgs};
-static void dbtrCallFunc(const ioccrfArgBuf *args) { dbtr(args[0].sval);}
+static const iocshArg dbtrArg0 = { "record name",iocshArgString};
+static const iocshArg * const dbtrArgs[1] = {&dbtrArg0};
+static const iocshFuncDef dbtrFuncDef = {"dbtr",1,dbtrArgs};
+static void dbtrCallFunc(const iocshArgBuf *args) { dbtr(args[0].sval);}

 /* dbtgf */
-static const ioccrfArg dbtgfArg0 = { "record name",ioccrfArgString};
-static const ioccrfArg * const dbtgfArgs[1] = {&dbtgfArg0};
-static const ioccrfFuncDef dbtgfFuncDef = {"dbtgf",1,dbtgfArgs};
-static void dbtgfCallFunc(const ioccrfArgBuf *args) { dbtgf(args[0].sval);}
+static const iocshArg dbtgfArg0 = { "record name",iocshArgString};
+static const iocshArg * const dbtgfArgs[1] = {&dbtgfArg0};
+static const iocshFuncDef dbtgfFuncDef = {"dbtgf",1,dbtgfArgs};
+static void dbtgfCallFunc(const iocshArgBuf *args) { dbtgf(args[0].sval);}

 /* dbtpf */
-static const ioccrfArg dbtpfArg0 = { "record name",ioccrfArgString};
-static const ioccrfArg dbtpfArg1 = { "value",ioccrfArgString};
-static const ioccrfArg * const dbtpfArgs[2] = {&dbtpfArg0,&dbtpfArg1};
-static const ioccrfFuncDef dbtpfFuncDef = {"dbtpf",2,dbtpfArgs};
-static void dbtpfCallFunc(const ioccrfArgBuf *args)
+static const iocshArg dbtpfArg0 = { "record name",iocshArgString};
+static const iocshArg dbtpfArg1 = { "value",iocshArgString};
+static const iocshArg * const dbtpfArgs[2] = {&dbtpfArg0,&dbtpfArg1};
+static const iocshFuncDef dbtpfFuncDef = {"dbtpf",2,dbtpfArgs};
+static void dbtpfCallFunc(const iocshArgBuf *args)
 { dbtpf(args[0].sval,args[1].sval);}

 /* dbior */
-static const ioccrfArg dbiorArg0 = { "record name",ioccrfArgString};
-static const ioccrfArg dbiorArg1 = { "interest level",ioccrfArgInt};
-static const ioccrfArg * const dbiorArgs[2] = {&dbiorArg0,&dbiorArg1};
-static const ioccrfFuncDef dbiorFuncDef = {"dbior",2,dbiorArgs};
-static void dbiorCallFunc(const ioccrfArgBuf *args)
+static const iocshArg dbiorArg0 = { "record name",iocshArgString};
+static const iocshArg dbiorArg1 = { "interest level",iocshArgInt};
+static const iocshArg * const dbiorArgs[2] = {&dbiorArg0,&dbiorArg1};
+static const iocshFuncDef dbiorFuncDef = {"dbior",2,dbiorArgs};
+static void dbiorCallFunc(const iocshArgBuf *args)
 { dbior(args[0].sval,args[1].ival);}

 /* dbhcr */
-static const ioccrfArg dbhcrArg0 = { "filename",ioccrfArgString};
-static const ioccrfArg * const dbhcrArgs[1] = {&dbhcrArg0};
-static const ioccrfFuncDef dbhcrFuncDef = {"dbhcr",1,dbhcrArgs};
-static void dbhcrCallFunc(const ioccrfArgBuf *args) { dbhcr(args[0].sval);}
+static const iocshArg dbhcrArg0 = { "filename",iocshArgString};
+static const iocshArg * const dbhcrArgs[1] = {&dbhcrArg0};
+static const iocshFuncDef dbhcrFuncDef = {"dbhcr",1,dbhcrArgs};
+static void dbhcrCallFunc(const iocshArgBuf *args) { dbhcr(args[0].sval);}

 /* gft */
-static const ioccrfArg gftArg0 = { "record name",ioccrfArgString};
-static const ioccrfArg * const gftArgs[1] = {&gftArg0};
-static const ioccrfFuncDef gftFuncDef = {"gft",1,gftArgs};
-static void gftCallFunc(const ioccrfArgBuf *args) { gft(args[0].sval);}
+static const iocshArg gftArg0 = { "record name",iocshArgString};
+static const iocshArg * const gftArgs[1] = {&gftArg0};
+static const iocshFuncDef gftFuncDef = {"gft",1,gftArgs};
+static void gftCallFunc(const iocshArgBuf *args) { gft(args[0].sval);}

 /* pft */
-static const ioccrfArg pftArg0 = { "record name",ioccrfArgString};
-static const ioccrfArg pftArg1 = { "value",ioccrfArgString};
-static const ioccrfArg * const pftArgs[2] = {&pftArg0,&pftArg1};
-static const ioccrfFuncDef pftFuncDef = {"pft",2,pftArgs};
-static void pftCallFunc(const ioccrfArgBuf *args)
+static const iocshArg pftArg0 = { "record name",iocshArgString};
+static const iocshArg pftArg1 = { "value",iocshArgString};
+static const iocshArg * const pftArgs[2] = {&pftArg0,&pftArg1};
+static const iocshFuncDef pftFuncDef = {"pft",2,pftArgs};
+static void pftCallFunc(const iocshArgBuf *args)
 { pft(args[0].sval,args[1].sval);}

 /* dbtpn */
-static const ioccrfArg dbtpnArg0 = { "record name",ioccrfArgString};
-static const ioccrfArg dbtpnArg1 = { "value",ioccrfArgString};
-static const ioccrfArg * const dbtpnArgs[2] = {&dbtpnArg0,&dbtpnArg1};
-static const ioccrfFuncDef dbtpnFuncDef = {"dbtpn",2,dbtpnArgs};
-static void dbtpnCallFunc(const ioccrfArgBuf *args)
+static const iocshArg dbtpnArg0 = { "record name",iocshArgString};
+static const iocshArg dbtpnArg1 = { "value",iocshArgString};
+static const iocshArg * const dbtpnArgs[2] = {&dbtpnArg0,&dbtpnArg1};
+static const iocshFuncDef dbtpnFuncDef = {"dbtpn",2,dbtpnArgs};
+static void dbtpnCallFunc(const iocshArgBuf *args)
 { dbtpn(args[0].sval,args[1].sval);}

 /* tpn */
-static const ioccrfArg tpnArg0 = { "record name",ioccrfArgString};
-static const ioccrfArg tpnArg1 = { "value",ioccrfArgString};
-static const ioccrfArg * const tpnArgs[2] = {&tpnArg0,&tpnArg1};
-static const ioccrfFuncDef tpnFuncDef = {"tpn",2,tpnArgs};
-static void tpnCallFunc(const ioccrfArgBuf *args)
+static const iocshArg tpnArg0 = { "record name",iocshArgString};
+static const iocshArg tpnArg1 = { "value",iocshArgString};
+static const iocshArg * const tpnArgs[2] = {&tpnArg0,&tpnArg1};
+static const iocshFuncDef tpnFuncDef = {"tpn",2,tpnArgs};
+static void tpnCallFunc(const iocshArgBuf *args)
 { tpn(args[0].sval,args[1].sval);}

 /* dblsr */
-static const ioccrfArg dblsrArg0 = { "record name",ioccrfArgString};
-static const ioccrfArg dblsrArg1 = { "interest level",ioccrfArgInt};
-static const ioccrfArg * const dblsrArgs[2] = {&dblsrArg0,&dblsrArg1};
-static const ioccrfFuncDef dblsrFuncDef = {"dblsr",2,dblsrArgs};
-static void dblsrCallFunc(const ioccrfArgBuf *args)
+static const iocshArg dblsrArg0 = { "record name",iocshArgString};
+static const iocshArg dblsrArg1 = { "interest level",iocshArgInt};
+static const iocshArg * const dblsrArgs[2] = {&dblsrArg0,&dblsrArg1};
+static const iocshFuncDef dblsrFuncDef = {"dblsr",2,dblsrArgs};
+static void dblsrCallFunc(const iocshArgBuf *args)
 { dblsr(args[0].sval,args[1].ival);}

 /* scanppl */
-static const ioccrfArg scanpplArg0 = { "rate",ioccrfArgDouble};
-static const ioccrfArg * const scanpplArgs[1] = {&scanpplArg0};
-static const ioccrfFuncDef scanpplFuncDef = {"scanppl",1,scanpplArgs};
-static void scanpplCallFunc(const ioccrfArgBuf *args)
+static const iocshArg scanpplArg0 = { "rate",iocshArgDouble};
+static const iocshArg * const scanpplArgs[1] = {&scanpplArg0};
+static const iocshFuncDef scanpplFuncDef = {"scanppl",1,scanpplArgs};
+static void scanpplCallFunc(const iocshArgBuf *args)
 { scanppl(args[0].dval);}

 /* scanpel */
-static const ioccrfArg scanpelArg0 = { "event number",ioccrfArgInt};
-static const ioccrfArg * const scanpelArgs[1] = {&scanpelArg0};
-static const ioccrfFuncDef scanpelFuncDef = {"scanpel",1,scanpelArgs};
-static void scanpelCallFunc(const ioccrfArgBuf *args)
+static const iocshArg scanpelArg0 = { "event number",iocshArgInt};
+static const iocshArg * const scanpelArgs[1] = {&scanpelArg0};
+static const iocshFuncDef scanpelFuncDef = {"scanpel",1,scanpelArgs};
+static void scanpelCallFunc(const iocshArgBuf *args)
 { scanpel(args[0].ival);}

 /* scanpiol */
-static const ioccrfFuncDef scanpiolFuncDef = {"scanpiol",0};
-static void scanpiolCallFunc(const ioccrfArgBuf *args) { scanpiol();}
+static const iocshFuncDef scanpiolFuncDef = {"scanpiol",0};
+static void scanpiolCallFunc(const iocshArgBuf *args) { scanpiol();}

 void epicsShareAPI dbTestRegister(void)
 {
-    ioccrfRegister(&dbaFuncDef,dbaCallFunc);
-    ioccrfRegister(&dblFuncDef,dblCallFunc);
-    ioccrfRegister(&dbnrFuncDef,dbnrCallFunc);
-    ioccrfRegister(&dbgrepFuncDef,dbgrepCallFunc);
-    ioccrfRegister(&dbgfFuncDef,dbgfCallFunc);
-    ioccrfRegister(&dbpfFuncDef,dbpfCallFunc);
-    ioccrfRegister(&dbprFuncDef,dbprCallFunc);
-    ioccrfRegister(&dbtrFuncDef,dbtrCallFunc);
-    ioccrfRegister(&dbtgfFuncDef,dbtgfCallFunc);
-    ioccrfRegister(&dbtpfFuncDef,dbtpfCallFunc);
-    ioccrfRegister(&dbiorFuncDef,dbiorCallFunc);
-    ioccrfRegister(&dbhcrFuncDef,dbhcrCallFunc);
-    ioccrfRegister(&gftFuncDef,gftCallFunc);
-    ioccrfRegister(&pftFuncDef,pftCallFunc);
-    ioccrfRegister(&dbtpnFuncDef,dbtpnCallFunc);
-    ioccrfRegister(&tpnFuncDef,tpnCallFunc);
-    ioccrfRegister(&dblsrFuncDef,dblsrCallFunc);
-    ioccrfRegister(&scanpplFuncDef,scanpplCallFunc);
-    ioccrfRegister(&scanpelFuncDef,scanpelCallFunc);
-    ioccrfRegister(&scanpiolFuncDef,scanpiolCallFunc);
+    iocshRegister(&dbaFuncDef,dbaCallFunc);
+    iocshRegister(&dblFuncDef,dblCallFunc);
+    iocshRegister(&dbnrFuncDef,dbnrCallFunc);
+    iocshRegister(&dbgrepFuncDef,dbgrepCallFunc);
+    iocshRegister(&dbgfFuncDef,dbgfCallFunc);
+    iocshRegister(&dbpfFuncDef,dbpfCallFunc);
+    iocshRegister(&dbprFuncDef,dbprCallFunc);
+    iocshRegister(&dbtrFuncDef,dbtrCallFunc);
+    iocshRegister(&dbtgfFuncDef,dbtgfCallFunc);
+    iocshRegister(&dbtpfFuncDef,dbtpfCallFunc);
+    iocshRegister(&dbiorFuncDef,dbiorCallFunc);
+    iocshRegister(&dbhcrFuncDef,dbhcrCallFunc);
+    iocshRegister(&gftFuncDef,gftCallFunc);
+    iocshRegister(&pftFuncDef,pftCallFunc);
+    iocshRegister(&dbtpnFuncDef,dbtpnCallFunc);
+    iocshRegister(&tpnFuncDef,tpnCallFunc);
+    iocshRegister(&dblsrFuncDef,dblsrCallFunc);
+    iocshRegister(&scanpplFuncDef,scanpplCallFunc);
+    iocshRegister(&scanpelFuncDef,scanpelCallFunc);
+    iocshRegister(&scanpiolFuncDef,scanpiolCallFunc);
 }
--- a/src/iocsh/envRegister.c
+++ b/src/iocsh/envRegister.c
@@ -14,14 +14,14 @@ of this distribution.

 #include "envDefs.h"
 #define epicsExportSharedSymbols
-#include "ioccrf.h"
+#include "iocsh.h"
 #include "envRegister.h"

 /* epicsPrtEnvParams */
-static const ioccrfFuncDef epicsPrtEnvParamsFuncDef = {"epicsPrtEnvParams",0,0};
-static void epicsPrtEnvParamsCallFunc(const ioccrfArgBuf *args) { epicsPrtEnvParams();}
+static const iocshFuncDef epicsPrtEnvParamsFuncDef = {"epicsPrtEnvParams",0,0};
+static void epicsPrtEnvParamsCallFunc(const iocshArgBuf *args) { epicsPrtEnvParams();}

 void epicsShareAPI envRegister(void)
 {
-    ioccrfRegister(&epicsPrtEnvParamsFuncDef,epicsPrtEnvParamsCallFunc);
+    iocshRegister(&epicsPrtEnvParamsFuncDef,epicsPrtEnvParamsCallFunc);
 }
--- a/src/iocsh/iocUtil.c
+++ b/src/iocsh/iocUtil.c
@@ -12,23 +12,23 @@
 #include "epicsThread.h"

 #define epicsExportSharedSymbols
-#include "ioccrf.h"
+#include "iocsh.h"
 #include "iocUtilRegister.h"

 /* < (runScript) command */
-static const ioccrfArg runScriptArg0 = { "command file name",ioccrfArgString};
-static const ioccrfArg * const runScriptArgs[1] = {&runScriptArg0};
-static const ioccrfFuncDef runScriptFuncDef = {"<",1,runScriptArgs};
-static void runScriptCallFunc(const ioccrfArgBuf *args)
+static const iocshArg runScriptArg0 = { "command file name",iocshArgString};
+static const iocshArg * const runScriptArgs[1] = {&runScriptArg0};
+static const iocshFuncDef runScriptFuncDef = {"<",1,runScriptArgs};
+static void runScriptCallFunc(const iocshArgBuf *args)
 {
-    ioccrf (args[0].sval);
+    iocsh (args[0].sval);
 }

 /* chdir */
-static const ioccrfArg chdirArg0 = { "current directory name",ioccrfArgString};
-static const ioccrfArg * const chdirArgs[1] = {&chdirArg0};
-static const ioccrfFuncDef chdirFuncDef = {"cd",1,chdirArgs};
-static void chdirCallFunc(const ioccrfArgBuf *args)
+static const iocshArg chdirArg0 = { "current directory name",iocshArgString};
+static const iocshArg * const chdirArgs[1] = {&chdirArg0};
+static const iocshFuncDef chdirFuncDef = {"cd",1,chdirArgs};
+static void chdirCallFunc(const iocshArgBuf *args)
 {
    int status;
    status = chdir(args[0].sval);
@@ -38,8 +38,8 @@ static void chdirCallFunc(const ioccrfArgBuf *args)
 }

 /* print current working directory */
-static const ioccrfFuncDef pwdFuncDef = { "pwd", 0, 0 };
-static void pwdCallFunc (const ioccrfArgBuf *args)
+static const iocshFuncDef pwdFuncDef = { "pwd", 0, 0 };
+static void pwdCallFunc (const iocshArgBuf *args)
 {
    char buf[256];
    char *pwd = getcwd ( buf, sizeof(buf) - 1 );
@@ -49,10 +49,10 @@ static void pwdCallFunc (const ioccrfArgBuf *args)
 }

 /* show (thread information) */
-static const ioccrfArg showArg0 = { "[-level] [task ...]", ioccrfArgArgv};
-static const ioccrfArg * const showArgs[1] = { &showArg0 };
-static const ioccrfFuncDef showFuncDef = {"show",1,showArgs};
-static void showCallFunc(const ioccrfArgBuf *args)
+static const iocshArg showArg0 = { "[-level] [task ...]", iocshArgArgv};
+static const iocshArg * const showArgs[1] = { &showArg0 };
+static const iocshFuncDef showFuncDef = {"show",1,showArgs};
+static void showCallFunc(const iocshArgBuf *args)
 {
    int i = 1;
    int first = 1;
@@ -94,11 +94,11 @@ static void showCallFunc(const ioccrfArgBuf *args)
 }

 /* epicsEnvSet */
-static const ioccrfArg epicsEnvSetArg0 = { "name",ioccrfArgString};
-static const ioccrfArg epicsEnvSetArg1 = { "value",ioccrfArgString};
-static const ioccrfArg * const epicsEnvSetArgs[2] = {&epicsEnvSetArg0,&epicsEnvSetArg1};
-static const ioccrfFuncDef epicsEnvSetFuncDef = {"epicsEnvSet",2,epicsEnvSetArgs};
-static void epicsEnvSetCallFunc(const ioccrfArgBuf *args)
+static const iocshArg epicsEnvSetArg0 = { "name",iocshArgString};
+static const iocshArg epicsEnvSetArg1 = { "value",iocshArgString};
+static const iocshArg * const epicsEnvSetArgs[2] = {&epicsEnvSetArg0,&epicsEnvSetArg1};
+static const iocshFuncDef epicsEnvSetFuncDef = {"epicsEnvSet",2,epicsEnvSetArgs};
+static void epicsEnvSetCallFunc(const iocshArgBuf *args)
 {
    char *name = args[0].sval;
    char *value = args[1].sval;
@@ -115,36 +115,36 @@ static void epicsEnvSetCallFunc(const ioccrfArgBuf *args)
 }

 /* epicsParamShow */
-static const ioccrfFuncDef epicsParamShowFuncDef = {"epicsParamShow",0,NULL};
-static void epicsParamShowCallFunc(const ioccrfArgBuf *args)
+static const iocshFuncDef epicsParamShowFuncDef = {"epicsParamShow",0,NULL};
+static void epicsParamShowCallFunc(const iocshArgBuf *args)
 {
    epicsPrtEnvParams ();
 }

 /* epicsEnvShow */
-static const ioccrfArg epicsEnvShowArg0 = { "[name]",ioccrfArgString};
-static const ioccrfArg * const epicsEnvShowArgs[1] = {&epicsEnvShowArg0};
-static const ioccrfFuncDef epicsEnvShowFuncDef = {"epicsEnvShow",1,epicsEnvShowArgs};
-static void epicsEnvShowCallFunc(const ioccrfArgBuf *args)
+static const iocshArg epicsEnvShowArg0 = { "[name]",iocshArgString};
+static const iocshArg * const epicsEnvShowArgs[1] = {&epicsEnvShowArg0};
+static const iocshFuncDef epicsEnvShowFuncDef = {"epicsEnvShow",1,epicsEnvShowArgs};
+static void epicsEnvShowCallFunc(const iocshArgBuf *args)
 {
    epicsEnvShow (args[0].sval);
 }

 /* iocLogInit */
-static const ioccrfFuncDef iocLogInitFuncDef = {"iocLogInit",0};
-static void iocLogInitCallFunc(const ioccrfArgBuf *args)
+static const iocshFuncDef iocLogInitFuncDef = {"iocLogInit",0};
+static void iocLogInitCallFunc(const iocshArgBuf *args)
 {
    iocLogInit ();
 }

 void epicsShareAPI iocUtilRegister(void)
 {
-    ioccrfRegister(&runScriptFuncDef,runScriptCallFunc);
-    ioccrfRegister(&chdirFuncDef,chdirCallFunc);
-    ioccrfRegister(&pwdFuncDef,pwdCallFunc);
-    ioccrfRegister(&showFuncDef,showCallFunc);
-    ioccrfRegister(&epicsEnvSetFuncDef,epicsEnvSetCallFunc);
-    ioccrfRegister(&epicsParamShowFuncDef,epicsParamShowCallFunc);
-    ioccrfRegister(&epicsEnvShowFuncDef,epicsEnvShowCallFunc);
-    ioccrfRegister(&iocLogInitFuncDef,iocLogInitCallFunc);
+    iocshRegister(&runScriptFuncDef,runScriptCallFunc);
+    iocshRegister(&chdirFuncDef,chdirCallFunc);
+    iocshRegister(&pwdFuncDef,pwdCallFunc);
+    iocshRegister(&showFuncDef,showCallFunc);
+    iocshRegister(&epicsEnvSetFuncDef,epicsEnvSetCallFunc);
+    iocshRegister(&epicsParamShowFuncDef,epicsParamShowCallFunc);
+    iocshRegister(&epicsEnvShowFuncDef,epicsEnvShowCallFunc);
+    iocshRegister(&iocLogInitFuncDef,iocLogInitCallFunc);
 }
--- a/src/iocsh/ioccrf.h
+++ b/src/iocsh/ioccrf.h
@@ -1,65 +0,0 @@
-/* ioccrf.h  ioc: call registered function*/
-/* Author:  Marty Kraimer Date: 27APR2000 */
-
-/********************COPYRIGHT NOTIFICATION**********************************
-This software was developed under a United States Government license
-described on the COPYRIGHT_UniversityOfChicago file included as part
-of this distribution.
-****************************************************************************/
-
-#ifndef INCioccrfH
-#define INCioccrfH
-
-#include <stdio.h>
-#include "shareLib.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef enum {
-    ioccrfArgInt,
-    ioccrfArgDouble,
-    ioccrfArgString,
-    ioccrfArgPdbbase,
-    ioccrfArgArgv
-}ioccrfArgType;
-
-typedef union ioccrfArgBuf {
-    int    ival;
-    double dval;
-    char  *sval;
-    void  *vval;
-    struct {
-     int    ac;
-     char **av;
-    }      aval;
-}ioccrfArgBuf;
-
-typedef struct ioccrfArg {
-    const char *name;
-    ioccrfArgType type;
-}ioccrfArg;
-
-typedef struct ioccrfFuncDef {
-    const char *name;
-    int nargs;
-    const ioccrfArg * const *arg;
-}ioccrfFuncDef;
-
-typedef void (*ioccrfCallFunc)(const ioccrfArgBuf *argBuf);
-
-epicsShareFunc void epicsShareAPI ioccrfRegister(
-    const ioccrfFuncDef *pioccrfFuncDef, ioccrfCallFunc func);
-
-/* ioccrfFree frees storage used by ioccrfRegister*/
-/* This should only be called when ioccrf is no longer needed*/
-epicsShareFunc void epicsShareAPI ioccrfFree(void);
-
-epicsShareFunc int epicsShareAPI ioccrf(const char *pathname);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /*INCioccrfH*/
--- a/src/iocsh/ioccrf.cpp
+++ b/src/iocsh/ioccrf.cpp
@@ -1,4 +1,4 @@
-/* ioccrf.cpp */
+/* iocsh.cpp */
 /* Author:  Marty Kraimer Date: 27APR2000 */
 /* Heavily modified by Eric Norum   Date: 03MAY2000 */
 /* Adapted to C++ by Eric Norum   Date: 18DEC2000 */
@@ -22,19 +22,19 @@ of this distribution.
 #include "epicsMutex.h"
 #include "registry.h"
 #define epicsExportSharedSymbols
-#include "ioccrf.h"
+#include "iocsh.h"
 #include "epicsReadline.h"

 /*
 * File-local information
 */
-struct ioccrfCommand {
-    ioccrfFuncDef const     *pFuncDef;
-    ioccrfCallFunc          func;
-    struct ioccrfCommand    *next;
+struct iocshCommand {
+    iocshFuncDef const     *pFuncDef;
+    iocshCallFunc          func;
+    struct iocshCommand    *next;
 };
-static struct ioccrfCommand *ioccrfCommandHead;
-static char ioccrfID[] = "ioccrf";
+static struct iocshCommand *iocshCommandHead;
+static char iocshID[] = "iocsh";
 static epicsMutexId commandTableMutex;
 static epicsThreadOnceId commandTableOnceId = EPICS_THREAD_ONCE_INIT;

@@ -69,16 +69,16 @@ commandTableUnlock (void)
 /*
 * Register a command
 */
-void epicsShareAPI ioccrfRegister (const ioccrfFuncDef *pioccrfFuncDef, ioccrfCallFunc func)
+void epicsShareAPI iocshRegister (const iocshFuncDef *piocshFuncDef, iocshCallFunc func)
 {
-    struct ioccrfCommand *l, *p, *n;
+    struct iocshCommand *l, *p, *n;
    int i;

    commandTableLock ();
-    for (l = NULL, p = ioccrfCommandHead ; p != NULL ; l = p, p = p->next) {
-        i = strcmp (pioccrfFuncDef->name, p->pFuncDef->name);
+    for (l = NULL, p = iocshCommandHead ; p != NULL ; l = p, p = p->next) {
+        i = strcmp (piocshFuncDef->name, p->pFuncDef->name);
        if (i == 0) {
-            p->pFuncDef = pioccrfFuncDef;
+            p->pFuncDef = piocshFuncDef;
            p->func = func;
            commandTableUnlock ();
            return;
@@ -86,35 +86,35 @@ void epicsShareAPI ioccrfRegister (const ioccrfFuncDef *pioccrfFuncDef, ioccrfCa
        if (i < 0)
            break;
    }
-    n = (struct ioccrfCommand *)callocMustSucceed (1, sizeof *n, "ioccrfRegister");
-    if (!registryAdd(ioccrfID, pioccrfFuncDef->name, (void *)n)) {
+    n = (struct iocshCommand *)callocMustSucceed (1, sizeof *n, "iocshRegister");
+    if (!registryAdd(iocshID, piocshFuncDef->name, (void *)n)) {
        free (n);
        commandTableUnlock ();
-        errlogPrintf ("ioccrfRegister failed to add %s\n", pioccrfFuncDef->name);
+        errlogPrintf ("iocshRegister failed to add %s\n", piocshFuncDef->name);
        return;
    }
    if (l == NULL) {
-        n->next = ioccrfCommandHead;
-        ioccrfCommandHead = n;
+        n->next = iocshCommandHead;
+        iocshCommandHead = n;
    }
    else {
        n->next = l->next;
        l->next = n;
    }
-    n->pFuncDef = pioccrfFuncDef;
+    n->pFuncDef = piocshFuncDef;
    n->func = func;
    commandTableUnlock ();
 }

 /*
- * Free storage created by ioccrfRegister
+ * Free storage created by iocshRegister
 */
-void epicsShareAPI ioccrfFree(void) 
+void epicsShareAPI iocshFree(void) 
 {
-    struct ioccrfCommand *p, *n;
+    struct iocshCommand *p, *n;

    commandTableLock ();
-    for (p = ioccrfCommandHead ; p != NULL ; ) {
+    for (p = iocshCommandHead ; p != NULL ; ) {
        n = p->next;
        free (p);
        p = n;
@@ -139,12 +139,12 @@ showError (const char *filename, int lineno, const char *msg, ...)
 }

 static int
-cvtArg (const char *filename, int lineno, char *arg, ioccrfArgBuf *argBuf, const ioccrfArg *pioccrfArg)
+cvtArg (const char *filename, int lineno, char *arg, iocshArgBuf *argBuf, const iocshArg *piocshArg)
 {
    char *endp;

-    switch (pioccrfArg->type) {
-    case ioccrfArgInt:
+    switch (piocshArg->type) {
+    case iocshArgInt:
        if (arg && *arg) {
            argBuf->ival = strtol (arg, &endp, 0);
            if (*endp) {
@@ -157,7 +157,7 @@ cvtArg (const char *filename, int lineno, char *arg, ioccrfArgBuf *argBuf, const
        }
        break;

-    case ioccrfArgDouble:
+    case iocshArgDouble:
        if (arg && *arg) {
            argBuf->dval = strtod (arg, &endp);
            if (*endp) {
@@ -170,11 +170,11 @@ cvtArg (const char *filename, int lineno, char *arg, ioccrfArgBuf *argBuf, const
        }
        break;

-    case ioccrfArgString:
+    case iocshArgString:
        argBuf->sval = arg;
        break;

-    case ioccrfArgPdbbase:
+    case iocshArgPdbbase:
        /* Argument must be missing or 0 or pdbbase */
        if(!arg || !*arg || (*arg == '0') || (strcmp(arg, "pdbbase") == 0)) {
            argBuf->vval = pdbbase;
@@ -184,7 +184,7 @@ cvtArg (const char *filename, int lineno, char *arg, ioccrfArgBuf *argBuf, const
        return 0;

    default:
-        showError (filename, lineno, "Illegal argument type %d", pioccrfArg->type);
+        showError (filename, lineno, "Illegal argument type %d", piocshArg->type);
        return 0;
    }
    return 1;
@@ -194,7 +194,7 @@ cvtArg (const char *filename, int lineno, char *arg, ioccrfArgBuf *argBuf, const
 * The body of the command interpreter
 */
 int epicsShareAPI
-ioccrf (const char *pathname)
+iocsh (const char *pathname)
 {
    FILE *fp = NULL;
    const char *filename = NULL;
@@ -208,10 +208,10 @@ ioccrf (const char *pathname)
    int sep;
    const char *prompt;
    const char *ifs = " \t(),";
-    ioccrfArgBuf *argBuf = NULL;
+    iocshArgBuf *argBuf = NULL;
    int argBufCapacity = 0;
-    struct ioccrfCommand *found;
-    struct ioccrfFuncDef const *pioccrfFuncDef;
+    struct iocshCommand *found;
+    struct iocshFuncDef const *piocshFuncDef;
    
    /*
     * See if command interpreter is interactive
@@ -367,14 +367,14 @@ ioccrf (const char *pathname)

                    printf ("Type `help command_name' to get more information about a particular command.\n");
                    commandTableLock ();
-                    for (found = ioccrfCommandHead ; found != NULL ; found = found->next) {
-                        pioccrfFuncDef = found->pFuncDef;
-                        l = strlen (pioccrfFuncDef->name);
+                    for (found = iocshCommandHead ; found != NULL ; found = found->next) {
+                        piocshFuncDef = found->pFuncDef;
+                        l = strlen (piocshFuncDef->name);
                        if ((l + col) >= 79) {
                            putchar ('\n');
                            col = 0;
                        }
-                        fputs (pioccrfFuncDef->name, stdout);
+                        fputs (piocshFuncDef->name, stdout);
                        col += l;
                        if (col >= 64) {
                            putchar ('\n');
@@ -393,16 +393,16 @@ ioccrf (const char *pathname)
                }
                else {
                    for (int i = 1 ; i < argc ; i++) {
-                        found = (ioccrfCommand *)registryFind (ioccrfID, argv[i]);
+                        found = (iocshCommand *)registryFind (iocshID, argv[i]);
                        if (found == NULL) {
                            printf ("%s -- no such command.\n", argv[i]);
                        }
                        else {
-                            pioccrfFuncDef = found->pFuncDef;
-                            fputs (pioccrfFuncDef->name, stdout);
-                            for (int a = 0 ; a < pioccrfFuncDef->nargs ; a++) {
-                                const char *cp = pioccrfFuncDef->arg[a]->name;
-                                if ((pioccrfFuncDef->arg[a]->type == ioccrfArgArgv)
+                            piocshFuncDef = found->pFuncDef;
+                            fputs (piocshFuncDef->name, stdout);
+                            for (int a = 0 ; a < piocshFuncDef->nargs ; a++) {
+                                const char *cp = piocshFuncDef->arg[a]->name;
+                                if ((piocshFuncDef->arg[a]->type == iocshArgArgv)
                                 || (strchr (cp, ' ') == NULL)) {
                                    printf (" %s", cp);
                                }
@@ -420,18 +420,18 @@ ioccrf (const char *pathname)
            /*
             * Look up command
             */
-            found = (ioccrfCommand *)registryFind (ioccrfID, argv[0]);
+            found = (iocshCommand *)registryFind (iocshID, argv[0]);
            if (!found) {
                showError (filename, lineno, "Command %s not found.", argv[0]);
                continue;
            }
-            pioccrfFuncDef = found->pFuncDef;
+            piocshFuncDef = found->pFuncDef;

            /*
             * Process arguments and call function
             */
            for (int arg = 0 ; ; arg++) {
-                if (arg == pioccrfFuncDef->nargs) {
+                if (arg == piocshFuncDef->nargs) {
                    (*found->func)(argBuf);
                    break;
                }
@@ -445,9 +445,9 @@ ioccrf (const char *pathname)
                        argBufCapacity -= 20;
                        break;
                    }
-                    argBuf = (ioccrfArgBuf *)np;
+                    argBuf = (iocshArgBuf *)np;
                }
-                if (pioccrfFuncDef->arg[arg]->type == ioccrfArgArgv) {
+                if (piocshFuncDef->arg[arg]->type == iocshArgArgv) {
                    argBuf[arg].aval.ac = argc-arg;
                    argBuf[arg].aval.av = argv+arg;
                    (*found->func)(argBuf);
@@ -455,7 +455,7 @@ ioccrf (const char *pathname)
                }
                if (!cvtArg (filename, lineno,
                                        ((arg < argc) ? argv[arg+1] : NULL),
-                                        &argBuf[arg], pioccrfFuncDef->arg[arg]))
+                                        &argBuf[arg], piocshFuncDef->arg[arg]))
                    break;
            }
        }
@@ -475,34 +475,34 @@ ioccrf (const char *pathname)

 extern "C" {
 /* help */
-static const ioccrfArg helpArg0 = { "command",ioccrfArgInt};
-static const ioccrfArg *helpArgs[1] = {&helpArg0};
-static const ioccrfFuncDef helpFuncDef =
+static const iocshArg helpArg0 = { "command",iocshArgInt};
+static const iocshArg *helpArgs[1] = {&helpArg0};
+static const iocshFuncDef helpFuncDef =
    {"help",1,helpArgs};
-static void helpCallFunc(const ioccrfArgBuf *)
+static void helpCallFunc(const iocshArgBuf *)
 {
 }

 /* comment */
-static const ioccrfArg commentArg0 = { "newline-terminated comment",ioccrfArgArgv};
-static const ioccrfArg *commentArgs[1] = {&commentArg0};
-static const ioccrfFuncDef commentFuncDef = {"#",1,commentArgs};
-static void commentCallFunc(const ioccrfArgBuf *)
+static const iocshArg commentArg0 = { "newline-terminated comment",iocshArgArgv};
+static const iocshArg *commentArgs[1] = {&commentArg0};
+static const iocshFuncDef commentFuncDef = {"#",1,commentArgs};
+static void commentCallFunc(const iocshArgBuf *)
 {
 }

 /* exit */
-static const ioccrfFuncDef exitFuncDef =
+static const iocshFuncDef exitFuncDef =
    {"exit",0,0};
-static void exitCallFunc(const ioccrfArgBuf *)
+static void exitCallFunc(const iocshArgBuf *)
 {
 }

 static void localRegister (void)
 {
-    ioccrfRegister(&helpFuncDef,helpCallFunc);
-    ioccrfRegister(&commentFuncDef,helpCallFunc);
-    ioccrfRegister(&exitFuncDef,exitCallFunc);
+    iocshRegister(&helpFuncDef,helpCallFunc);
+    iocshRegister(&commentFuncDef,helpCallFunc);
+    iocshRegister(&exitFuncDef,exitCallFunc);
 }

 } /* extern "C" */
@@ -510,9 +510,9 @@ static void localRegister (void)
 /*
 * Register commands on application startup
 */
-#include "ioccrfRegisterCommon.h"
-class IoccrfRegister {
+#include "iocshRegisterCommon.h"
+class IocshRegister {
  public:
-    IoccrfRegister() { localRegister(); ioccrfRegisterCommon(); }
+    IocshRegister() { localRegister(); iocshRegisterCommon(); }
 };
-static IoccrfRegister ioccrfRegisterObj;
+static IocshRegister iocshRegisterObj;
--- a/src/iocsh/iocsh.h
+++ b/src/iocsh/iocsh.h
@@ -0,0 +1,65 @@
+/* iocsh.h  ioc: call registered function*/
+/* Author:  Marty Kraimer Date: 27APR2000 */
+
+/********************COPYRIGHT NOTIFICATION**********************************
+This software was developed under a United States Government license
+described on the COPYRIGHT_UniversityOfChicago file included as part
+of this distribution.
+****************************************************************************/
+
+#ifndef INCiocshH
+#define INCiocshH
+
+#include <stdio.h>
+#include "shareLib.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+    iocshArgInt,
+    iocshArgDouble,
+    iocshArgString,
+    iocshArgPdbbase,
+    iocshArgArgv
+}iocshArgType;
+
+typedef union iocshArgBuf {
+    int    ival;
+    double dval;
+    char  *sval;
+    void  *vval;
+    struct {
+     int    ac;
+     char **av;
+    }      aval;
+}iocshArgBuf;
+
+typedef struct iocshArg {
+    const char *name;
+    iocshArgType type;
+}iocshArg;
+
+typedef struct iocshFuncDef {
+    const char *name;
+    int nargs;
+    const iocshArg * const *arg;
+}iocshFuncDef;
+
+typedef void (*iocshCallFunc)(const iocshArgBuf *argBuf);
+
+epicsShareFunc void epicsShareAPI iocshRegister(
+    const iocshFuncDef *piocshFuncDef, iocshCallFunc func);
+
+/* iocshFree frees storage used by iocshRegister*/
+/* This should only be called when iocsh is no longer needed*/
+epicsShareFunc void epicsShareAPI iocshFree(void);
+
+epicsShareFunc int epicsShareAPI iocsh(const char *pathname);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*INCiocshH*/
--- a/src/iocsh/ioccrfRegisterCommon.c
+++ b/src/iocsh/ioccrfRegisterCommon.c
@@ -1,4 +1,4 @@
-/* ioccrfRegisterCommon.c */
+/* iocshRegisterCommon.c */
 /* Author:  Marty Kraimer Date: 26APR2000 */

 /********************COPYRIGHT NOTIFICATION**********************************
@@ -22,11 +22,11 @@ of this distribution.
 #include "dbAccessRegister.h"
 #include "asTestRegister.h"
 #include "envRegister.h"
-#include "ioccrfRegisterCommon.h"
+#include "iocshRegisterCommon.h"
 #include "osiRegister.h"
-#include "ioccrf.h"
+#include "iocsh.h"

-void epicsShareAPI ioccrfRegisterCommon(void)
+void epicsShareAPI iocshRegisterCommon(void)
 {
    osiRegister();
    iocUtilRegister();
--- a/src/iocsh/ioccrfRegisterCommon.h
+++ b/src/iocsh/ioccrfRegisterCommon.h
@@ -1,4 +1,4 @@
-/* ioccrfRegisterCommon.h */
+/* iocshRegisterCommon.h */
 /* Author:  Marty Kraimer Date: 27APR2000 */

 /********************COPYRIGHT NOTIFICATION**********************************
@@ -7,8 +7,8 @@ described on the COPYRIGHT_UniversityOfChicago file included as part
 of this distribution.
 ****************************************************************************/

-#ifndef INCioccrfRegisterCommonH
-#define INCioccrfRegisterCommonH
+#ifndef INCiocshRegisterCommonH
+#define INCiocshRegisterCommonH

 #include "shareLib.h"

@@ -17,10 +17,10 @@ extern "C" {
 #endif

 /* register many useful commands */
-epicsShareFunc void epicsShareAPI ioccrfRegisterCommon(void);
+epicsShareFunc void epicsShareAPI iocshRegisterCommon(void);

 #ifdef __cplusplus
 }
 #endif

-#endif /*INCioccrfRegisterCommonH*/
+#endif /*INCiocshRegisterCommonH*/
--- a/src/iocsh/osiRegister.c
+++ b/src/iocsh/osiRegister.c
@@ -16,44 +16,44 @@ of this distribution.
 #include "epicsMutex.h"
 #include "dbEvent.h"
 #define epicsExportSharedSymbols
-#include "ioccrf.h"
+#include "iocsh.h"
 #include "osiRegister.h"

 /* epicsThreadShowAll */
-static const ioccrfArg epicsThreadShowAllArg0 = { "level",ioccrfArgInt};
-static const ioccrfArg * const epicsThreadShowAllArgs[1] = {&epicsThreadShowAllArg0};
-static const ioccrfFuncDef epicsThreadShowAllFuncDef =
+static const iocshArg epicsThreadShowAllArg0 = { "level",iocshArgInt};
+static const iocshArg * const epicsThreadShowAllArgs[1] = {&epicsThreadShowAllArg0};
+static const iocshFuncDef epicsThreadShowAllFuncDef =
    {"epicsThreadShowAll",1,epicsThreadShowAllArgs};
-static void epicsThreadShowAllCallFunc(const ioccrfArgBuf *args)
+static void epicsThreadShowAllCallFunc(const iocshArgBuf *args)
 {
    epicsThreadShowAll(args[0].ival);
 }

 /* epicsMutexShowAll */
-static const ioccrfArg epicsMutexShowAllArg0 = { "onlyLocked",ioccrfArgInt};
-static const ioccrfArg epicsMutexShowAllArg1 = { "level",ioccrfArgInt};
-static const ioccrfArg * const epicsMutexShowAllArgs[2] =
+static const iocshArg epicsMutexShowAllArg0 = { "onlyLocked",iocshArgInt};
+static const iocshArg epicsMutexShowAllArg1 = { "level",iocshArgInt};
+static const iocshArg * const epicsMutexShowAllArgs[2] =
    {&epicsMutexShowAllArg0,&epicsMutexShowAllArg1};
-static const ioccrfFuncDef epicsMutexShowAllFuncDef =
+static const iocshFuncDef epicsMutexShowAllFuncDef =
    {"epicsMutexShowAll",1,epicsMutexShowAllArgs};
-static void epicsMutexShowAllCallFunc(const ioccrfArgBuf *args)
+static void epicsMutexShowAllCallFunc(const iocshArgBuf *args)
 {
    epicsMutexShowAll(args[0].ival,args[1].ival);
 }

 /* epicsThreadSleep */
-static const ioccrfArg epicsThreadSleepArg0 = { "seconds",ioccrfArgDouble};
-static const ioccrfArg * const epicsThreadSleepArgs[1] = {&epicsThreadSleepArg0};
-static const ioccrfFuncDef epicsThreadSleepFuncDef =
+static const iocshArg epicsThreadSleepArg0 = { "seconds",iocshArgDouble};
+static const iocshArg * const epicsThreadSleepArgs[1] = {&epicsThreadSleepArg0};
+static const iocshFuncDef epicsThreadSleepFuncDef =
    {"epicsThreadSleep",1,epicsThreadSleepArgs};
-static void epicsThreadSleepCallFunc(const ioccrfArgBuf *args)
+static void epicsThreadSleepCallFunc(const iocshArgBuf *args)
 {
    epicsThreadSleep(args[0].dval);
 }

 void epicsShareAPI osiRegister(void)
 {
-    ioccrfRegister(&epicsThreadShowAllFuncDef,epicsThreadShowAllCallFunc);
-    ioccrfRegister(&epicsMutexShowAllFuncDef,epicsMutexShowAllCallFunc);
-    ioccrfRegister(&epicsThreadSleepFuncDef,epicsThreadSleepCallFunc);
+    iocshRegister(&epicsThreadShowAllFuncDef,epicsThreadShowAllCallFunc);
+    iocshRegister(&epicsMutexShowAllFuncDef,epicsMutexShowAllCallFunc);
+    iocshRegister(&epicsThreadSleepFuncDef,epicsThreadSleepCallFunc);
 }
--- a/src/libCom/osi/os/RTEMS/rtems_init.c
+++ b/src/libCom/osi/os/RTEMS/rtems_init.c
@@ -25,7 +25,7 @@

 #include <epicsThread.h>
 #include <logClient.h>
-#include <ioccrf.h>
+#include <iocsh.h>
 #include <dbStaticLib.h>

 static void logReset (void);
@@ -152,22 +152,22 @@ rtems_netstat (unsigned int level)
    }
 }

-static const ioccrfArg netStatArg0 = { "level",ioccrfArgInt};
-static const ioccrfArg * const netStatArgs[1] = {&netStatArg0};
-static const ioccrfFuncDef netStatFuncDef = {"netstat",1,netStatArgs};
-static void netStatCallFunc(const ioccrfArgBuf *args)
+static const iocshArg netStatArg0 = { "level",iocshArgInt};
+static const iocshArg * const netStatArgs[1] = {&netStatArg0};
+static const iocshFuncDef netStatFuncDef = {"netstat",1,netStatArgs};
+static void netStatCallFunc(const iocshArgBuf *args)
 {
    rtems_netstat(args[0].ival);
 }
-static const ioccrfFuncDef stackCheckFuncDef = {"stackCheck",0,NULL};
-static void stackCheckCallFunc(const ioccrfArgBuf *args)
+static const iocshFuncDef stackCheckFuncDef = {"stackCheck",0,NULL};
+static void stackCheckCallFunc(const iocshArgBuf *args)
 {
    Stack_check_Dump_usage ();
 }
-static void ioccrfRegisterRTEMS (void)
+static void iocshRegisterRTEMS (void)
 {
-    ioccrfRegister(&netStatFuncDef, netStatCallFunc);
-    ioccrfRegister(&stackCheckFuncDef, stackCheckCallFunc);
+    iocshRegister(&netStatFuncDef, netStatCallFunc);
+    iocshRegister(&stackCheckFuncDef, stackCheckCallFunc);
 }

 /*
@@ -266,14 +266,14 @@ Init (rtems_task_argument ignored)
     * Run the EPICS startup script
     */
    printf ("***** Executing EPICS startup script *****\n");
-    ioccrfRegisterRTEMS ();
-    ioccrf ("st.cmd");
+    iocshRegisterRTEMS ();
+    iocsh ("st.cmd");

    /*
     * Everything's running!
     */
    epicsThreadSleep (2.0);
-    ioccrf (NULL);
+    iocsh (NULL);
    LogFatal ("Console command interpreter terminated");
 }

--- a/src/libCom/osi/os/default/epicsReadline.c
+++ b/src/libCom/osi/os/default/epicsReadline.c
@@ -1,4 +1,4 @@
-/* ioccrf.cpp */
+/* iocsh.cpp */
 /* Author:  Eric Norum Date: 12DEC2001 */

 #include <stdio.h>
--- a/src/makeBaseApp/top/exampleApp/src/exampleMain.c
+++ b/src/makeBaseApp/top/exampleApp/src/exampleMain.c
@@ -14,14 +14,14 @@ of this distribution.
 #include <stdio.h>

 #include "epicsThread.h"
-#include "ioccrf.h"
+#include "iocsh.h"

 int main(int argc,char *argv[])
 {
    if(argc>=2) {    
-        ioccrf(argv[1]);
+        iocsh(argv[1]);
        epicsThreadSleep(.2);
    }
-    ioccrf(NULL);
+    iocsh(NULL);
    return(0);
 }
--- a/src/registry/registerRecordDeviceDriver.pl
+++ b/src/registry/registerRecordDeviceDriver.pl
@@ -45,7 +45,7 @@ print << "END" ;
 #include "registryRecordType.h"
 #include "registryDeviceSupport.h"
 #include "registryDriverSupport.h"
-#include "ioccrf.h"
+#include "iocsh.h"
 END

 #definitions for recordtype
@@ -179,14 +179,14 @@ print << "END" ;
 }

 /* registerRecordDeviceDriver */
-static const ioccrfArg registerRecordDeviceDriverArg0 =
-                                            {"pdbbase",ioccrfArgPdbbase};
-static const ioccrfArg *registerRecordDeviceDriverArgs[1] =
+static const iocshArg registerRecordDeviceDriverArg0 =
+                                            {"pdbbase",iocshArgPdbbase};
+static const iocshArg *registerRecordDeviceDriverArgs[1] =
                                            {&registerRecordDeviceDriverArg0};
-static const ioccrfFuncDef registerRecordDeviceDriverFuncDef =
+static const iocshFuncDef registerRecordDeviceDriverFuncDef =
                {"registerRecordDeviceDriver",1,registerRecordDeviceDriverArgs};
 extern "C" {
-static void registerRecordDeviceDriverCallFunc(const ioccrfArgBuf *)
+static void registerRecordDeviceDriverCallFunc(const iocshArgBuf *)
 {
    registerRecordDeviceDriver(pdbbase);
 }
@@ -197,7 +197,7 @@ static void registerRecordDeviceDriverCallFunc(const ioccrfArgBuf *)
 */
 class IoccrfReg {
  public:
-    IoccrfReg() { ioccrfRegister(&registerRecordDeviceDriverFuncDef,registerRecordDeviceDriverCallFunc);}
+    IoccrfReg() { iocshRegister(&registerRecordDeviceDriverFuncDef,registerRecordDeviceDriverCallFunc);}
 };
-namespace { IoccrfReg ioccrfReg; }
+namespace { IoccrfReg iocshReg; }
 END