add static where appropriate

2000-05-03 13:12:58 +00:00
parent cff5d80b7c
commit 9eeeb258e6
7 changed files with 228 additions and 224 deletions
--- a/src/iocsh/asTestRegister.c
+++ b/src/iocsh/asTestRegister.c
@@ -18,71 +18,72 @@ of this distribution.
 #include "asTestRegister.h"

 /* asSetFilename */
-ioccrfArg asSetFilenameArg0 = { "ascf",ioccrfArgString,0};
-ioccrfArg *asSetFilenameArgs[1] = {&asSetFilenameArg0};
-ioccrfFuncDef asSetFilenameFuncDef = {"asSetFilename",1,asSetFilenameArgs};
-void asSetFilenameCallFunc(ioccrfArg **args)
+static ioccrfArg asSetFilenameArg0 = { "ascf",ioccrfArgString,0};
+static ioccrfArg *asSetFilenameArgs[1] = {&asSetFilenameArg0};
+static ioccrfFuncDef asSetFilenameFuncDef =
+    {"asSetFilename",1,asSetFilenameArgs};
+static void asSetFilenameCallFunc(ioccrfArg **args)
 {
    asSetFilename((char *)args[0]->value);
 }

 /* asSetSubstitutions */
-ioccrfArg asSetSubstitutionsArg0 = { "substitutions",ioccrfArgString,0};
-ioccrfArg *asSetSubstitutionsArgs[1] = {&asSetSubstitutionsArg0};
-ioccrfFuncDef asSetSubstitutionsFuncDef =
+static ioccrfArg asSetSubstitutionsArg0 = { "substitutions",ioccrfArgString,0};
+static ioccrfArg *asSetSubstitutionsArgs[1] = {&asSetSubstitutionsArg0};
+static ioccrfFuncDef asSetSubstitutionsFuncDef =
    {"asSetSubstitutions",1,asSetSubstitutionsArgs};
-void asSetSubstitutionsCallFunc(ioccrfArg **args)
+static void asSetSubstitutionsCallFunc(ioccrfArg **args)
 {
    asSetSubstitutions((char *)args[0]->value);
 }

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

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

 /* aspuag */
-ioccrfArg aspuagArg0 = { "uagname",ioccrfArgString,0};
-ioccrfArg *aspuagArgs[1] = {&aspuagArg0};
-ioccrfFuncDef aspuagFuncDef = {"aspuag",1,aspuagArgs};
-void aspuagCallFunc(ioccrfArg **args)
+static ioccrfArg aspuagArg0 = { "uagname",ioccrfArgString,0};
+static ioccrfArg *aspuagArgs[1] = {&aspuagArg0};
+static ioccrfFuncDef aspuagFuncDef = {"aspuag",1,aspuagArgs};
+static void aspuagCallFunc(ioccrfArg **args)
 {
    aspuag((char *)args[0]->value);
 }

 /* asphag */
-ioccrfArg asphagArg0 = { "hagname",ioccrfArgString,0};
-ioccrfArg *asphagArgs[1] = {&asphagArg0};
-ioccrfFuncDef asphagFuncDef = {"asphag",1,asphagArgs};
-void asphagCallFunc(ioccrfArg **args)
+static ioccrfArg asphagArg0 = { "hagname",ioccrfArgString,0};
+static ioccrfArg *asphagArgs[1] = {&asphagArg0};
+static ioccrfFuncDef asphagFuncDef = {"asphag",1,asphagArgs};
+static void asphagCallFunc(ioccrfArg **args)
 {
    asphag((char *)args[0]->value);
 }

 /* asprules */
-ioccrfArg asprulesArg0 = { "asgname",ioccrfArgString,0};
-ioccrfArg *asprulesArgs[1] = {&asprulesArg0};
-ioccrfFuncDef asprulesFuncDef = {"asprules",1,asprulesArgs};
-void asprulesCallFunc(ioccrfArg **args)
+static ioccrfArg asprulesArg0 = { "asgname",ioccrfArgString,0};
+static ioccrfArg *asprulesArgs[1] = {&asprulesArg0};
+static ioccrfFuncDef asprulesFuncDef = {"asprules",1,asprulesArgs};
+static void asprulesCallFunc(ioccrfArg **args)
 {
    asprules((char *)args[0]->value);
 }

 /* aspmem */
-ioccrfArg aspmemArg0 = { "asgname",ioccrfArgString,0};
-ioccrfArg aspmemArg1 = { "asgname",ioccrfArgInt,0};
-ioccrfArg *aspmemArgs[2] = {&aspmemArg0,&aspmemArg1};
-ioccrfFuncDef aspmemFuncDef = {"aspmem",2,aspmemArgs};
-void aspmemCallFunc(ioccrfArg **args)
+static ioccrfArg aspmemArg0 = { "asgname",ioccrfArgString,0};
+static ioccrfArg aspmemArg1 = { "asgname",ioccrfArgInt,0};
+static ioccrfArg *aspmemArgs[2] = {&aspmemArg0,&aspmemArg1};
+static ioccrfFuncDef aspmemFuncDef = {"aspmem",2,aspmemArgs};
+static void aspmemCallFunc(ioccrfArg **args)
 {
    aspmem((char *)args[0]->value,*(int *)args[1]->value);
 }
--- a/src/iocsh/caTestRegister.c
+++ b/src/iocsh/caTestRegister.c
@@ -19,20 +19,20 @@ of this distribution.
 #include "caTestRegister.h"

 /* casr */
-ioccrfArg casrArg0 = { "level",ioccrfArgInt,0};
-ioccrfArg *casrArgs[1] = {&casrArg0};
-ioccrfFuncDef casrFuncDef = {"casr",1,casrArgs};
-void casrCallFunc(ioccrfArg **args)
+static ioccrfArg casrArg0 = { "level",ioccrfArgInt,0};
+static ioccrfArg *casrArgs[1] = {&casrArg0};
+static ioccrfFuncDef casrFuncDef = {"casr",1,casrArgs};
+static void casrCallFunc(ioccrfArg **args)
 {
    casr(*(int *)args[0]->value);
 }

 /* dbel */
-ioccrfArg dbelArg0 = { "record name",ioccrfArgString,0};
-ioccrfArg dbelArg1 = { "level",ioccrfArgInt,0};
-ioccrfArg *dbelArgs[2] = {&dbelArg0,&dbelArg1};
-ioccrfFuncDef dbelFuncDef = {"dbel",2,dbelArgs};
-void dbelCallFunc(ioccrfArg **args)
+static ioccrfArg dbelArg0 = { "record name",ioccrfArgString,0};
+static ioccrfArg dbelArg1 = { "level",ioccrfArgInt,0};
+static ioccrfArg *dbelArgs[2] = {&dbelArg0,&dbelArg1};
+static ioccrfFuncDef dbelFuncDef = {"dbel",2,dbelArgs};
+static void dbelCallFunc(ioccrfArg **args)
 {
    dbel((char *)args[0]->value, *(int *)args[1]->value);
 }
--- a/src/iocsh/dbAccessRegister.c
+++ b/src/iocsh/dbAccessRegister.c
@@ -20,53 +20,56 @@ of this distribution.
 #include "dbAccessRegister.h"

 /* dbLoadDatabase */
-ioccrfArg dbLoadDatabaseArg0 = { "file name",ioccrfArgString,0};
-ioccrfArg dbLoadDatabaseArg1 = { "path",ioccrfArgString,0};
-ioccrfArg dbLoadDatabaseArg2 = { "substitutions",ioccrfArgString,0};
-ioccrfArg *dbLoadDatabaseArgs[3] =
+static ioccrfArg dbLoadDatabaseArg0 = { "file name",ioccrfArgString,0};
+static ioccrfArg dbLoadDatabaseArg1 = { "path",ioccrfArgString,0};
+static ioccrfArg dbLoadDatabaseArg2 = { "substitutions",ioccrfArgString,0};
+static ioccrfArg *dbLoadDatabaseArgs[3] =
 {
    &dbLoadDatabaseArg0,&dbLoadDatabaseArg1,&dbLoadDatabaseArg2
 };
-ioccrfFuncDef dbLoadDatabaseFuncDef = {"dbLoadDatabase",3,dbLoadDatabaseArgs};
-void dbLoadDatabaseCallFunc(ioccrfArg **args)
+static ioccrfFuncDef dbLoadDatabaseFuncDef =
+    {"dbLoadDatabase",3,dbLoadDatabaseArgs};
+static void dbLoadDatabaseCallFunc(ioccrfArg **args)
 {
    dbLoadDatabase(
        (char *)args[0]->value,(char *)args[1]->value,(char *)args[2]->value);
 }

 /* dbLoadRecords */
-ioccrfArg dbLoadRecordsArg0 = { "file name",ioccrfArgString,0};
-ioccrfArg dbLoadRecordsArg1 = { "substitutions",ioccrfArgString,0};
-ioccrfArg *dbLoadRecordsArgs[2] = {&dbLoadRecordsArg0,&dbLoadRecordsArg1};
-ioccrfFuncDef dbLoadRecordsFuncDef = {"dbLoadRecords",2,dbLoadRecordsArgs};
-void dbLoadRecordsCallFunc(ioccrfArg **args)
+static ioccrfArg dbLoadRecordsArg0 = { "file name",ioccrfArgString,0};
+static ioccrfArg dbLoadRecordsArg1 = { "substitutions",ioccrfArgString,0};
+static ioccrfArg *dbLoadRecordsArgs[2] = {&dbLoadRecordsArg0,&dbLoadRecordsArg1};
+static ioccrfFuncDef dbLoadRecordsFuncDef = {"dbLoadRecords",2,dbLoadRecordsArgs};
+static void dbLoadRecordsCallFunc(ioccrfArg **args)
 {
    dbLoadRecords((char *)args[0]->value,(char *)args[1]->value);
 }

 /* dbLoadTemplate */
-ioccrfArg dbLoadTemplateArg0 = { "file name",ioccrfArgString,0};
-ioccrfArg *dbLoadTemplateArgs[1] = {&dbLoadTemplateArg0};
-ioccrfFuncDef dbLoadTemplateFuncDef = {"dbLoadTemplate",1,dbLoadTemplateArgs};
-void dbLoadTemplateCallFunc(ioccrfArg **args)
+static ioccrfArg dbLoadTemplateArg0 = { "file name",ioccrfArgString,0};
+static ioccrfArg *dbLoadTemplateArgs[1] = {&dbLoadTemplateArg0};
+static ioccrfFuncDef dbLoadTemplateFuncDef =
+    {"dbLoadTemplate",1,dbLoadTemplateArgs};
+static void dbLoadTemplateCallFunc(ioccrfArg **args)
 {
    dbLoadTemplate((char *)args[0]->value);
 }

 /* registerRecordDeviceDriver */
-ioccrfArg registerRecordDeviceDriverArg0 = { "pdbbase",ioccrfArgPdbbase,0};
-ioccrfArg *registerRecordDeviceDriverArgs[1] = {&registerRecordDeviceDriverArg0};
-ioccrfFuncDef registerRecordDeviceDriverFuncDef =
+static ioccrfArg registerRecordDeviceDriverArg0 = { "pdbbase",ioccrfArgPdbbase,0};
+static ioccrfArg *registerRecordDeviceDriverArgs[1] =
+    {&registerRecordDeviceDriverArg0};
+static ioccrfFuncDef registerRecordDeviceDriverFuncDef =
    {"registerRecordDeviceDriver",1,registerRecordDeviceDriverArgs};
-void registerRecordDeviceDriverCallFunc(ioccrfArg **args)
+static void registerRecordDeviceDriverCallFunc(ioccrfArg **args)
 {
    registerRecordDeviceDriver(pdbbase);
 }

 /* iocInit */
-ioccrfFuncDef iocInitFuncDef =
+static ioccrfFuncDef iocInitFuncDef =
    {"iocInit",0,0};
-void iocInitCallFunc(ioccrfArg **args)
+static void iocInitCallFunc(ioccrfArg **args)
 {
    iocInit();
 }
--- a/src/iocsh/dbBkptRegister.c
+++ b/src/iocsh/dbBkptRegister.c
@@ -28,45 +28,45 @@ of this distribution.
 #include "dbBkptRegister.h"

 /* dbb */
-ioccrfArg dbbArg0 = { "record name",ioccrfArgString,0};
-ioccrfArg *dbbArgs[1] = {&dbbArg0};
-ioccrfFuncDef dbbFuncDef = {"dbb",1,dbbArgs};
-void dbbCallFunc(ioccrfArg **args) { dbb((char *)args[0]->value);}
+static ioccrfArg dbbArg0 = { "record name",ioccrfArgString,0};
+static ioccrfArg *dbbArgs[1] = {&dbbArg0};
+static ioccrfFuncDef dbbFuncDef = {"dbb",1,dbbArgs};
+static void dbbCallFunc(ioccrfArg **args) { dbb((char *)args[0]->value);}

 /* dbd */
-ioccrfArg dbdArg0 = { "record name",ioccrfArgString,0};
-ioccrfArg *dbdArgs[1] = {&dbdArg0};
-ioccrfFuncDef dbdFuncDef = {"dbd",1,dbdArgs};
-void dbdCallFunc(ioccrfArg **args) { dbd((char *)args[0]->value);}
+static ioccrfArg dbdArg0 = { "record name",ioccrfArgString,0};
+static ioccrfArg *dbdArgs[1] = {&dbdArg0};
+static ioccrfFuncDef dbdFuncDef = {"dbd",1,dbdArgs};
+static void dbdCallFunc(ioccrfArg **args) { dbd((char *)args[0]->value);}

 /* dbc */
-ioccrfArg dbcArg0 = { "record name",ioccrfArgString,0};
-ioccrfArg *dbcArgs[1] = {&dbcArg0};
-ioccrfFuncDef dbcFuncDef = {"dbc",1,dbcArgs};
-void dbcCallFunc(ioccrfArg **args) { dbc((char *)args[0]->value);}
+static ioccrfArg dbcArg0 = { "record name",ioccrfArgString,0};
+static ioccrfArg *dbcArgs[1] = {&dbcArg0};
+static ioccrfFuncDef dbcFuncDef = {"dbc",1,dbcArgs};
+static void dbcCallFunc(ioccrfArg **args) { dbc((char *)args[0]->value);}

 /* dbs */
-ioccrfArg dbsArg0 = { "record name",ioccrfArgString,0};
-ioccrfArg *dbsArgs[1] = {&dbsArg0};
-ioccrfFuncDef dbsFuncDef = {"dbs",1,dbsArgs};
-void dbsCallFunc(ioccrfArg **args) { dbs((char *)args[0]->value);}
+static ioccrfArg dbsArg0 = { "record name",ioccrfArgString,0};
+static ioccrfArg *dbsArgs[1] = {&dbsArg0};
+static ioccrfFuncDef dbsFuncDef = {"dbs",1,dbsArgs};
+static void dbsCallFunc(ioccrfArg **args) { dbs((char *)args[0]->value);}

-ioccrfFuncDef dbstatFuncDef = {"dbstat",0,0};
-void dbstatCallFunc(ioccrfArg **args) { dbstat();}
+static ioccrfFuncDef dbstatFuncDef = {"dbstat",0,0};
+static void dbstatCallFunc(ioccrfArg **args) { dbstat();}

 /* dbp */
-ioccrfArg dbpArg0 = { "record name",ioccrfArgString,0};
-ioccrfArg dbpArg1 = { "interest_level",ioccrfArgInt,0};
-ioccrfArg *dbpArgs[2] = {&dbpArg0,&dbpArg1};
-ioccrfFuncDef dbpFuncDef = {"dbp",2,dbpArgs};
-void dbpCallFunc(ioccrfArg **args)
+static ioccrfArg dbpArg0 = { "record name",ioccrfArgString,0};
+static ioccrfArg dbpArg1 = { "interest_level",ioccrfArgInt,0};
+static ioccrfArg *dbpArgs[2] = {&dbpArg0,&dbpArg1};
+static ioccrfFuncDef dbpFuncDef = {"dbp",2,dbpArgs};
+static void dbpCallFunc(ioccrfArg **args)
 { dbp((char *)args[0]->value,*(int *)args[1]->value);}

 /* dbap */
-ioccrfArg dbapArg0 = { "record name",ioccrfArgString,0};
-ioccrfArg *dbapArgs[1] = {&dbapArg0};
-ioccrfFuncDef dbapFuncDef = {"dbap",1,dbapArgs};
-void dbapCallFunc(ioccrfArg **args) { dbap((char *)args[0]->value);}
+static ioccrfArg dbapArg0 = { "record name",ioccrfArgString,0};
+static ioccrfArg *dbapArgs[1] = {&dbapArg0};
+static ioccrfFuncDef dbapFuncDef = {"dbap",1,dbapArgs};
+static void dbapCallFunc(ioccrfArg **args) { dbap((char *)args[0]->value);}

 void epicsShareAPI dbBkptRegister(void)
 {
--- a/src/iocsh/dbCaTestRegister.c
+++ b/src/iocsh/dbCaTestRegister.c
@@ -18,11 +18,11 @@ of this distribution.
 #include "dbCaTestRegister.h"

 /* dbcar */
-ioccrfArg dbcarArg0 = { "record name",ioccrfArgString,0};
-ioccrfArg dbcarArg1 = { "level",ioccrfArgInt,0};
-ioccrfArg *dbcarArgs[2] = {&dbcarArg0,&dbcarArg1};
-ioccrfFuncDef dbcarFuncDef = {"dbcar",2,dbcarArgs};
-void dbcarCallFunc(ioccrfArg **args)
+static ioccrfArg dbcarArg0 = { "record name",ioccrfArgString,0};
+static ioccrfArg dbcarArg1 = { "level",ioccrfArgInt,0};
+static ioccrfArg *dbcarArgs[2] = {&dbcarArg0,&dbcarArg1};
+static ioccrfFuncDef dbcarFuncDef = {"dbcar",2,dbcarArgs};
+static void dbcarCallFunc(ioccrfArg **args)
 {
    dbcar((char *)args[0]->value,*(int *)args[1]->value);
 }
--- a/src/iocsh/dbStaticRegister.c
+++ b/src/iocsh/dbStaticRegister.c
@@ -20,107 +20,107 @@ of this distribution.
 #include "dbStaticRegister.h"

 /* dbDumpRecDes */
-ioccrfArg dbDumpRecDesArg0 = { "pdbbase",ioccrfArgPdbbase,0};
-ioccrfArg dbDumpRecDesArg1 = { "recordTypeName",ioccrfArgString,0};
-ioccrfArg *dbDumpRecDesArgs[2] = {&dbDumpRecDesArg0,&dbDumpRecDesArg1};
-ioccrfFuncDef dbDumpRecDesFuncDef = {"dbDumpRecDes",2,dbDumpRecDesArgs};
-void dbDumpRecDesCallFunc(ioccrfArg **args)
+static ioccrfArg dbDumpRecDesArg0 = { "pdbbase",ioccrfArgPdbbase,0};
+static ioccrfArg dbDumpRecDesArg1 = { "recordTypeName",ioccrfArgString,0};
+static ioccrfArg *dbDumpRecDesArgs[2] = {&dbDumpRecDesArg0,&dbDumpRecDesArg1};
+static ioccrfFuncDef dbDumpRecDesFuncDef = {"dbDumpRecDes",2,dbDumpRecDesArgs};
+static void dbDumpRecDesCallFunc(ioccrfArg **args)
 {
    dbDumpRecDes(pdbbase,(char *)args[1]->value);
 }

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

 /* dbDumpRecord */
-ioccrfArg dbDumpRecordArg0 = { "pdbbase",ioccrfArgPdbbase,0};
-ioccrfArg dbDumpRecordArg1 = { "recordTypeName",ioccrfArgString,0};
-ioccrfArg dbDumpRecordArg2 = { "interest_level",ioccrfArgInt,0};
-ioccrfArg *dbDumpRecordArgs[3] =
+static ioccrfArg dbDumpRecordArg0 = { "pdbbase",ioccrfArgPdbbase,0};
+static ioccrfArg dbDumpRecordArg1 = { "recordTypeName",ioccrfArgString,0};
+static ioccrfArg dbDumpRecordArg2 = { "interest_level",ioccrfArgInt,0};
+static ioccrfArg *dbDumpRecordArgs[3] =
    {&dbDumpRecordArg0,&dbDumpRecordArg1,&dbDumpRecordArg2};
-ioccrfFuncDef dbDumpRecordFuncDef = {"dbDumpRecord",3,dbDumpRecordArgs};
-void dbDumpRecordCallFunc(ioccrfArg **args)
+static ioccrfFuncDef dbDumpRecordFuncDef = {"dbDumpRecord",3,dbDumpRecordArgs};
+static void dbDumpRecordCallFunc(ioccrfArg **args)
 {
    dbDumpRecord(pdbbase,(char *)args[1]->value,*(int *)args[2]->value);
 }

 /* dbDumpMenu */
-ioccrfArg dbDumpMenuArg0 = { "pdbbase",ioccrfArgPdbbase,0};
-ioccrfArg dbDumpMenuArg1 = { "menuName",ioccrfArgString,0};
-ioccrfArg *dbDumpMenuArgs[2] = {&dbDumpMenuArg0,&dbDumpMenuArg1};
-ioccrfFuncDef dbDumpMenuFuncDef = {"dbDumpMenu",2,dbDumpMenuArgs};
-void dbDumpMenuCallFunc(ioccrfArg **args)
+static ioccrfArg dbDumpMenuArg0 = { "pdbbase",ioccrfArgPdbbase,0};
+static ioccrfArg dbDumpMenuArg1 = { "menuName",ioccrfArgString,0};
+static ioccrfArg *dbDumpMenuArgs[2] = {&dbDumpMenuArg0,&dbDumpMenuArg1};
+static ioccrfFuncDef dbDumpMenuFuncDef = {"dbDumpMenu",2,dbDumpMenuArgs};
+static void dbDumpMenuCallFunc(ioccrfArg **args)
 {
    dbDumpMenu(pdbbase,(char *)args[1]->value);
 }

 /* dbDumpRecordType */
-ioccrfArg dbDumpRecordTypeArg0 = { "pdbbase",ioccrfArgPdbbase,0};
-ioccrfArg dbDumpRecordTypeArg1 = { "recordTypeName",ioccrfArgString,0};
-ioccrfArg *dbDumpRecordTypeArgs[2] =
+static ioccrfArg dbDumpRecordTypeArg0 = { "pdbbase",ioccrfArgPdbbase,0};
+static ioccrfArg dbDumpRecordTypeArg1 = { "recordTypeName",ioccrfArgString,0};
+static ioccrfArg *dbDumpRecordTypeArgs[2] =
    {&dbDumpRecordTypeArg0,&dbDumpRecordTypeArg1};
-ioccrfFuncDef dbDumpRecordTypeFuncDef =
+static ioccrfFuncDef dbDumpRecordTypeFuncDef =
    {"dbDumpRecordType",2,dbDumpRecordTypeArgs};
-void dbDumpRecordTypeCallFunc(ioccrfArg **args)
+static void dbDumpRecordTypeCallFunc(ioccrfArg **args)
 {
    dbDumpRecordType(pdbbase,(char *)args[1]->value);
 }

 /* dbDumpFldDes */
-ioccrfArg dbDumpFldDesArg0 = { "pdbbase",ioccrfArgPdbbase,0};
-ioccrfArg dbDumpFldDesArg1 = { "recordTypeName",ioccrfArgString,0};
-ioccrfArg dbDumpFldDesArg2 = { "fieldName",ioccrfArgString,0};
-ioccrfArg *dbDumpFldDesArgs[3] =
+static ioccrfArg dbDumpFldDesArg0 = { "pdbbase",ioccrfArgPdbbase,0};
+static ioccrfArg dbDumpFldDesArg1 = { "recordTypeName",ioccrfArgString,0};
+static ioccrfArg dbDumpFldDesArg2 = { "fieldName",ioccrfArgString,0};
+static ioccrfArg *dbDumpFldDesArgs[3] =
    {&dbDumpFldDesArg0,&dbDumpFldDesArg1,&dbDumpFldDesArg2};
-ioccrfFuncDef dbDumpFldDesFuncDef = {"dbDumpFldDes",3,dbDumpFldDesArgs};
-void dbDumpFldDesCallFunc(ioccrfArg **args)
+static ioccrfFuncDef dbDumpFldDesFuncDef = {"dbDumpFldDes",3,dbDumpFldDesArgs};
+static void dbDumpFldDesCallFunc(ioccrfArg **args)
 {
    dbDumpFldDes(pdbbase,(char *)args[1]->value,(char *)args[2]->value);
 }

 /* dbDumpDevice */
-ioccrfArg dbDumpDeviceArg0 = { "pdbbase",ioccrfArgPdbbase,0};
-ioccrfArg dbDumpDeviceArg1 = { "recordTypeName",ioccrfArgString,0};
-ioccrfArg *dbDumpDeviceArgs[2] = {&dbDumpDeviceArg0,&dbDumpDeviceArg1};
-ioccrfFuncDef dbDumpDeviceFuncDef = {"dbDumpDevice",2,dbDumpDeviceArgs};
-void dbDumpDeviceCallFunc(ioccrfArg **args)
+static ioccrfArg dbDumpDeviceArg0 = { "pdbbase",ioccrfArgPdbbase,0};
+static ioccrfArg dbDumpDeviceArg1 = { "recordTypeName",ioccrfArgString,0};
+static ioccrfArg *dbDumpDeviceArgs[2] = {&dbDumpDeviceArg0,&dbDumpDeviceArg1};
+static ioccrfFuncDef dbDumpDeviceFuncDef = {"dbDumpDevice",2,dbDumpDeviceArgs};
+static void dbDumpDeviceCallFunc(ioccrfArg **args)
 {
    dbDumpDevice(pdbbase,(char *)args[1]->value);
 }

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

 /* dbDumpBreaktable */
-ioccrfArg dbDumpBreaktableArg0 = { "pdbbase",ioccrfArgPdbbase,0};
-ioccrfArg dbDumpBreaktableArg1 = { "tableName",ioccrfArgString,0};
-ioccrfArg *dbDumpBreaktableArgs[2] =
+static ioccrfArg dbDumpBreaktableArg0 = { "pdbbase",ioccrfArgPdbbase,0};
+static ioccrfArg dbDumpBreaktableArg1 = { "tableName",ioccrfArgString,0};
+static ioccrfArg *dbDumpBreaktableArgs[2] =
    {&dbDumpBreaktableArg0,&dbDumpBreaktableArg1};
-ioccrfFuncDef dbDumpBreaktableFuncDef =
+static ioccrfFuncDef dbDumpBreaktableFuncDef =
    {"dbDumpBreaktable",2,dbDumpBreaktableArgs};
-void dbDumpBreaktableCallFunc(ioccrfArg **args)
+static void dbDumpBreaktableCallFunc(ioccrfArg **args)
 {
    dbDumpBreaktable(pdbbase,(char *)args[1]->value);
 }

 /* dbPvdDump */
-ioccrfArg dbPvdDumpArg0 = { "pdbbase",ioccrfArgPdbbase,0};
-ioccrfArg dbPvdDumpArg1 = { "verbose",ioccrfArgInt,0};
-ioccrfArg *dbPvdDumpArgs[2] = {&dbPvdDumpArg0,&dbPvdDumpArg1};
-ioccrfFuncDef dbPvdDumpFuncDef = {"dbPvdDump",2,dbPvdDumpArgs};
-void dbPvdDumpCallFunc(ioccrfArg **args)
+static ioccrfArg dbPvdDumpArg0 = { "pdbbase",ioccrfArgPdbbase,0};
+static ioccrfArg dbPvdDumpArg1 = { "verbose",ioccrfArgInt,0};
+static ioccrfArg *dbPvdDumpArgs[2] = {&dbPvdDumpArg0,&dbPvdDumpArg1};
+static ioccrfFuncDef dbPvdDumpFuncDef = {"dbPvdDump",2,dbPvdDumpArgs};
+static void dbPvdDumpCallFunc(ioccrfArg **args)
 {
    dbPvdDump(pdbbase,*(int *)args[1]->value);
 }
--- a/src/iocsh/dbTestRegister.c
+++ b/src/iocsh/dbTestRegister.c
@@ -21,137 +21,137 @@ of this distribution.
 #include "dbTestRegister.h"

 /* dba */
-ioccrfArg dbaArg0 = { "record name",ioccrfArgString,0};
-ioccrfArg *dbaArgs[1] = {&dbaArg0};
-ioccrfFuncDef dbaFuncDef = {"dba",1,dbaArgs};
-void dbaCallFunc(ioccrfArg **args) { dba((char *)args[0]->value);}
+static ioccrfArg dbaArg0 = { "record name",ioccrfArgString,0};
+static ioccrfArg *dbaArgs[1] = {&dbaArg0};
+static ioccrfFuncDef dbaFuncDef = {"dba",1,dbaArgs};
+static void dbaCallFunc(ioccrfArg **args) { dba((char *)args[0]->value);}

 /* dbl */
-ioccrfArg dblArg0 = { "record type",ioccrfArgString,0};
-ioccrfArg dblArg1 = { "output file",ioccrfArgString,0};
-ioccrfArg dblArg2 = { "fields",ioccrfArgString,0};
-ioccrfArg *dblArgs[3] = {&dblArg0,&dblArg1,&dblArg2};
-ioccrfFuncDef dblFuncDef = {"dbl",3,dblArgs};
-void dblCallFunc(ioccrfArg **args)
+static ioccrfArg dblArg0 = { "record type",ioccrfArgString,0};
+static ioccrfArg dblArg1 = { "output file",ioccrfArgString,0};
+static ioccrfArg dblArg2 = { "fields",ioccrfArgString,0};
+static ioccrfArg *dblArgs[3] = {&dblArg0,&dblArg1,&dblArg2};
+static ioccrfFuncDef dblFuncDef = {"dbl",3,dblArgs};
+static void dblCallFunc(ioccrfArg **args)
 {
    dbl((char *)args[0]->value,(char *)args[1]->value,(char *)args[2]->value);
 }

 /* dbnr */
-ioccrfArg dbnrArg0 = { "verbose",ioccrfArgInt,0};
-ioccrfArg *dbnrArgs[1] = {&dbnrArg0};
-ioccrfFuncDef dbnrFuncDef = {"dbnr",1,dbnrArgs};
-void dbnrCallFunc(ioccrfArg **args) { dbnr(*(int *)args[0]->value);}
+static ioccrfArg dbnrArg0 = { "verbose",ioccrfArgInt,0};
+static ioccrfArg *dbnrArgs[1] = {&dbnrArg0};
+static ioccrfFuncDef dbnrFuncDef = {"dbnr",1,dbnrArgs};
+static void dbnrCallFunc(ioccrfArg **args) { dbnr(*(int *)args[0]->value);}

 /* dbgrep */
-ioccrfArg dbgrepArg0 = { "record name",ioccrfArgString,0};
-ioccrfArg *dbgrepArgs[1] = {&dbgrepArg0};
-ioccrfFuncDef dbgrepFuncDef = {"dbgrep",1,dbgrepArgs};
-void dbgrepCallFunc(ioccrfArg **args) { dbgrep((char *)args[0]->value);}
+static ioccrfArg dbgrepArg0 = { "record name",ioccrfArgString,0};
+static ioccrfArg *dbgrepArgs[1] = {&dbgrepArg0};
+static ioccrfFuncDef dbgrepFuncDef = {"dbgrep",1,dbgrepArgs};
+static void dbgrepCallFunc(ioccrfArg **args) { dbgrep((char *)args[0]->value);}

 /* dbgf */
-ioccrfArg dbgfArg0 = { "record name",ioccrfArgString,0};
-ioccrfArg *dbgfArgs[1] = {&dbgfArg0};
-ioccrfFuncDef dbgfFuncDef = {"dbgf",1,dbgfArgs};
-void dbgfCallFunc(ioccrfArg **args) { dbgf((char *)args[0]->value);}
+static ioccrfArg dbgfArg0 = { "record name",ioccrfArgString,0};
+static ioccrfArg *dbgfArgs[1] = {&dbgfArg0};
+static ioccrfFuncDef dbgfFuncDef = {"dbgf",1,dbgfArgs};
+static void dbgfCallFunc(ioccrfArg **args) { dbgf((char *)args[0]->value);}

 /* dbpf */
-ioccrfArg dbpfArg0 = { "record name",ioccrfArgString,0};
-ioccrfArg dbpfArg1 = { "value",ioccrfArgString,0};
-ioccrfArg *dbpfArgs[2] = {&dbpfArg0,&dbpfArg1};
-ioccrfFuncDef dbpfFuncDef = {"dbpf",2,dbpfArgs};
-void dbpfCallFunc(ioccrfArg **args)
+static ioccrfArg dbpfArg0 = { "record name",ioccrfArgString,0};
+static ioccrfArg dbpfArg1 = { "value",ioccrfArgString,0};
+static ioccrfArg *dbpfArgs[2] = {&dbpfArg0,&dbpfArg1};
+static ioccrfFuncDef dbpfFuncDef = {"dbpf",2,dbpfArgs};
+static void dbpfCallFunc(ioccrfArg **args)
 { dbpf((char *)args[0]->value,(char *)args[1]->value);}

 /* dbpr */
-ioccrfArg dbprArg0 = { "record name",ioccrfArgString,0};
-ioccrfArg dbprArg1 = { "interest_level",ioccrfArgInt,0};
-ioccrfArg *dbprArgs[2] = {&dbprArg0,&dbprArg1};
-ioccrfFuncDef dbprFuncDef = {"dbpr",2,dbprArgs};
-void dbprCallFunc(ioccrfArg **args)
+static ioccrfArg dbprArg0 = { "record name",ioccrfArgString,0};
+static ioccrfArg dbprArg1 = { "interest_level",ioccrfArgInt,0};
+static ioccrfArg *dbprArgs[2] = {&dbprArg0,&dbprArg1};
+static ioccrfFuncDef dbprFuncDef = {"dbpr",2,dbprArgs};
+static void dbprCallFunc(ioccrfArg **args)
 { dbpr((char *)args[0]->value,*(int *)args[1]->value);}

 /* dbtr */
-ioccrfArg dbtrArg0 = { "record name",ioccrfArgString,0};
-ioccrfArg *dbtrArgs[1] = {&dbtrArg0};
-ioccrfFuncDef dbtrFuncDef = {"dbtr",1,dbtrArgs};
-void dbtrCallFunc(ioccrfArg **args) { dbtr((char *)args[0]->value);}
+static ioccrfArg dbtrArg0 = { "record name",ioccrfArgString,0};
+static ioccrfArg *dbtrArgs[1] = {&dbtrArg0};
+static ioccrfFuncDef dbtrFuncDef = {"dbtr",1,dbtrArgs};
+static void dbtrCallFunc(ioccrfArg **args) { dbtr((char *)args[0]->value);}

 /* dbtgf */
-ioccrfArg dbtgfArg0 = { "record name",ioccrfArgString,0};
-ioccrfArg *dbtgfArgs[1] = {&dbtgfArg0};
-ioccrfFuncDef dbtgfFuncDef = {"dbtgf",1,dbtgfArgs};
-void dbtgfCallFunc(ioccrfArg **args) { dbtgf((char *)args[0]->value);}
+static ioccrfArg dbtgfArg0 = { "record name",ioccrfArgString,0};
+static ioccrfArg *dbtgfArgs[1] = {&dbtgfArg0};
+static ioccrfFuncDef dbtgfFuncDef = {"dbtgf",1,dbtgfArgs};
+static void dbtgfCallFunc(ioccrfArg **args) { dbtgf((char *)args[0]->value);}

 /* dbtpf */
-ioccrfArg dbtpfArg0 = { "record name",ioccrfArgString,0};
-ioccrfArg dbtpfArg1 = { "value",ioccrfArgString,0};
-ioccrfArg *dbtpfArgs[2] = {&dbtpfArg0,&dbtpfArg1};
-ioccrfFuncDef dbtpfFuncDef = {"dbtpf",2,dbtpfArgs};
-void dbtpfCallFunc(ioccrfArg **args)
+static ioccrfArg dbtpfArg0 = { "record name",ioccrfArgString,0};
+static ioccrfArg dbtpfArg1 = { "value",ioccrfArgString,0};
+static ioccrfArg *dbtpfArgs[2] = {&dbtpfArg0,&dbtpfArg1};
+static ioccrfFuncDef dbtpfFuncDef = {"dbtpf",2,dbtpfArgs};
+static void dbtpfCallFunc(ioccrfArg **args)
 { dbtpf((char *)args[0]->value,(char *)args[1]->value);}

 /* dbior */
-ioccrfArg dbiorArg0 = { "record name",ioccrfArgString,0};
-ioccrfArg dbiorArg1 = { "interest_level",ioccrfArgInt,0};
-ioccrfArg *dbiorArgs[2] = {&dbiorArg0,&dbiorArg1};
-ioccrfFuncDef dbiorFuncDef = {"dbior",2,dbiorArgs};
-void dbiorCallFunc(ioccrfArg **args)
+static ioccrfArg dbiorArg0 = { "record name",ioccrfArgString,0};
+static ioccrfArg dbiorArg1 = { "interest_level",ioccrfArgInt,0};
+static ioccrfArg *dbiorArgs[2] = {&dbiorArg0,&dbiorArg1};
+static ioccrfFuncDef dbiorFuncDef = {"dbior",2,dbiorArgs};
+static void dbiorCallFunc(ioccrfArg **args)
 { dbior((char *)args[0]->value,*(int *)args[1]->value);}

 /* dbhcr */
-ioccrfArg dbhcrArg0 = { "filename",ioccrfArgString,0};
-ioccrfArg *dbhcrArgs[1] = {&dbhcrArg0};
-ioccrfFuncDef dbhcrFuncDef = {"dbhcr",1,dbhcrArgs};
-void dbhcrCallFunc(ioccrfArg **args) { dbhcr((char *)args[0]->value);}
+static ioccrfArg dbhcrArg0 = { "filename",ioccrfArgString,0};
+static ioccrfArg *dbhcrArgs[1] = {&dbhcrArg0};
+static ioccrfFuncDef dbhcrFuncDef = {"dbhcr",1,dbhcrArgs};
+static void dbhcrCallFunc(ioccrfArg **args) { dbhcr((char *)args[0]->value);}

 /* gft */
-ioccrfArg gftArg0 = { "record name",ioccrfArgString,0};
-ioccrfArg *gftArgs[1] = {&gftArg0};
-ioccrfFuncDef gftFuncDef = {"gft",1,gftArgs};
-void gftCallFunc(ioccrfArg **args) { gft((char *)args[0]->value);}
+static ioccrfArg gftArg0 = { "record name",ioccrfArgString,0};
+static ioccrfArg *gftArgs[1] = {&gftArg0};
+static ioccrfFuncDef gftFuncDef = {"gft",1,gftArgs};
+static void gftCallFunc(ioccrfArg **args) { gft((char *)args[0]->value);}

 /* pft */
-ioccrfArg pftArg0 = { "record name",ioccrfArgString,0};
-ioccrfArg pftArg1 = { "value",ioccrfArgString,0};
-ioccrfArg *pftArgs[2] = {&pftArg0,&pftArg1};
-ioccrfFuncDef pftFuncDef = {"pft",2,pftArgs};
-void pftCallFunc(ioccrfArg **args)
+static ioccrfArg pftArg0 = { "record name",ioccrfArgString,0};
+static ioccrfArg pftArg1 = { "value",ioccrfArgString,0};
+static ioccrfArg *pftArgs[2] = {&pftArg0,&pftArg1};
+static ioccrfFuncDef pftFuncDef = {"pft",2,pftArgs};
+static void pftCallFunc(ioccrfArg **args)
 { pft((char *)args[0]->value,(char *)args[1]->value);}

 /* tpn */
-ioccrfArg tpnArg0 = { "record name",ioccrfArgString,0};
-ioccrfArg tpnArg1 = { "value",ioccrfArgString,0};
-ioccrfArg *tpnArgs[2] = {&tpnArg0,&tpnArg1};
-ioccrfFuncDef tpnFuncDef = {"tpn",2,tpnArgs};
-void tpnCallFunc(ioccrfArg **args)
+static ioccrfArg tpnArg0 = { "record name",ioccrfArgString,0};
+static ioccrfArg tpnArg1 = { "value",ioccrfArgString,0};
+static ioccrfArg *tpnArgs[2] = {&tpnArg0,&tpnArg1};
+static ioccrfFuncDef tpnFuncDef = {"tpn",2,tpnArgs};
+static void tpnCallFunc(ioccrfArg **args)
 { tpn((char *)args[0]->value,(char *)args[1]->value);}

 /* dblsr */
-ioccrfArg dblsrArg0 = { "record name",ioccrfArgString,0};
-ioccrfArg dblsrArg1 = { "interest_level",ioccrfArgInt,0};
-ioccrfArg *dblsrArgs[2] = {&dblsrArg0,&dblsrArg1};
-ioccrfFuncDef dblsrFuncDef = {"dblsr",2,dblsrArgs};
-void dblsrCallFunc(ioccrfArg **args)
+static ioccrfArg dblsrArg0 = { "record name",ioccrfArgString,0};
+static ioccrfArg dblsrArg1 = { "interest_level",ioccrfArgInt,0};
+static ioccrfArg *dblsrArgs[2] = {&dblsrArg0,&dblsrArg1};
+static ioccrfFuncDef dblsrFuncDef = {"dblsr",2,dblsrArgs};
+static void dblsrCallFunc(ioccrfArg **args)
 { dblsr((char *)args[0]->value,*(int *)args[1]->value);}

 /* scanppl */
-ioccrfArg scanpplArg0 = { "rate",ioccrfArgDouble,0};
-ioccrfArg *scanpplArgs[1] = {&scanpplArg0};
-ioccrfFuncDef scanpplFuncDef = {"scanppl",1,scanpplArgs};
-void scanpplCallFunc(ioccrfArg **args)
+static ioccrfArg scanpplArg0 = { "rate",ioccrfArgDouble,0};
+static ioccrfArg *scanpplArgs[1] = {&scanpplArg0};
+static ioccrfFuncDef scanpplFuncDef = {"scanppl",1,scanpplArgs};
+static void scanpplCallFunc(ioccrfArg **args)
 { scanppl(*(double *)args[0]->value);}

 /* scanpel */
-ioccrfArg scanpelArg0 = { "event_number",ioccrfArgInt,0};
-ioccrfArg *scanpelArgs[1] = {&scanpelArg0};
-ioccrfFuncDef scanpelFuncDef = {"scanpel",1,scanpelArgs};
-void scanpelCallFunc(ioccrfArg **args)
+static ioccrfArg scanpelArg0 = { "event_number",ioccrfArgInt,0};
+static ioccrfArg *scanpelArgs[1] = {&scanpelArg0};
+static ioccrfFuncDef scanpelFuncDef = {"scanpel",1,scanpelArgs};
+static void scanpelCallFunc(ioccrfArg **args)
 { scanpel(*(int *)args[0]->value);}

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

 void epicsShareAPI dbTestRegister(void)
 {