diff --git a/site_ansto/ansto_tclmotdriv.c b/site_ansto/ansto_tclmotdriv.c
index 3f6b7859..35dbd328 100644
--- a/site_ansto/ansto_tclmotdriv.c
+++ b/site_ansto/ansto_tclmotdriv.c
@@ -19,10 +19,11 @@
   facilitate error handling, a motor parameter errorcode is available to
   store errors between invocations.
 
- copyright: see file COPYRIGHT
+ Author: Jing Chen, Nov 2012
 
- Mark Koennecke, December 2005
+ copyright: see file COPYRIGHT
  --------------------------------------------------------------------------*/
+
 #include <stdlib.h>
 #include <assert.h>
 #include <string.h>
@@ -63,21 +64,24 @@ static int buildStandardCommandPart(TCLDriv *pDriv, char *command,
 /*----------------------------------------------------------------------------*/
   static int GetTclPos(void *self, float *fPos){
     TCLDriv *pDriv;
-    char tclCommand[1024];    
     int status;
     const char *result = NULL; 
  
     assert(self);
     pDriv = (TCLDriv *)self;
 
+    char *tclCommand = (char *)calloc(1024, sizeof(char)); 
+
     pDriv->errorCode = 0;
     if(!buildStandardCommandPart(pDriv,"getpos",tclCommand,1023)){
  	pDriv->errorCode = FUNCNOTFOUND;
+        free(tclCommand);
 	return HWFault;
     }
 
     status = Tcl_Eval(pServ->pSics->pTcl,tclCommand);
     result = Tcl_GetStringResult(pServ->pSics->pTcl);
+    free(tclCommand);
     if(result == NULL){
 	pDriv->errorCode = NOTCLRESULT;
         return HWFault;
@@ -93,7 +97,6 @@ static int buildStandardCommandPart(TCLDriv *pDriv, char *command,
 /*----------------------------------------------------------------------------*/
   static int TclRun(void *self, float fVal) {
     TCLDriv *pDriv;
-    char tclCommand[1024];    
     char num[80];
     int status;
     const char *result = NULL;
@@ -101,9 +104,12 @@ static int buildStandardCommandPart(TCLDriv *pDriv, char *command,
     assert(self);
     pDriv = (TCLDriv *)self;
 
+    char *tclCommand = (char *)calloc(1024, sizeof(char));    
+
     pDriv->errorCode = 0;
     if(!buildStandardCommandPart(pDriv,"run",tclCommand,1023)){
 	pDriv->errorCode = FUNCNOTFOUND;
+        free(tclCommand);
 	return HWFault;
     }
     snprintf(num,79,"%f",fVal);
@@ -111,6 +117,7 @@ static int buildStandardCommandPart(TCLDriv *pDriv, char *command,
 
     status = Tcl_Eval(pServ->pSics->pTcl,tclCommand);
     result = Tcl_GetStringResult(pServ->pSics->pTcl);
+    free(tclCommand);
     if(result == NULL) {
 	pDriv->errorCode = NOTCLRESULT;
         return HWFault;
@@ -149,9 +156,8 @@ static int evaluateInternalErrors(TCLDriv *pDriv, int *iCode,
     return 0;
 } 
 /*--------------------------------------------------------------------------*/
-  static void TclError(void *self, int *iCode, char *error, int iErrLen){
+  static void TclGetError(void *self, int *iCode, char *error, int iErrLen){
     TCLDriv *pDriv;
-    char tclCommand[1024];    
     int status = 1;
     const char *result = NULL;
   
@@ -162,6 +168,8 @@ static int evaluateInternalErrors(TCLDriv *pDriv, int *iCode,
 	return;
     }
 
+    char *tclCommand = (char *)calloc(1024, sizeof(char)); 
+
     if(!buildStandardCommandPart(pDriv,"geterror",tclCommand,1023)){
 	pDriv->errorCode = FUNCNOTFOUND;
 	status = 0;
@@ -180,14 +188,16 @@ static int evaluateInternalErrors(TCLDriv *pDriv, int *iCode,
     }
 
     if(evaluateInternalErrors(pDriv,iCode,error,iErrLen) == 1) {
-	return;
+      free(tclCommand);
+      return;
     }
+    free(tclCommand);
     strncpy(error,result,iErrLen);
   }
+
 /*---------------------------------------------------------------------------*/
-  static int TclFix(void *self, int iError, float fNew){
+  static int TclTryAndFixIt(void *self, int iError, float fNew){
     TCLDriv *pDriv;
-    char tclCommand[1024];    
     char num[80];
     int status;
     const char *result = NULL;
@@ -195,8 +205,11 @@ static int evaluateInternalErrors(TCLDriv *pDriv, int *iCode,
     assert(self);
     pDriv = (TCLDriv *)self;
 
+    char *tclCommand = (char *)calloc(1024, sizeof(char));
+
     if(!buildStandardCommandPart(pDriv,"fixit",tclCommand,1023)){
 	pDriv->errorCode = FUNCNOTFOUND;
+        free(tclCommand);
 	return HWFault;
     }
     snprintf(num,79,"%d %f",pDriv->errorCode, fNew);
@@ -206,21 +219,24 @@ static int evaluateInternalErrors(TCLDriv *pDriv, int *iCode,
     result = Tcl_GetStringResult(pServ->pSics->pTcl);
     if(result == NULL) {
 	pDriv->errorCode = NOTCLRESULT;
+        free(tclCommand);
         return HWFault;
     }
     if(status != TCL_OK){
 	pDriv->errorCode = TCLERROR;
         strncpy(pDriv->tclError,result,1023);
+        free(tclCommand);
         return HWFault;
     }
     sscanf(result,"%d",&status);
+    free(tclCommand);
     return status;
   }
+
 /*--------------------------------------------------------------------------*/
   static int TclHalt(void *self)
   {
     TCLDriv *pDriv;
-    char tclCommand[1024];    
     int status;
     const char *result = NULL; 
  
@@ -228,8 +244,12 @@ static int evaluateInternalErrors(TCLDriv *pDriv, int *iCode,
     pDriv = (TCLDriv *)self;
 
     pDriv->errorCode = 0;
+
+    char *tclCommand = (char *)calloc(1024, sizeof(char));
+
     if(!buildStandardCommandPart(pDriv,"halt",tclCommand,1023)){
  	pDriv->errorCode = FUNCNOTFOUND;
+        free(tclCommand);
 	return HWFault;
     }
 
@@ -237,20 +257,23 @@ static int evaluateInternalErrors(TCLDriv *pDriv, int *iCode,
     result = Tcl_GetStringResult(pServ->pSics->pTcl);
     if(result == NULL){
 	pDriv->errorCode = NOTCLRESULT;
+        free(tclCommand);
         return HWFault;
     }
     if(status != TCL_OK){
 	pDriv->errorCode = TCLERROR;
         strncpy(pDriv->tclError,result,1023);
+        free(tclCommand);
         return HWFault;
     }
+    free(tclCommand);
     return OKOK;
   }
+
 /*--------------------------------------------------------------------------*/
-  static int TclStat(void *self)
+  static int TclGetStatus(void *self)
   {
     TCLDriv *pDriv;
-    char tclCommand[1024];    
     int status;
     const char *result = NULL; 
  
@@ -258,8 +281,12 @@ static int evaluateInternalErrors(TCLDriv *pDriv, int *iCode,
     pDriv = (TCLDriv *)self;
 
     pDriv->errorCode = 0;
+
+    char *tclCommand = (char *)calloc(1024, sizeof(char));
+
     if(!buildStandardCommandPart(pDriv,"status",tclCommand,1023)){
  	pDriv->errorCode = FUNCNOTFOUND;
+        free(tclCommand);
 	return HWFault;
     }
 
@@ -267,16 +294,20 @@ static int evaluateInternalErrors(TCLDriv *pDriv, int *iCode,
     result = Tcl_GetStringResult(pServ->pSics->pTcl);
     if(result == NULL){
 	pDriv->errorCode = NOTCLRESULT;
+        free(tclCommand);
         return HWFault;
     }
     if(status != TCL_OK){
 	pDriv->errorCode = TCLERROR;
         strncpy(pDriv->tclError,result,1023);
+        free(tclCommand);
         return HWFault;
     }
     sscanf(result,"%d",&status);
+    free(tclCommand);
     return status;
   }
+
 /*-----------------------------------------------------------------------*/
 static int TclSetPar(void *self, SConnection *pCon, char *name, float newValue){
 
@@ -361,12 +392,20 @@ static int TclListPar(void *self, char *motorname, SConnection *pCon) {
       count++;
     }
     if(flag==0) {
-      snprintf(pBueffel,511,"%s.%s = %f",motorname,sVal.name,sVal.value);
-      SCWrite(pCon,pBueffel,eValue);
+      int   ret;
+      float value;
+      ret = TclGetPar(self, sVal.name, &value);
+      if (ret != OKOK) {
+        return ret;
+      } else {
+	snprintf(pBueffel,511,"%s.%s = %f",motorname,sVal.name,value);
+	SCWrite(pCon,pBueffel,eValue);
+      }
     }
     iRet = LLDnodePtr2Next(pDriv->mappings->iList);
   }
 
+  return OKOK;
 }
 
 
@@ -440,7 +479,8 @@ static int assignMappings(TCLDriv *pDriv, SConnection *pCon, char *arrayName){
     return OKOK;
   } else {
     unsigned char ps=0;
-    char *pch, *funcName;
+    char *pch;
+    char *funcName = (char *)calloc(1024, sizeof(char));
 
     pch = strtok(arrayName, "{}");
     while (pch != NULL) {
@@ -460,20 +500,20 @@ static int assignMappings(TCLDriv *pDriv, SConnection *pCon, char *arrayName){
       if (ps%2==0){
         if (*newStr==NULL) {
           free(newStr);
+          free(funcName);
           return OKOK;
         } else {
-	  funcName = (char *)calloc(strlen(pch)-c+1, sizeof(char));
 	  strcpy(funcName, newStr);
 	  ps++;
         }
       } else {
 	StringDictAddPair(pDriv->mappings,funcName, newStr);
-	ps++;
-	free(funcName);
+	ps = 0;
       }
       free(newStr);
       pch = strtok (NULL, "{}");
     }
+    free(funcName);
   }
   return 1;
 } 
@@ -511,9 +551,9 @@ static int assignMappings(TCLDriv *pDriv, SConnection *pCon, char *arrayName){
      strncpy(pDriv->motName, argv[1], 131);
      pDriv->GetPosition = GetTclPos;
      pDriv->RunTo = TclRun;
-     pDriv->GetStatus = TclStat;
-     pDriv->GetError = TclError;
-     pDriv->TryAndFixIt = TclFix;
+     pDriv->GetStatus = TclGetStatus;
+     pDriv->GetError = TclGetError;
+     pDriv->TryAndFixIt = TclTryAndFixIt;
      pDriv->SetDriverPar = TclSetPar; 
      pDriv->GetDriverPar = TclGetPar; 
      pDriv->ListDriverPar = TclListPar;