diff --git a/source/include/accAPI.h b/source/include/accAPI.h
index 43027610..da1a4b10 100644
--- a/source/include/accAPI.h
+++ b/source/include/accAPI.h
@@ -15,271 +15,271 @@ extern "C" {
 
 #define UDA_NUM_CLIENT_THREADS 30
 
-LIBRARY_API DATA_BLOCK* acc_getCurrentDataBlock(CLIENT_FLAGS* client_flags);
+LIBRARY_API DATA_BLOCK* udaGetCurrentDataBlock();  
 
-LIBRARY_API int acc_getCurrentDataBlockIndex(CLIENT_FLAGS* client_flags);
+LIBRARY_API int udaGetCurrentDataBlockIndex();  
 
-LIBRARY_API int acc_growUdaDataBlocks(CLIENT_FLAGS* client_flags);
+LIBRARY_API int udaGrowDataBlocks();
 
-LIBRARY_API int acc_getUdaNewDataHandle(CLIENT_FLAGS* client_flags);
+LIBRARY_API int udaGetNewDataHandle();  
 
-LIBRARY_API void acc_freeDataBlocks();
+LIBRARY_API void udaFreeDataBlocks();  
 
-LIBRARY_API void setUdaPrivateFlag(unsigned int flag);
+LIBRARY_API void udaSetPrivateFlag(unsigned int flag);
 
-LIBRARY_API void resetUdaPrivateFlag(unsigned int flag);
+LIBRARY_API void udaResetPrivateFlag(unsigned int flag);
 
-LIBRARY_API void setUdaClientFlag(CLIENT_FLAGS* client_flags, unsigned int flag);
+LIBRARY_API void udaSetClientFlag(unsigned int flag);
 
-LIBRARY_API void resetUdaClientFlag(CLIENT_FLAGS* client_flags, unsigned int flag);
+LIBRARY_API void udaResetClientFlag(unsigned int flag);
 
-LIBRARY_API void setUdaProperty(const char* property, CLIENT_FLAGS* client_flags);
+LIBRARY_API void udaSetProperty(const char* property);
 
-LIBRARY_API int getUdaProperty(const char* property, const CLIENT_FLAGS* client_flags);
+LIBRARY_API int udaGetProperty(const char* property);
 
-LIBRARY_API void resetUdaProperty(const char* property, CLIENT_FLAGS* client_flags);
+LIBRARY_API void udaResetProperty(const char* property);
 
-LIBRARY_API void resetUdaProperties(CLIENT_FLAGS* client_flags);
+LIBRARY_API void udaResetProperties();
 
-LIBRARY_API CLIENT_BLOCK saveUdaProperties(const CLIENT_FLAGS* client_flags);
+LIBRARY_API CLIENT_BLOCK udaSaveProperties();
 
-LIBRARY_API void restoreUdaProperties(CLIENT_BLOCK cb, CLIENT_FLAGS* client_flags);
+LIBRARY_API void udaRestoreProperties(CLIENT_BLOCK cb);
 
-LIBRARY_API CLIENT_BLOCK* getUdaProperties(int handle);
+LIBRARY_API CLIENT_BLOCK* udaGetProperties(int handle);
 
-LIBRARY_API CLIENT_BLOCK* getUdaDataProperties(int handle);
+LIBRARY_API CLIENT_BLOCK* udaGetDataProperties(int handle);
 
 #ifndef __APPLE__
 
-LIBRARY_API int getUdaMemoryFree();
+LIBRARY_API int udaGetMemoryFree();
 
-LIBRARY_API int getUdaMemoryUsed();
+LIBRARY_API int udaGetMemoryUsed();
 
 #endif
 
-LIBRARY_API void putUdaErrorModel(int handle, int model, int param_n, const float* params);
+LIBRARY_API void udaPutErrorModel(int handle, int model, int param_n, const float* params);
 
-LIBRARY_API void putUdaDimErrorModel(int handle, int ndim, int model, int param_n, const float* params);
+LIBRARY_API void udaPutDimErrorModel(int handle, int ndim, int model, int param_n, const float* params);
 
-LIBRARY_API void putUdaServer(const char* host, int port);
+LIBRARY_API void udaPutServer(const char* host, int port);
 
-LIBRARY_API void putUdaServerHost(const char* host);
+LIBRARY_API void udaPutServerHost(const char* host);
 
-LIBRARY_API void putUdaServerPort(int port);
+LIBRARY_API void udaPutServerPort(int port);
 
-LIBRARY_API void putUdaServerSocket(int socket);
+LIBRARY_API void udaPutServerSocket(int socket);
 
-LIBRARY_API void getUdaServer(const char** host, int* port, int* socket);
+LIBRARY_API void udaGetServer(const char** host, int* port, int* socket);
 
-LIBRARY_API UDA_ERROR_STACK* getUdaServerErrorStack();
+LIBRARY_API UDA_ERROR_STACK* udaGetServerErrorStack();
 
-LIBRARY_API int getUdaErrorCode(int handle);
+LIBRARY_API int udaGetErrorCode(int handle);
 
-LIBRARY_API const char* getUdaErrorMsg(int handle);
+LIBRARY_API const char* udaGetErrorMsg(int handle);
 
-LIBRARY_API int getUdaSourceStatus(int handle);
+LIBRARY_API int udaGetSourceStatus(int handle);
 
-LIBRARY_API int getUdaSignalStatus(int handle);
+LIBRARY_API int udaGetSignalStatus(int handle);
 
-LIBRARY_API int getUdaDataStatus(int handle);
+LIBRARY_API int udaGetDataStatus(int handle);
 
-LIBRARY_API int getUdaLastHandle(CLIENT_FLAGS* client_flags);
+LIBRARY_API int udaGetLastHandle();
 
-LIBRARY_API int getUdaDataNum(int handle);
+LIBRARY_API int udaGetDataNum(int handle);
 
-LIBRARY_API int getUdaRank(int handle);
+LIBRARY_API int udaGetRank(int handle);
 
-LIBRARY_API int getUdaOrder(int handle);
+LIBRARY_API int udaGetOrder(int handle);
 
-LIBRARY_API unsigned int getUdaCachePermission(int handle);
+LIBRARY_API unsigned int udaGetCachePermission(int handle);
 
-LIBRARY_API unsigned int getUdaTotalDataBlockSize(int handle);
+LIBRARY_API unsigned int udaGetTotalDataBlockSize(int handle);
 
-LIBRARY_API int getUdaDataType(int handle);
+LIBRARY_API int udaGetDataType(int handle);
 
-LIBRARY_API int getUdaDataOpaqueType(int handle);
+LIBRARY_API int udaGetDataOpaqueType(int handle);
 
-LIBRARY_API void* getUdaDataOpaqueBlock(int handle);
+LIBRARY_API void* udaGetDataOpaqueBlock(int handle);
 
-LIBRARY_API int getUdaDataOpaqueCount(int handle);
+LIBRARY_API int udaGetDataOpaqueCount(int handle);
 
-LIBRARY_API void getUdaErrorModel(int handle, int* model, int* param_n, float* params);
+LIBRARY_API void udaGetErrorModel(int handle, int* model, int* param_n, float* params);
 
-LIBRARY_API int getUdaErrorType(int handle);
+LIBRARY_API int udaGetErrorType(int handle);
 
-LIBRARY_API int getUdaDataTypeId(const char* type);
+LIBRARY_API int udaGetDataTypeId(const char* type);
 
-LIBRARY_API int getUdaDataTypeSize(int type);
+LIBRARY_API int udaGetDataTypeSize(int type);
 
-LIBRARY_API void getUdaErrorModel(int handle, int* model, int* param_n, float* params);
+LIBRARY_API void udaGetErrorModel(int handle, int* model, int* param_n, float* params);
 
-LIBRARY_API int getUdaErrorAsymmetry(int handle);
+LIBRARY_API int udaGetErrorAsymmetry(int handle);
 
-LIBRARY_API int getUdaErrorModelId(const char* model);
+LIBRARY_API int udaGetErrorModelId(const char* model);
 
-LIBRARY_API char* acc_getSyntheticData(int handle);
+LIBRARY_API char* udaGetSyntheticData(int handle);  
 
-LIBRARY_API char* acc_getSyntheticDimData(int handle, int ndim);
+LIBRARY_API char* udaGetSyntheticDimData(int handle, int ndim);  
 
-LIBRARY_API void acc_setSyntheticData(int handle, char* data);
+LIBRARY_API void udaSetSyntheticData(int handle, char* data);  
 
-LIBRARY_API void acc_setSyntheticDimData(int handle, int ndim, char* data);
+LIBRARY_API void udaSetSyntheticDimData(int handle, int ndim, char* data);  
 
-LIBRARY_API char* getUdaSyntheticData(int handle);
+LIBRARY_API char* udaGetSyntheticData(int handle);
 
-LIBRARY_API char* getUdaData(int handle);
+LIBRARY_API char* udaGetData(int handle);
 
-LIBRARY_API void getUdaDataTdi(int handle, char* data);
+LIBRARY_API void udaGetDataTdi(int handle, char* data);
 
-LIBRARY_API char* getUdaAsymmetricError(int handle, int above);
+LIBRARY_API char* udaGetAsymmetricError(int handle, int above);
 
-LIBRARY_API char* getUdaDataErrLo(int handle);
+LIBRARY_API char* udaGetDataErrLo(int handle);
 
-LIBRARY_API char* getUdaDataErrHi(int handle);
+LIBRARY_API char* udaGetDataErrHi(int handle);
 
-LIBRARY_API int getUdaDataErrAsymmetry(int handle);
+LIBRARY_API int udaGetDataErrAsymmetry(int handle);
 
-LIBRARY_API void acc_setUdaDataErrAsymmetry(int handle, int asymmetry);
+LIBRARY_API void udaSetDataErrAsymmetry(int handle, int asymmetry);  
 
-LIBRARY_API void acc_setUdaDataErrType(int handle, int type);
+LIBRARY_API void udaSetDataErrType(int handle, int type);  
 
-LIBRARY_API void acc_setUdaDataErrLo(int handle, char* errlo);
+LIBRARY_API void udaSetDataErrLo(int handle, char* errlo);  
 
-LIBRARY_API char* getUdaDimErrLo(int handle, int ndim);
+LIBRARY_API char* udaGetDimErrLo(int handle, int ndim);
 
-LIBRARY_API char* getUdaDimErrHi(int handle, int ndim);
+LIBRARY_API char* udaGetDimErrHi(int handle, int ndim);
 
-LIBRARY_API int getUdaDimErrAsymmetry(int handle, int ndim);
+LIBRARY_API int udaGetDimErrAsymmetry(int handle, int ndim);
 
-LIBRARY_API void acc_setUdaDimErrAsymmetry(int handle, int ndim, int asymmetry);
+LIBRARY_API void udaSetDimErrAsymmetry(int handle, int ndim, int asymmetry);  
 
-LIBRARY_API void acc_setUdaDimErrType(int handle, int ndim, int type);
+LIBRARY_API void udaSetDimErrType(int handle, int ndim, int type);  
 
-LIBRARY_API void acc_setUdaDimErrLo(int handle, int ndim, char* errlo);
+LIBRARY_API void udaSetDimErrLo(int handle, int ndim, char* errlo);  
 
-LIBRARY_API char* getUdaError(int handle);
+LIBRARY_API char* udaGetError(int handle);
 
-LIBRARY_API void getUdaDoubleData(int handle, double* fp);
+LIBRARY_API void udaGetDoubleData(int handle, double* fp);
 
-LIBRARY_API void getUdaFloatData(int handle, float* fp);
+LIBRARY_API void udaGetFloatData(int handle, float* fp);
 
-LIBRARY_API void getUdaGenericData(int handle, void* data);
+LIBRARY_API void udaGetGenericData(int handle, void* data);
 
-LIBRARY_API void getUdaFloatAsymmetricError(int handle, int above, float* fp);
+LIBRARY_API void udaGetFloatAsymmetricError(int handle, int above, float* fp);
 
-LIBRARY_API void getUdaFloatError(int handle, float* fp);
+LIBRARY_API void udaGetFloatError(int handle, float* fp);
 
-LIBRARY_API void getUdaDBlock(int handle, DATA_BLOCK* db);
+LIBRARY_API void udaGetDBlock(int handle, DATA_BLOCK* db);
 
-LIBRARY_API DATA_BLOCK* getUdaDataBlock(int handle);
+LIBRARY_API DATA_BLOCK* udaGetDataBlock(int handle);
 
-LIBRARY_API const char* getUdaDataLabel(int handle);
+LIBRARY_API const char* udaGetDataLabel(int handle);
 
-LIBRARY_API void getUdaDataLabelTdi(int handle, char* label);
+LIBRARY_API void udaGetDataLabelTdi(int handle, char* label);
 
-LIBRARY_API const char* getUdaDataUnits(int handle);
+LIBRARY_API const char* udaGetDataUnits(int handle);
 
-LIBRARY_API void getUdaDataUnitsTdi(int handle, char* units);
+LIBRARY_API void udaGetDataUnitsTdi(int handle, char* units);
 
-LIBRARY_API const char* getUdaDataDesc(int handle);
+LIBRARY_API const char* udaGetDataDesc(int handle);
 
-LIBRARY_API void getUdaDataDescTdi(int handle, char* desc);
+LIBRARY_API void udaGetDataDescTdi(int handle, char* desc);
 
-LIBRARY_API int getUdaDimNum(int handle, int ndim);
+LIBRARY_API int udaGetDimNum(int handle, int ndim);
 
-LIBRARY_API int getUdaDimType(int handle, int ndim);
+LIBRARY_API int udaGetDimType(int handle, int ndim);
 
-LIBRARY_API int getUdaDimErrorType(int handle, int ndim);
+LIBRARY_API int udaGetDimErrorType(int handle, int ndim);
 
-LIBRARY_API int getUdaDimErrorAsymmetry(int handle, int ndim);
+LIBRARY_API int udaGetDimErrorAsymmetry(int handle, int ndim);
 
-LIBRARY_API void getUdaDimErrorModel(int handle, int ndim, int* model, int* param_n, float* params);
+LIBRARY_API void udaGetDimErrorModel(int handle, int ndim, int* model, int* param_n, float* params);
 
-LIBRARY_API char* getUdaSyntheticDimData(int handle, int ndim);
+LIBRARY_API char* udaGetSyntheticDimData(int handle, int ndim);
 
-LIBRARY_API char* getUdaDimData(int handle, int ndim);
+LIBRARY_API char* udaGetDimData(int handle, int ndim);
 
-LIBRARY_API const char* getUdaDimLabel(int handle, int ndim);
+LIBRARY_API const char* udaGetDimLabel(int handle, int ndim);
 
-LIBRARY_API const char* getUdaDimUnits(int handle, int ndim);
+LIBRARY_API const char* udaGetDimUnits(int handle, int ndim);
 
-LIBRARY_API void getUdaDimLabelTdi(int handle, int ndim, char* label);
+LIBRARY_API void udaGetDimLabelTdi(int handle, int ndim, char* label);
 
-LIBRARY_API void getUdaDimUnitsTdi(int handle, int ndim, char* units);
+LIBRARY_API void udaGetDimUnitsTdi(int handle, int ndim, char* units);
 
-LIBRARY_API void getUdaDoubleDimData(int handle, int ndim, double* fp);
+LIBRARY_API void udaGetDoubleDimData(int handle, int ndim, double* fp);
 
-LIBRARY_API void getUdaFloatDimData(int handle, int ndim, float* fp);
+LIBRARY_API void udaGetFloatDimData(int handle, int ndim, float* fp);
 
-LIBRARY_API void getUdaGenericDimData(int handle, int ndim, void* data);
+LIBRARY_API void udaGetGenericDimData(int handle, int ndim, void* data);
 
-LIBRARY_API DIMS* getUdaDimBlock(int handle, int ndim);
+LIBRARY_API DIMS* udaGetDimBlock(int handle, int ndim);
 
-LIBRARY_API char* getUdaDimAsymmetricError(int handle, int ndim, int above);
+LIBRARY_API char* udaGetDimAsymmetricError(int handle, int ndim, int above);
 
-LIBRARY_API char* getUdaDimError(int handle, int ndim);
+LIBRARY_API char* udaGetDimError(int handle, int ndim);
 
-LIBRARY_API void getUdaFloatDimAsymmetricError(int handle, int ndim, int above, float* fp);
+LIBRARY_API void udaGetFloatDimAsymmetricError(int handle, int ndim, int above, float* fp);
 
-LIBRARY_API void getUdaFloatDimError(int handle, int ndim, float* fp);
+LIBRARY_API void udaGetFloatDimError(int handle, int ndim, float* fp);
 
-LIBRARY_API DATA_SYSTEM* getUdaDataSystem(int handle);
+LIBRARY_API DATA_SYSTEM* udaGetDataSystem(int handle);
 
-LIBRARY_API SYSTEM_CONFIG* getUdaSystemConfig(int handle);
+LIBRARY_API SYSTEM_CONFIG* udaGetSystemConfig(int handle);
 
-LIBRARY_API DATA_SOURCE* getUdaDataSource(int handle);
+LIBRARY_API DATA_SOURCE* udaGetDataSource(int handle);
 
-LIBRARY_API SIGNAL* getUdaSignal(int handle);
+LIBRARY_API SIGNAL* udaGetSignal(int handle);
 
-LIBRARY_API SIGNAL_DESC* getUdaSignalDesc(int handle);
+LIBRARY_API SIGNAL_DESC* udaGetSignalDesc(int handle);
 
-LIBRARY_API const char* getUdaFileFormat(int handle);
+LIBRARY_API const char* udaGetFileFormat(int handle);
 
-LIBRARY_API void initUdaDataBlock(DATA_BLOCK* str);
+LIBRARY_API void udaInitDataBlock(DATA_BLOCK* str);
 
-LIBRARY_API void initUdaRequestBlock(REQUEST_BLOCK* str);
+LIBRARY_API void udaInitRequestBlock(REQUEST_BLOCK* str);
 
-LIBRARY_API int idamDataCheckSum(void* data, int data_n, int type);
+LIBRARY_API int udaDataCheckSum(void* data, int data_n, int type);
 
-LIBRARY_API int getUdaDataCheckSum(int handle);
+LIBRARY_API int udaGetDataCheckSum(int handle);
 
-LIBRARY_API int getUdaDimDataCheckSum(int handle, int ndim);
+LIBRARY_API int udaGetDimDataCheckSum(int handle, int ndim);
 
-LIBRARY_API void lockUdaThread(CLIENT_FLAGS* client_flags);
+LIBRARY_API void udaLockThread();
 
-LIBRARY_API void unlockUdaThread(CLIENT_FLAGS* client_flags);
+LIBRARY_API void udaUnlockThread();
 
-LIBRARY_API void freeUdaThread(CLIENT_FLAGS* client_flags);
+LIBRARY_API void udaFreeThread();
 
-LIBRARY_API int getUdaThreadLastHandle();
+LIBRARY_API int udaGetThreadLastHandle();
 
-LIBRARY_API void putUdaThreadLastHandle(int handle);
+LIBRARY_API void udaPutThreadLastHandle(int handle);
 
-LIBRARY_API int getUdaMaxThreadCount();
+LIBRARY_API int udaGetMaxThreadCount();
 
-LIBRARY_API SERVER_BLOCK getUdaThreadServerBlock();
+LIBRARY_API SERVER_BLOCK udaGetThreadServerBlock();
 
-LIBRARY_API CLIENT_BLOCK getUdaThreadClientBlock();
+LIBRARY_API CLIENT_BLOCK udaGetThreadClientBlock();
 
-LIBRARY_API void putUdaThreadServerBlock(SERVER_BLOCK* str);
+LIBRARY_API void udaPutThreadServerBlock(SERVER_BLOCK* str);
 
-LIBRARY_API void putUdaThreadClientBlock(CLIENT_BLOCK* str);
+LIBRARY_API void udaPutThreadClientBlock(CLIENT_BLOCK* str);
 
-LIBRARY_API int setUdaDataTree(int handle);
+LIBRARY_API int udaSetDataTree(int handle);
 
 // Return a specific data tree
 
-LIBRARY_API NTREE* getUdaDataTree(int handle);
+LIBRARY_API NTREE* udaGetDataTree(int handle);
 
 // Return a user defined data structure definition
 
-LIBRARY_API USERDEFINEDTYPE* getUdaUserDefinedType(int handle);
+LIBRARY_API USERDEFINEDTYPE* udaGetUserDefinedType(int handle);
 
-LIBRARY_API USERDEFINEDTYPELIST* getUdaUserDefinedTypeList(int handle);
+LIBRARY_API USERDEFINEDTYPELIST* udaGetUserDefinedTypeList(int handle);
 
-LIBRARY_API LOGMALLOCLIST* getUdaLogMallocList(int handle);
+LIBRARY_API LOGMALLOCLIST* udaGetLogMallocList(int handle);
 
-LIBRARY_API NTREE* findUdaNTreeStructureDefinition(NTREE* node, const char* target);
+LIBRARY_API NTREE* udaFindNTreeStructureDefinition(NTREE* node, const char* target);
 
 #ifdef __cplusplus
 }
diff --git a/source/include/accessors.h b/source/include/accessors.h
index 9332b1f0..5f8151be 100644
--- a/source/include/accessors.h
+++ b/source/include/accessors.h
@@ -119,7 +119,7 @@ LIBRARY_API NTREE* findNTreeStructureComponentDefinition(NTREE* tree, const char
  * @param class The Structure Class, e.g., UDA_TYPE_VLEN.
  * @return A pointer to the First tree node found with the targeted structure class.
  */
-LIBRARY_API NTREE* idam_findNTreeStructureClass(NTREE* tree, int cls);
+LIBRARY_API NTREE* udaFindNTreeStructureClass(NTREE* tree, int cls);
 
 /** Identify the largest count of a Variable Length Array with a given structure type.
  *
@@ -130,7 +130,7 @@ LIBRARY_API NTREE* idam_findNTreeStructureClass(NTREE* tree, int cls);
  * @param reset Reset the counbter to zero.
  * @return An integer returning the maximum count value.
  */
-LIBRARY_API int idam_maxCountVlenStructureArray(NTREE* tree, const char* target, int reset);
+LIBRARY_API int udaMaxCountVlenStructureArray(NTREE* tree, const char* target, int reset);
 
 /** Regularise a specific VLEN structure.
  *
@@ -141,7 +141,7 @@ LIBRARY_API int idam_maxCountVlenStructureArray(NTREE* tree, const char* target,
  * @param count The maximum count size for the VLEN data arrays.
  * @return An integer returning an error code: 0 => OK.
  */
-LIBRARY_API int idam_regulariseVlenStructures(LOGMALLOCLIST* logmalloclist, NTREE* tree,
+LIBRARY_API int udaRegulariseVlenStructures(LOGMALLOCLIST* logmalloclist, NTREE* tree,
                                               USERDEFINEDTYPELIST* userdefinedtypelist, const char* target,
                                               unsigned int count);
 
@@ -153,7 +153,7 @@ LIBRARY_API int idam_regulariseVlenStructures(LOGMALLOCLIST* logmalloclist, NTRE
  * @param tree A pointer to a parent tree node. If NULL the root node is assumed.
  * @return An integer returning an error code: 0 => OK.
  */
-LIBRARY_API int idam_regulariseVlenData(LOGMALLOCLIST* logmalloclist, NTREE* tree,
+LIBRARY_API int udaRegulariseVlenData(LOGMALLOCLIST* logmalloclist, NTREE* tree,
                                         USERDEFINEDTYPELIST* userdefinedtypelist);
 
 //---------------------------------------------------------------------------------------------
diff --git a/source/include/client.h b/source/include/client.h
index 05793474..fc0cc8ed 100644
--- a/source/include/client.h
+++ b/source/include/client.h
@@ -74,39 +74,39 @@ LIBRARY_API const char* udaGetBuildVersion();
  */
 LIBRARY_API const char* udaGetBuildDate();
 
-LIBRARY_API const char* getUdaServerHost();
+LIBRARY_API const char* udaGetServerHost(); 
 
-LIBRARY_API int getUdaServerPort();
+LIBRARY_API int udaGetServerPort(); 
 
-LIBRARY_API int getUdaServerSocket();
+LIBRARY_API int udaGetServerSocket(); 
 
-LIBRARY_API const char* getUdaClientDOI();
+LIBRARY_API const char* udaGetClientDOI(); 
 
-LIBRARY_API const char* getUdaServerDOI();
+LIBRARY_API const char* udaGetServerDOI(); 
 
-LIBRARY_API const char* getUdaClientOSName();
+LIBRARY_API const char* udaGetClientOSName(); 
 
-LIBRARY_API const char* getUdaServerOSName();
+LIBRARY_API const char* udaGetServerOSName(); 
 
-LIBRARY_API int getUdaClientVersion();
+LIBRARY_API int udaGetClientVersion(); 
 
-LIBRARY_API int getUdaServerVersion();
+LIBRARY_API int udaGetServerVersion(); 
 
-LIBRARY_API int getUdaServerErrorCode();
+LIBRARY_API int udaGetServerErrorCode(); 
 
-LIBRARY_API const char* getUdaServerErrorMsg();
+LIBRARY_API const char* udaGetServerErrorMsg(); 
 
-LIBRARY_API int getUdaServerErrorStackSize();
+LIBRARY_API int udaGetServerErrorStackSize(); 
 
-LIBRARY_API int getUdaServerErrorStackRecordType(int record);
+LIBRARY_API int udaGetServerErrorStackRecordType(int record); 
 
-LIBRARY_API int getUdaServerErrorStackRecordCode(int record);
+LIBRARY_API int udaGetServerErrorStackRecordCode(int record); 
 
-LIBRARY_API const char* getUdaServerErrorStackRecordLocation(int record);
+LIBRARY_API const char* udaGetServerErrorStackRecordLocation(int record); 
 
-LIBRARY_API const char* getUdaServerErrorStackRecordMsg(int record);
+LIBRARY_API const char* udaGetServerErrorStackRecordMsg(int record); 
 
-LIBRARY_API void closeAllConnections();
+LIBRARY_API void udaCloseAllConnections();
 
 #ifdef __cplusplus
 }
diff --git a/source/include/clientMDS.h b/source/include/clientMDS.h
index dada6293..da4ad244 100644
--- a/source/include/clientMDS.h
+++ b/source/include/clientMDS.h
@@ -7,7 +7,7 @@
 extern "C" {
 #endif
 
-LIBRARY_API int idamClientMDS(const char* server, const char* tree, const char* node, int treenum);
+LIBRARY_API int udaClientMDS(const char* server, const char* tree, const char* node, int treenum);
 
 #ifdef __cplusplus
 }
diff --git a/source/include/errorLog.h b/source/include/errorLog.h
index 806199a7..0fd2e0f3 100644
--- a/source/include/errorLog.h
+++ b/source/include/errorLog.h
@@ -20,13 +20,13 @@ extern "C" {
 
 LIBRARY_API int udaNumErrors(void);
 LIBRARY_API void udaErrorLog(CLIENT_BLOCK client_block, REQUEST_BLOCK request_block, UDA_ERROR_STACK* error_stack);
-LIBRARY_API void initUdaErrorStack(void);
-LIBRARY_API void initErrorRecords(const UDA_ERROR_STACK* errorstack);
-LIBRARY_API void printIdamErrorStack(void);
-LIBRARY_API void addIdamError(int type, const char* location, int code, const char* msg);
-LIBRARY_API void concatUdaError(UDA_ERROR_STACK* errorstackout);
-LIBRARY_API void freeIdamErrorStack(UDA_ERROR_STACK* errorstack);
-LIBRARY_API void closeUdaError(void);
+LIBRARY_API void udaInitErrorStack(void);
+LIBRARY_API void udaInitErrorRecords(const UDA_ERROR_STACK* errorstack);
+LIBRARY_API void udaPrintErrorStack(void);
+LIBRARY_API void udaAddError(int type, const char* location, int code, const char* msg);
+LIBRARY_API void udaConcatError(UDA_ERROR_STACK* errorstackout);
+LIBRARY_API void udaFreeErrorStack(UDA_ERROR_STACK* errorstack);
+LIBRARY_API void udaCloseError(void);
 
 #ifdef __cplusplus
 }
diff --git a/source/include/legacy.h b/source/include/legacy.h
index 41509cf6..919ed564 100644
--- a/source/include/legacy.h
+++ b/source/include/legacy.h
@@ -5,6 +5,8 @@
 
 #  warning "using UDA legacy name mappings"
 
+// TODO: address embedded todos...
+
 /*
  * definitions from pluginStructs.h
  */
@@ -173,18 +175,46 @@ inline int idamClientMDS(const char* server, const char* tree, const char* node,
 /*
  * NO IDAM KEYWORD
  */
-// LIBRARY_API DATA_BLOCK* acc_getCurrentDataBlock(CLIENT_FLAGS* client_flags);
-// LIBRARY_API int acc_getCurrentDataBlockIndex(CLIENT_FLAGS* client_flags);
-// LIBRARY_API void acc_freeDataBlocks();
 // LIBRARY_API UDA_ERROR_STACK* getUdaServerErrorStack();
-// LIBRARY_API char* acc_getSyntheticData(int handle);
-// LIBRARY_API char* acc_getSyntheticDimData(int handle, int ndim);
-// LIBRARY_API void acc_setSyntheticData(int handle, char* data);
-// LIBRARY_API void acc_setSyntheticDimData(int handle, int ndim, char* data);
+
+inline DATA_BLOCK* acc_getCurrentDataBlock()
+{
+    return udaGetCurrentDataBlock();
+}
+
+inline int acc_getCurrentDataBlockIndex()
+{
+    return udaGetCurrentDataBlockIndex();
+}
+
+inline void acc_freeDataBlocks()
+{
+    return udaFreeDataBlocks();
+}
+
+inline char* acc_getSyntheticData(int handle)
+{
+    return udaGetSyntheticData(handle); ;
+}
+
+inline char* acc_getSyntheticDimData(int handle, int ndim)
+{
+    return udaGetSyntheticDimData(handle, ndim);
+}
+
+inline void acc_setSyntheticData(int handle, char* data)
+{
+    return udaSetSyntheticData(handle, data);
+}
+
+inline void acc_setSyntheticDimData(int handle, int ndim, char* data)
+{
+    return udaSetSyntheticDimData(int handle, int ndim, char* data);
+}
 
 inline int acc_growIdamDataBlocks()
 {
-    return acc_growUdaDataBlocks();
+    return udaGrowDataBlocks();
 }
 
 inline int acc_getIdamNewDataHandle()
@@ -769,15 +799,11 @@ inline int setIdamDataTree(int handle)
     return setUdaDataTree(handle);
 }
 
-// Return a specific data tree
-
 inline NTREE* getIdamDataTree(int handle)
 {
     return getUdaDataTree(handle);
 }
 
-// Return a user defined data structure definition
-
 inline USERDEFINEDTYPE* getIdamUserDefinedType(int handle)
 {
     return getUdaUserDefinedType(handle);
@@ -827,6 +853,8 @@ inline int idamClientTestAPI(const char* file, const char* signal, int pass, int
  * definitions from accessors.h
  */
 
+// TODO: these are used by plugins and wrappers only so don't need to be shadowed? 
+
 // LIBRARY_API NTREE* findNTreeStructureComponent2(LOGMALLOCLIST* logmalloclist, NTREE* ntree, const char* target,
 //                                                 const char** lastname);
 // LIBRARY_API NTREE* findNTreeStructure2(LOGMALLOCLIST* logmalloclist, NTREE* ntree, const char* target,
@@ -841,19 +869,19 @@ inline int idamClientTestAPI(const char* file, const char* signal, int pass, int
 
 inline NTREE* idam_findNTreeStructureClass(NTREE * tree, int cls)
 {
-    return uda_findNTreeStructureClass(tree, cls);
+    return udaFindNTreeStructureClass(tree, cls);
 }
 
 inline int idam_maxCountVlenStructureArray(NTREE * tree, const char* target, int reset)
 {
-    return uda_maxCountVlenStructureArray(tree, target, reset);
+    return udaMaxCountVlenStructureArray(tree, target, reset);
 }
 
 inline int idam_regulariseVlenStructures(LOGMALLOCLIST * logmalloclist, NTREE * tree,
                                          USERDEFINEDTYPELIST * userdefinedtypelist, const char* target,
                                          unsigned int count)
 {
-    return uda_regulariseVlenStructures(LOGMALLOCLIST * logmalloclist, NTREE * tree,
+    return udaRegulariseVlenStructures(LOGMALLOCLIST * logmalloclist, NTREE * tree,
                                         USERDEFINEDTYPELIST * userdefinedtypelist, const char* target,
                                         unsigned int count);
 }
@@ -861,7 +889,7 @@ inline int idam_regulariseVlenStructures(LOGMALLOCLIST * logmalloclist, NTREE *
 inline int idam_regulariseVlenData(LOGMALLOCLIST * logmalloclist, NTREE * tree,
                                    USERDEFINEDTYPELIST * userdefinedtypelist)
 {
-    return uda_regulariseVlenData(LOGMALLOCLIST * logmalloclist, NTREE * tree,
+    return udaRegulariseVlenData(LOGMALLOCLIST * logmalloclist, NTREE * tree,
                                   USERDEFINEDTYPELIST * userdefinedtypelist);
 }
 //
diff --git a/source/include/pluginStructs.h b/source/include/pluginStructs.h
index 949278da..186d254d 100644
--- a/source/include/pluginStructs.h
+++ b/source/include/pluginStructs.h
@@ -23,7 +23,7 @@ enum pluginClass {
 struct PluginList; // Forward declaration
 typedef struct PluginList PLUGINLIST;
 
-typedef struct IdamPluginInterface {  // Standard Plugin interface
+typedef struct UdaluginInterface {  // Standard Plugin interface
     unsigned short interfaceVersion;  // Interface Version
     unsigned short pluginVersion;     // Plugin Version
     unsigned short sqlConnectionType; // Which SQL is the server connected to
@@ -43,9 +43,9 @@ typedef struct IdamPluginInterface {  // Standard Plugin interface
     void* sqlConnection;          // Opaque structure
     const PLUGINLIST* pluginList; // List of data readers, filters, models, and servers
     UDA_ERROR_STACK error_stack;
-} IDAM_PLUGIN_INTERFACE;
+} UDA_PLUGIN_INTERFACE;
 
-typedef int (*PLUGINFUNP)(IDAM_PLUGIN_INTERFACE*); // Plugin function type
+typedef int (*PLUGINFUNP)(UDA_PLUGIN_INTERFACE*); // Plugin function type
 
 typedef struct PluginData {
     char format[STRING_LENGTH];         // File format, or Function library or Server protocol or External Device name