diff --git a/src/gdd/aitConvert.cc b/src/gdd/aitConvert.cc
index 86b4b55ee..d97ee21c3 100644
--- a/src/gdd/aitConvert.cc
+++ b/src/gdd/aitConvert.cc
@@ -5,6 +5,9 @@
 // $Id$
 //
 // $Log$
+// Revision 1.13  2001/06/11 22:28:50  jhill
+// revert because workaround for RTEMS didnt build
+//
 // Revision 1.12  2001/06/11 20:13:42  jhill
 // workarounds for problems discovered when building for RTEMS
 //
@@ -59,7 +62,7 @@
 #define epicsExportSharedSymbols
 #include "aitConvert.h"
 
-int aitNoConvert(void* /*dest*/,const void* /*src*/,aitIndex /*count*/, const std::vector< std::string > &) {return -1;}
+int aitNoConvert(void* /*dest*/,const void* /*src*/,aitIndex /*count*/, const std::vector< std::string > *) {return -1;}
 
 #ifdef AIT_CONVERT
 #undef AIT_CONVERT
@@ -75,12 +78,11 @@ int aitNoConvert(void* /*dest*/,const void* /*src*/,aitIndex /*count*/, const st
 #define min(A,B) ((A)<(B)?(A):(B))
 #endif
 
-const std::vector<std::string> aitEmptyEnumStringTable;
-
 /* put the fixed conversion functions here (ones not generated) */
 
 /* ------- extra string conversion functions --------- */
-static int aitConvertStringString(void* d,const void* s,aitIndex c, const std::vector< std::string > &)
+static int aitConvertStringString(void* d,const void* s,
+              aitIndex c, const std::vector< std::string > *)
 {
 	// does not work - need to be fixed
 	aitIndex i;
@@ -89,24 +91,30 @@ static int aitConvertStringString(void* d,const void* s,aitIndex c, const std::v
 	for(i=0;i<c;i++) out[i]=in[i];
 	return 0;
 }
-static int aitConvertToNetStringString(void* d,const void* s,aitIndex c, const std::vector< std::string > &enumStringTable)
-{ return aitConvertStringString(d,s,c, enumStringTable);}
-static int aitConvertFromNetStringString(void* d,const void* s,aitIndex c, const std::vector< std::string > &enumStringTable)
-{ return aitConvertStringString(d,s,c, enumStringTable);}
+static int aitConvertToNetStringString(void* d,const void* s,
+              aitIndex c, const std::vector< std::string > *pEnumStringTable)
+{ return aitConvertStringString(d,s,c, pEnumStringTable);}
+static int aitConvertFromNetStringString(void* d,const void* s,
+              aitIndex c, const std::vector< std::string > *pEnumStringTable)
+{ return aitConvertStringString(d,s,c, pEnumStringTable);}
 
 /* ------ all the fixed string conversion functions ------ */
-static int aitConvertFixedStringFixedString(void* d,const void* s,aitIndex c, const std::vector< std::string > &)
+static int aitConvertFixedStringFixedString(void* d,const void* s,
+                       aitIndex c, const std::vector< std::string > *)
 {
 	aitUint32 len = c*AIT_FIXED_STRING_SIZE;
 	memcpy(d,s,len);
 	return 0;
 }
-static int aitConvertToNetFixedStringFixedString(void* d,const void* s,aitIndex c, const std::vector< std::string > &enumStringTable)
-{ return aitConvertFixedStringFixedString(d,s,c,enumStringTable);}
-static int aitConvertFromNetFixedStringFixedString(void* d,const void* s,aitIndex c, const std::vector< std::string > &enumStringTable)
-{ return aitConvertFixedStringFixedString(d,s,c,enumStringTable);}
+static int aitConvertToNetFixedStringFixedString(void* d,const void* s,
+                  aitIndex c, const std::vector< std::string > *pEnumStringTable)
+{ return aitConvertFixedStringFixedString(d,s,c,pEnumStringTable);}
+static int aitConvertFromNetFixedStringFixedString(void* d,const void* s,
+                  aitIndex c, const std::vector< std::string > *pEnumStringTable)
+{ return aitConvertFixedStringFixedString(d,s,c,pEnumStringTable);}
 
-static int aitConvertStringFixedString(void* d,const void* s,aitIndex c, const std::vector< std::string > &)
+static int aitConvertStringFixedString(void* d,const void* s,
+                    aitIndex c, const std::vector< std::string > *)
 {
 	aitIndex i;
 	aitString* out = (aitString*)d;
@@ -116,7 +124,8 @@ static int aitConvertStringFixedString(void* d,const void* s,aitIndex c, const s
 	return 0;
 }
 
-static int aitConvertFixedStringString(void* d,const void* s,aitIndex c, const std::vector< std::string > &)
+static int aitConvertFixedStringString(void* d,const void* s,
+                   aitIndex c, const std::vector< std::string > *)
 {
 	aitIndex i;
 	aitString* in = (aitString*)s;
@@ -135,16 +144,21 @@ static int aitConvertFixedStringString(void* d,const void* s,aitIndex c, const s
 	return 0;
 }
 
-static int aitConvertToNetStringFixedString(void* d,const void* s,aitIndex c, const std::vector< std::string > &enumStringTable)
-{ return aitConvertStringFixedString(d,s,c,enumStringTable); }
-static int aitConvertFromNetFixedStringString(void* d,const void* s,aitIndex c, const std::vector< std::string > &enumStringTable)
-{ return aitConvertFixedStringString(d,s,c,enumStringTable); }
-static int aitConvertToNetFixedStringString(void* d,const void* s,aitIndex c, const std::vector< std::string > &enumStringTable)
-{ return aitConvertStringFixedString(d,s,c,enumStringTable); }
-static int aitConvertFromNetStringFixedString(void* d,const void* s,aitIndex c, const std::vector< std::string > &enumStringTable)
-{ return aitConvertFixedStringString(d,s,c,enumStringTable); }
+static int aitConvertToNetStringFixedString(void* d,const void* s,
+              aitIndex c, const std::vector< std::string > *pEnumStringTable)
+{ return aitConvertStringFixedString(d,s,c,pEnumStringTable); }
+static int aitConvertFromNetFixedStringString(void* d,const void* s,
+              aitIndex c, const std::vector< std::string > *pEnumStringTable)
+{ return aitConvertFixedStringString(d,s,c,pEnumStringTable); }
+static int aitConvertToNetFixedStringString(void* d,const void* s,
+              aitIndex c, const std::vector< std::string > *pEnumStringTable)
+{ return aitConvertStringFixedString(d,s,c,pEnumStringTable); }
+static int aitConvertFromNetStringFixedString(void* d,const void* s,
+              aitIndex c, const std::vector< std::string > *pEnumStringTable)
+{ return aitConvertFixedStringString(d,s,c,pEnumStringTable); }
 
-static int aitConvertStringEnum16(void* d,const void* s,aitIndex c, const std::vector< std::string > &enumStringTable)
+static int aitConvertStringEnum16(void* d,const void* s,
+               aitIndex c, const std::vector< std::string > *pEnumStringTable)
 {
 	aitIndex i;
 	int status=0;
@@ -153,9 +167,9 @@ static int aitConvertStringEnum16(void* d,const void* s,aitIndex c, const std::v
 	aitEnum16* in=(aitEnum16*)s;
 	for (i=0;i<c;i++) {
 		unsigned nChar;
-		if (in[i]<enumStringTable.size()) {
-			out[i].copy(enumStringTable[in[i]].c_str());
-			nChar = enumStringTable[in[i]].length();
+		if (pEnumStringTable&&in[i]<pEnumStringTable->size()) {
+			out[i].copy((*pEnumStringTable)[in[i]].c_str());
+			nChar = (*pEnumStringTable)[in[i]].length();
 		}
 		else {
 			nChar = sprintf(temp, "%hu",in[i]);
@@ -166,17 +180,20 @@ static int aitConvertStringEnum16(void* d,const void* s,aitIndex c, const std::v
 	return status;
 }
 
-static int aitConvertToNetStringEnum16(void* d,const void* s,aitIndex c, const std::vector< std::string > &enumStringTable)
+static int aitConvertToNetStringEnum16(void* d,const void* s,
+            aitIndex c, const std::vector< std::string > *pEnumStringTable)
 { 
-    return aitConvertStringEnum16(d,s,c,enumStringTable); 
+    return aitConvertStringEnum16(d,s,c,pEnumStringTable); 
 }
 
-static int aitConvertFromNetStringEnum16(void* d,const void* s,aitIndex c, const std::vector< std::string > &enumStringTable)
+static int aitConvertFromNetStringEnum16(void* d,const void* s,
+            aitIndex c, const std::vector< std::string > *pEnumStringTable)
 { 
-    return aitConvertStringEnum16(d,s,c,enumStringTable); 
+    return aitConvertStringEnum16(d,s,c,pEnumStringTable); 
 }
 
-static int aitConvertFixedStringEnum16(void* d,const void* s,aitIndex c, const std::vector< std::string > &enumStringTable)
+static int aitConvertFixedStringEnum16(void* d,const void* s,
+         aitIndex c, const std::vector< std::string > *pEnumStringTable)
 {
 	aitIndex i;
 	int status=0;
@@ -184,8 +201,8 @@ static int aitConvertFixedStringEnum16(void* d,const void* s,aitIndex c, const s
 	aitEnum16* in=(aitEnum16*)s;
 	for (i=0;i<c;i++) {
 		unsigned nChar;
-		if (in[i]<enumStringTable.size()) {
-			strncpy(out[i].fixed_string, enumStringTable[in[i]].c_str(),sizeof(out[i].fixed_string));
+		if (pEnumStringTable&&in[i]<pEnumStringTable->size()) {
+			strncpy(out[i].fixed_string, (*pEnumStringTable)[in[i]].c_str(),sizeof(out[i].fixed_string));
 			out[i].fixed_string[sizeof(out[i].fixed_string)-1] = '\0';
 			nChar = sizeof(out[i].fixed_string);
 		}
@@ -198,17 +215,20 @@ static int aitConvertFixedStringEnum16(void* d,const void* s,aitIndex c, const s
 	return status;
 }
 
-static int aitConvertToNetFixedStringEnum16(void* d,const void* s,aitIndex c, const std::vector< std::string > &enumStringTable)
+static int aitConvertToNetFixedStringEnum16(void* d,const void* s,
+              aitIndex c, const std::vector< std::string > *pEnumStringTable)
 { 
-    return aitConvertFixedStringEnum16(d,s,c,enumStringTable); 
+    return aitConvertFixedStringEnum16(d,s,c,pEnumStringTable); 
 }
 
-static int aitConvertFromNetFixedStringEnum16(void* d,const void* s,aitIndex c, const std::vector< std::string > &enumStringTable)
+static int aitConvertFromNetFixedStringEnum16(void* d,const void* s,
+              aitIndex c, const std::vector< std::string > *pEnumStringTable)
 { 
-    return aitConvertFixedStringEnum16(d,s,c,enumStringTable); 
+    return aitConvertFixedStringEnum16(d,s,c,pEnumStringTable); 
 }
 
-static int aitConvertEnum16FixedString (void* d,const void* s,aitIndex c, const std::vector< std::string > &enumStringTable)
+static int aitConvertEnum16FixedString (void* d,const void* s,aitIndex c, 
+                        const std::vector< std::string > *pEnumStringTable)
 {
 	aitIndex i;
 	int status = 0;
@@ -219,15 +239,20 @@ static int aitConvertEnum16FixedString (void* d,const void* s,aitIndex c, const
     //
     // convert only after a range check
     //
-    assert (enumStringTable.size()<=0xffff);
-    nChoices = static_cast<aitEnum16>(enumStringTable.size());
+    if ( pEnumStringTable ) {
+        assert (pEnumStringTable->size()<=0xffff);
+        nChoices = static_cast<aitEnum16>(pEnumStringTable->size());
+    }
+    else {
+        nChoices = 0;
+    }
 
 	for (i=0;i<c;i++) {
         //
         // find the choice that matches
         //
 	    for (choice=0;choice<nChoices;choice++) {
-            if (strcmp(enumStringTable[choice].c_str(), in[i].fixed_string)==0) {
+            if (strcmp((*pEnumStringTable)[choice].c_str(), in[i].fixed_string)==0) {
                 out[i] = choice;
                 status += sizeof(out[i]);
                 break;
@@ -243,17 +268,20 @@ static int aitConvertEnum16FixedString (void* d,const void* s,aitIndex c, const
     return status;
 }
 
-static int aitConvertToNetEnum16FixedString(void* d,const void* s,aitIndex c, const std::vector< std::string > &enumStringTable)
+static int aitConvertToNetEnum16FixedString(void* d,const void* s,
+               aitIndex c, const std::vector< std::string > *pEnumStringTable)
 { 
-    return aitConvertEnum16FixedString(d,s,c,enumStringTable); 
+    return aitConvertEnum16FixedString(d,s,c,pEnumStringTable); 
 }
 
-static int aitConvertFromNetEnum16FixedString(void* d,const void* s,aitIndex c, const std::vector< std::string > &enumStringTable)
+static int aitConvertFromNetEnum16FixedString(void* d,const void* s,
+               aitIndex c, const std::vector< std::string > *pEnumStringTable)
 { 
-    return aitConvertEnum16FixedString(d,s,c,enumStringTable); 
+    return aitConvertEnum16FixedString(d,s,c,pEnumStringTable); 
 }
 
-static int aitConvertEnum16String (void* d,const void* s,aitIndex c, const std::vector< std::string > &enumStringTable)
+static int aitConvertEnum16String (void* d,const void* s,
+               aitIndex c, const std::vector< std::string > *pEnumStringTable)
 {
 	aitIndex i;
 	int status = 0;
@@ -264,15 +292,20 @@ static int aitConvertEnum16String (void* d,const void* s,aitIndex c, const std::
     //
     // convert only after a range check
     //
-    assert (enumStringTable.size()<=0xffff);
-    nChoices = static_cast<aitEnum16>(enumStringTable.size());
+    if ( pEnumStringTable ) {
+        assert (pEnumStringTable->size()<=0xffff);
+        nChoices = static_cast<aitEnum16>(pEnumStringTable->size());
+    }
+    else {
+        nChoices = 0u;
+    }
 
 	for (i=0;i<c;i++) {
         //
         // find the choice that matches
         //
 	    for (choice=0;choice<nChoices;choice++) {
-            if (strcmp(enumStringTable[choice].c_str(), in[i].string())==0) {
+            if (strcmp((*pEnumStringTable)[choice].c_str(), in[i].string())==0) {
                 out[i] = choice;
                 status += sizeof(out[i]);
                 break;
@@ -288,14 +321,16 @@ static int aitConvertEnum16String (void* d,const void* s,aitIndex c, const std::
     return status;
 }
 
-static int aitConvertToNetEnum16String(void* d,const void* s,aitIndex c, const std::vector< std::string > &enumStringTable)
+static int aitConvertToNetEnum16String(void* d,const void* s,
+               aitIndex c, const std::vector< std::string > *pEnumStringTable)
 { 
-    return aitConvertEnum16String(d,s,c,enumStringTable); 
+    return aitConvertEnum16String(d,s,c,pEnumStringTable); 
 }
 
-static int aitConvertFromNetEnum16String(void* d,const void* s,aitIndex c, const std::vector< std::string > &enumStringTable)
+static int aitConvertFromNetEnum16String(void* d,const void* s,
+               aitIndex c, const std::vector< std::string > *pEnumStringTable)
 { 
-    return aitConvertEnum16String(d,s,c,enumStringTable); 
+    return aitConvertEnum16String(d,s,c,pEnumStringTable); 
 }
 
 #define AIT_CONVERT 1
diff --git a/src/gdd/aitConvert.h b/src/gdd/aitConvert.h
index 0d274f041..171ed7e6e 100644
--- a/src/gdd/aitConvert.h
+++ b/src/gdd/aitConvert.h
@@ -8,6 +8,9 @@
  * $Id$
  *
  * $Log$
+ * Revision 1.12  2001/06/11 22:28:51  jhill
+ * revert because workaround for RTEMS didnt build
+ *
  * Revision 1.11  2001/06/11 20:13:42  jhill
  * workarounds for problems discovered when building for RTEMS
  *
@@ -74,7 +77,7 @@
 typedef enum { aitLocalDataFormat=0, aitNetworkDataFormat } aitDataFormat;
 
 /* all conversion functions have this prototype */
-typedef int (*aitFunc)(void* dest,const void* src,aitIndex count,const std::vector< std::string > &enumStringTable);
+typedef int (*aitFunc)(void* dest,const void* src,aitIndex count,const std::vector< std::string > *pEnumStringTable);
 
 #ifdef __cplusplus
 extern "C" {
@@ -99,22 +102,20 @@ epicsShareExtern aitFunc aitConvertFromNetTable[aitTotal][aitTotal];
 
 #if defined(__cplusplus)
 
-extern const std::vector<std::string> aitEmptyEnumStringTable;
-
 inline int aitConvert(aitEnum desttype, void* dest,
  aitEnum srctype, const void* src, aitIndex count, 
- const std::vector< std::string > &enumStringTable = aitEmptyEnumStringTable )
-  { return (*aitConvertTable[desttype][srctype])(dest,src,count,enumStringTable); }
+ const std::vector<std::string> *pEnumStringTable = 0 )
+  { return (*aitConvertTable[desttype][srctype])(dest,src,count,pEnumStringTable); }
 
 inline int aitConvertToNet(aitEnum desttype, void* dest,
  aitEnum srctype, const void* src, aitIndex count, 
- const std::vector< std::string > &enumStringTable = aitEmptyEnumStringTable )
-  { return (*aitConvertToNetTable[desttype][srctype])(dest,src,count,enumStringTable); }
+ const std::vector<std::string> *pEnumStringTable = 0 )
+  { return (*aitConvertToNetTable[desttype][srctype])(dest,src,count,pEnumStringTable); }
 
 inline int aitConvertFromNet(aitEnum desttype, void* dest,
  aitEnum srctype, const void* src, aitIndex count, 
- const std::vector< std::string > &enumStringTable = aitEmptyEnumStringTable )
-  { return (*aitConvertFromNetTable[desttype][srctype])(dest,src,count,enumStringTable); }
+ const std::vector<std::string> *pEnumStringTable = 0 )
+  { return (*aitConvertFromNetTable[desttype][srctype])(dest,src,count,pEnumStringTable); }
 
 #else
 
diff --git a/src/gdd/aitGen.c b/src/gdd/aitGen.c
index 18c9aca81..97e770d33 100644
--- a/src/gdd/aitGen.c
+++ b/src/gdd/aitGen.c
@@ -5,6 +5,9 @@
  * $Id$
  *
  * $Log$
+ * Revision 1.10  2000/10/12 21:52:48  jhill
+ * changes to support compilation by borland
+ *
  * Revision 1.9  1999/10/28 23:33:41  jhill
  * use fully qualified namespace names for C++ RTL classes
  *
@@ -231,7 +234,7 @@ void MakeStringFuncFrom(int i,int j,int k)
 	/* assumes that void* d in an array of char pointers of length c */
 	/* takes numeric data from source j and convert it to string in dest i */
 
-	pr(dfd,"static int %s%s%s(void* d,const void* s,aitIndex c, const std::vector<std::string> &)\n",
+	pr(dfd,"static int %s%s%s(void* d,const void* s,aitIndex c, const std::vector<std::string> *)\n",
 		table_type[k],&(aitName[i])[3],&(aitName[j])[3]);
 	pr(dfd,"{\n");
 	pr(dfd,"\taitIndex i;\n");
@@ -261,7 +264,7 @@ void MakeStringFuncTo(int i,int j,int k)
 	/* assumes that void* d in an array of char pointers of length c */
 	/* takes string data from source j and convert it to numeric in dest i */
 
-	pr(dfd,"static int %s%s%s(void* d,const void* s,aitIndex c, const std::vector<std::string> &)\n",
+	pr(dfd,"static int %s%s%s(void* d,const void* s,aitIndex c, const std::vector<std::string> *)\n",
 		table_type[k],&(aitName[i])[3],&(aitName[j])[3]);
 	pr(dfd,"{\n");
 	pr(dfd,"\taitIndex i;\n");
@@ -309,7 +312,7 @@ void MakeFStringFuncFrom(int i,int j,int k)
 	/* assumes that void* d in an array of char pointers of length c */
 	/* takes numeric data from source j and convert it to string in dest i */
 
-	pr(dfd,"static int %s%s%s(void* d,const void* s,aitIndex c, const std::vector<std::string> &)\n",
+	pr(dfd,"static int %s%s%s(void* d,const void* s,aitIndex c, const std::vector<std::string> *)\n",
 		table_type[k],&(aitName[i])[3],&(aitName[j])[3]);
 	pr(dfd,"{\n");
 	pr(dfd,"\taitIndex i;\n");
@@ -346,7 +349,7 @@ void MakeFStringFuncTo(int i,int j,int k)
 {
 	/* assumes that void* d in an array of char pointers of length c */
 	/* takes string data from source j and convert it to numeric in dest i */
-	pr(dfd,"static int %s%s%s(void* d,const void* s,aitIndex c, const std::vector<std::string> &)\n",
+	pr(dfd,"static int %s%s%s(void* d,const void* s,aitIndex c, const std::vector<std::string> *)\n",
 		table_type[k],&(aitName[i])[3],&(aitName[j])[3]);
 	pr(dfd,"{\n");
 	pr(dfd,"\taitIndex i;\n");
@@ -392,7 +395,7 @@ void GenName(int i,int j,int k)
 	const char* i_name = &((aitName[i])[3]);
 	const char* j_name = &((aitName[j])[3]);
 
-	pr(dfd,"static int %s%s%s(void* d,const void* s,aitIndex c, const std::vector<std::string> &)\n",
+	pr(dfd,"static int %s%s%s(void* d,const void* s,aitIndex c, const std::vector<std::string> *)\n",
 			table_type[k],i_name,j_name);
 }
 
diff --git a/src/gdd/dbMapper.cc b/src/gdd/dbMapper.cc
index 8e6a7b862..9efadd069 100644
--- a/src/gdd/dbMapper.cc
+++ b/src/gdd/dbMapper.cc
@@ -4,6 +4,9 @@
 // $Id$
 // 
 // $Log$
+// Revision 1.34  2000/09/27 19:43:52  jhill
+// cosmetic
+//
 // Revision 1.33  2000/09/26 21:11:56  jhill
 // added definition of min
 //
@@ -260,7 +263,8 @@ static smartGDDPointer mapStringToGdd(void* v,aitIndex count) {
 	}
 }
 
-static int mapGddToString(void* vd, aitIndex count, const gdd & dd, const std::vector< std::string > &enumStringTable) {
+static int mapGddToString(void* vd, aitIndex count, 
+    const gdd & dd, const std::vector< std::string > &enumStringTable) {
 	aitFixedString* db = (aitFixedString*)vd;
 	aitIndex sz = dd.getDataSizeElements();
 	const void* v = dd.dataVoid();
@@ -273,14 +277,16 @@ static int mapGddToString(void* vd, aitIndex count, const gdd & dd, const std::v
 
 	if(local_data_format==aitLocalDataFormat) {
 		if((aitFixedString*)v!=db) {
-			status = aitConvert(aitEnumFixedString,db,dd.primitiveType(),v,count, enumStringTable);
+			status = aitConvert(aitEnumFixedString,db,
+                dd.primitiveType(),v,count, &enumStringTable);
 		}
 		else {
 			status = sz*sizeof(aitFixedString);
 		}
 	}
 	else {
-		status = aitConvertToNet(aitEnumFixedString,db,dd.primitiveType(),v,count, enumStringTable);
+		status = aitConvertToNet(aitEnumFixedString,
+            db,dd.primitiveType(),v,count, &enumStringTable);
 	}
 	
 	return status;
@@ -319,14 +325,16 @@ static int mapGddToShort(void* vd, aitIndex count, const gdd &dd,
 
 	if (local_data_format==aitLocalDataFormat) {
 		if((dbr_short_t*)v!=sv) {
-			status = aitConvert(aitEnumInt16,sv,dd.primitiveType(),v,count, enumStringTable);
+			status = aitConvert(aitEnumInt16,sv,
+                dd.primitiveType(),v,count, &enumStringTable);
 		}
 		else {
 			status = count*sizeof(dbr_short_t);
 		}
 	}
 	else {
-		status = aitConvertToNet(aitEnumInt16,sv,dd.primitiveType(),v,count, enumStringTable);
+		status = aitConvertToNet(aitEnumInt16,sv,
+            dd.primitiveType(),v,count, &enumStringTable);
 	}
 
 	return status;
@@ -351,7 +359,8 @@ static smartGDDPointer mapFloatToGdd(void* v,aitIndex count) {
 	}
 }
 
-static int mapGddToFloat(void* vd, aitIndex count, const gdd & dd, const std::vector< std::string > &enumStringTable) {
+static int mapGddToFloat(void* vd, aitIndex count, 
+     const gdd & dd, const std::vector< std::string > &enumStringTable) {
 	dbr_float_t* sv = (dbr_float_t*)vd;
     aitIndex sz=dd.getDataSizeElements();
 	const void * v = dd.dataVoid();
@@ -364,14 +373,16 @@ static int mapGddToFloat(void* vd, aitIndex count, const gdd & dd, const std::ve
 
 	if(local_data_format==aitLocalDataFormat) {
 		if((dbr_float_t*)v!=sv) {
-			status = aitConvert(aitEnumFloat32,sv,dd.primitiveType(),v,count, enumStringTable);
+			status = aitConvert(aitEnumFloat32,sv,
+                dd.primitiveType(),v,count, &enumStringTable);
 		}
 		else {
 			status = sz*sizeof(dbr_float_t);
 		}
 	}
 	else {
-		status = aitConvertToNet(aitEnumFloat32,sv,dd.primitiveType(),v,count, enumStringTable);
+		status = aitConvertToNet(aitEnumFloat32,sv,
+            dd.primitiveType(),v,count, &enumStringTable);
 	}
 
 	return status;
@@ -396,7 +407,8 @@ static smartGDDPointer mapEnumToGdd(void* v,aitIndex count) {
 	return dd;
 }
 
-static int mapGddToEnum(void* vd, aitIndex count, const gdd & dd, const std::vector< std::string > &enumStringTable) {
+static int mapGddToEnum(void* vd, aitIndex count, const gdd & dd, 
+                        const std::vector< std::string > &enumStringTable) {
 	dbr_enum_t* sv = (dbr_enum_t*)vd;
     aitIndex sz=dd.getDataSizeElements();
 	const void* v = dd.dataVoid();
@@ -409,14 +421,16 @@ static int mapGddToEnum(void* vd, aitIndex count, const gdd & dd, const std::vec
 
 	if(local_data_format==aitLocalDataFormat) {
 		if((dbr_enum_t*)v!=sv) {
-			status = aitConvert(aitEnumEnum16,sv,dd.primitiveType(),v,count, enumStringTable);
+			status = aitConvert(aitEnumEnum16,sv,
+                dd.primitiveType(),v,count, &enumStringTable);
 		}
 		else {
 			status = sizeof(dbr_enum_t)*count;
 		}
 	}
 	else {
-		status = aitConvertToNet(aitEnumEnum16,sv,dd.primitiveType(),v,count, enumStringTable);
+		status = aitConvertToNet(aitEnumEnum16,sv,
+            dd.primitiveType(),v,count, &enumStringTable);
 	}
 
 	return status;
@@ -441,7 +455,8 @@ static smartGDDPointer mapCharToGdd(void* v,aitIndex count) {
 	return dd;
 }
 
-static int mapGddToChar(void* vd, aitIndex count, const gdd & dd, const std::vector< std::string > &enumStringTable) {
+static int mapGddToChar(void* vd, aitIndex count, 
+     const gdd & dd, const std::vector< std::string > &enumStringTable) {
 	dbr_char_t* sv = (dbr_char_t*)vd;
     aitIndex sz=dd.getDataSizeElements();
 	const void* v = dd.dataVoid();
@@ -454,14 +469,16 @@ static int mapGddToChar(void* vd, aitIndex count, const gdd & dd, const std::vec
 
 	if (local_data_format==aitLocalDataFormat) {
 		if((dbr_char_t*)v!=sv) {
-			status = aitConvert(aitEnumInt8,sv,dd.primitiveType(),v,count, enumStringTable);
+			status = aitConvert(aitEnumInt8,sv,
+                dd.primitiveType(),v,count, &enumStringTable);
 		}
 		else {
 			status = sz*sizeof(dbr_char_t);
 		}
 	}
 	else {
-		status = aitConvertToNet(aitEnumInt8,sv,dd.primitiveType(),v,count, enumStringTable);
+		status = aitConvertToNet(aitEnumInt8,sv,
+            dd.primitiveType(),v,count, &enumStringTable);
 	}
 
 	return status;
@@ -486,7 +503,8 @@ static smartGDDPointer mapLongToGdd(void* v,aitIndex count) {
 	return dd;
 }
 
-static int mapGddToLong(void* vd, aitIndex count, const gdd & dd, const std::vector< std::string > &enumStringTable) {
+static int mapGddToLong(void* vd, aitIndex count, const gdd & dd, 
+                      const std::vector< std::string > &enumStringTable) {
 	dbr_long_t* sv = (dbr_long_t*)vd;
     aitIndex sz=dd.getDataSizeElements();
 	const void* v = dd.dataVoid();
@@ -499,14 +517,16 @@ static int mapGddToLong(void* vd, aitIndex count, const gdd & dd, const std::vec
 
 	if (local_data_format==aitLocalDataFormat) {
 		if ((dbr_long_t*)v!=sv) {
-			status = aitConvert(aitEnumInt32,sv,dd.primitiveType(),v,count, enumStringTable);
+			status = aitConvert(aitEnumInt32,sv,
+                dd.primitiveType(),v,count, &enumStringTable);
 		}
 		else {
 			status = count*sizeof(dbr_long_t);
 		}
 	}
 	else {
-		status = aitConvertToNet(aitEnumInt32,sv,dd.primitiveType(),v,count, enumStringTable);
+		status = aitConvertToNet(aitEnumInt32,sv,
+            dd.primitiveType(),v,count, &enumStringTable);
 	}
 
 	return status;
@@ -531,7 +551,8 @@ static smartGDDPointer mapDoubleToGdd(void* v,aitIndex count) {
 	return dd;
 }
 
-static int mapGddToDouble(void* vd, aitIndex count, const gdd & dd, const std::vector< std::string > &enumStringTable) {
+static int mapGddToDouble(void* vd, aitIndex count, const gdd & dd, 
+                          const std::vector< std::string > &enumStringTable) {
 	dbr_double_t* sv = (dbr_double_t*)vd;
     aitIndex sz=dd.getDataSizeElements();
 	const void* v = dd.dataVoid();
@@ -544,14 +565,16 @@ static int mapGddToDouble(void* vd, aitIndex count, const gdd & dd, const std::v
 
 	if (local_data_format==aitLocalDataFormat) {
 		if ((dbr_double_t*)v!=sv) {
-			status = aitConvert(aitEnumFloat64,sv,dd.primitiveType(),v,count, enumStringTable);
+			status = aitConvert(aitEnumFloat64,sv,
+                dd.primitiveType(),v,count, &enumStringTable);
 		}
 		else {
 			status = count*sizeof(dbr_double_t);
 		}
 	}
 	else {
-		status = aitConvertToNet(aitEnumFloat64,sv,dd.primitiveType(),v,count, enumStringTable);
+		status = aitConvertToNet(aitEnumFloat64,sv,
+            dd.primitiveType(),v,count, &enumStringTable);
 	}
 
 	return status;
@@ -1673,7 +1696,8 @@ static int mapGddToAckt(void* vd, aitIndex count, const gdd & dd,
         if (local_data_format==aitLocalDataFormat) {
             if((dbr_put_ackt_t*)v!=sv) {
                 status = 
-                    aitConvert(aitEnumUint16,sv,dd.primitiveType(),v,sz,enumStringTable);
+                    aitConvert(aitEnumUint16,sv,
+                    dd.primitiveType(),v,sz,&enumStringTable);
             }
             else {
                 status = sz*sizeof(dbr_put_ackt_t);
@@ -1681,7 +1705,8 @@ static int mapGddToAckt(void* vd, aitIndex count, const gdd & dd,
         }
         else {
             status = 
-                aitConvertToNet(aitEnumUint16,sv,dd.primitiveType(),v,sz, enumStringTable);
+                aitConvertToNet(aitEnumUint16,sv,
+                dd.primitiveType(),v,sz, &enumStringTable);
         }
     }
     else {
@@ -1723,7 +1748,8 @@ static int mapGddToAcks(void* vd, aitIndex count, const gdd &dd,
         if (local_data_format==aitLocalDataFormat) {
             if((dbr_put_acks_t*)v!=sv) {
                 status = 
-                    aitConvert(aitEnumUint16,sv,dd.primitiveType(),v,sz, enumStringTable);
+                    aitConvert(aitEnumUint16,sv,
+                    dd.primitiveType(),v,sz, &enumStringTable);
             }
             else {
                 status = sz*sizeof(dbr_put_acks_t);
@@ -1731,7 +1757,8 @@ static int mapGddToAcks(void* vd, aitIndex count, const gdd &dd,
         }
         else {
             status = 
-                aitConvertToNet(aitEnumUint16,sv,dd.primitiveType(),v,sz, enumStringTable);
+                aitConvertToNet(aitEnumUint16,sv,
+                dd.primitiveType(),v,sz, &enumStringTable);
         }
     }
     else {
@@ -1779,7 +1806,8 @@ static int mapGddToClassName(void* vd, aitIndex count, const gdd & dd,
         if(local_data_format==aitLocalDataFormat) {
             if((aitFixedString*)v!=db) {
                 status = 
-                    aitConvert(aitEnumFixedString,db,dd.primitiveType(),v,count, enumStringTable);
+                    aitConvert(aitEnumFixedString,db,
+                    dd.primitiveType(),v,count, &enumStringTable);
             }
             else {
                 status = sz*sizeof(aitFixedString);
@@ -1787,7 +1815,8 @@ static int mapGddToClassName(void* vd, aitIndex count, const gdd & dd,
         }
         else {
             status = 
-                aitConvertToNet(aitEnumFixedString,db,dd.primitiveType(),v,count, enumStringTable);
+                aitConvertToNet(aitEnumFixedString,db,
+                dd.primitiveType(),v,count, &enumStringTable);
         }
     }
     else {