Clean up the space/tab mess and trailing whitespace

site_ansto/ansto_sctdriveadapter.c

@@ -1,18 +1,18 @@
 /**
- * This is an adapter to a node under the control of the new 
+ * This is an adapter to a node under the control of the new
- * scriptcontext generic device model. This is a wrapper around 
+ * scriptcontext generic device model. This is a wrapper around
  * such a node which implements the drivable interface.
- * 
+ *
  * Some cooperation from the node is required: It has to provide
- * certain properties the value of which define scripts which 
+ * certain properties the value of which define scripts which
  * have to be called at various stages. These are:
- * 
+ *
  *    checklimits, for limits checking
  *    checkstatus, for evaluating progress
  *    halt       , for halting things
- * 
+ *
  * copyright: see file COPYRIGHT
- * 
+ *
  * Mark Koennecke, June 2008
  * --------------------------------------------------------------*/
 #include <sics.h>
@@ -24,16 +24,16 @@
 #include "scriptcontext.h"
 /*---------------------------------------------------------------*/
 typedef struct {
-	pObjectDescriptor pDes;
+    pObjectDescriptor pDes;
-	pIDrivable pDriv;
+    pIDrivable pDriv;
-	pHdb write_node;
+    pHdb write_node;
-	pHdb read_node;
+    pHdb read_node;
-	SctController *c;
+    SctController *c;
 }SctDrive, *pSctDrive;
 /*---------------------------------------------------------------*/
 static void *SCTDRIVGetInterface(void *data, int iD){
-    pSctDrive self = NULL; 
+    pSctDrive self = NULL;
- 
+
     self = (pSctDrive)data;
     if(self != NULL && iD == DRIVEID){
          if (self->write_node == NULL) return NULL;
@@ -48,51 +48,51 @@ static void *SCTDRIVGetInterface(void *data, int iD){
  go wrong. However, the return value of Halt is usually ignored!
 ------------------------------------------------------------------*/
 static int SCTDRIVHalt(void *data) {
-    pSctDrive self = NULL; 
+    pSctDrive self = NULL;
     char dummy[16];
-    
+
     self = (pSctDrive)data;
     if (GetHdbProperty(self->write_node,"halt", dummy, sizeof dummy)) {
       SctQueueNode(self->c, self->write_node, HaltPRIO, "halt", NULL);
     } else if (GetHdbProperty(self->write_node, "status", dummy, sizeof dummy)) {
       SetHdbProperty(self->write_node, "status", "idle");
     }
-    return OKOK; 
+    return OKOK;
 }
 /*----------------------------------------------------------------
- This routine can return either 1 or 0. 1 means the position can 
+ This routine can return either 1 or 0. 1 means the position can
  be reached, 0 NOT
  If 0, error shall contain up to errlen characters of information
  about which limit was violated
 ------------------------------------------------------------------*/
 static int SCTDRIVCheckLimits(void *data, float val,
                          char *error, int errlen){
-    pSctDrive self = NULL; 
+    pSctDrive self = NULL;
     char script[1024];
     int status;
     Tcl_Interp *pTcl = NULL;
     char *result;
-    
+
     self = (pSctDrive)data;
     snprintf(script,1024,"%f", val);
     SetHdbProperty(self->write_node,"target", script);
     if(GetHdbProperty(self->write_node,"checklimits",script,1024)){
-    	status = SctCallInContext(pServ->dummyCon, script, 
+        status = SctCallInContext(pServ->dummyCon, script,
-    			self->write_node, self->c, &result);
+                self->write_node, self->c, &result);
-    	if(SctVerbose(self->c)){
+        if(SctVerbose(self->c)){
-    		SCPrintf(pServ->dummyCon, eWarning, "script %s called with result %s\n ", 
+            SCPrintf(pServ->dummyCon, eWarning, "script %s called with result %s\n ",
-    				script, result);
+                    script, result);
-    	}
+        }
-    	if(status == 0){
+        if(status == 0){
-    		strncpy(error,result,errlen);
+            strncpy(error,result,errlen);
-    		return 0;
+            return 0;
-    	}
+        }
     }
     return 1;
 }
 /*----------------------------------------------------------------
- This routine can return 0 when a limit problem occurred 
+ This routine can return 0 when a limit problem occurred
- OKOK when the motor was successfully started 
+ OKOK when the motor was successfully started
  HWFault when a problem occured starting the device
  Possible errors shall be printed to pCon
  For real motors, this is supposed to try at least three times
@@ -100,19 +100,19 @@ static int SCTDRIVCheckLimits(void *data, float val,
  val is the value to drive the motor too
 ------------------------------------------------------------------*/
 static long SCTDRIVSetValue(void *data, SConnection *pCon, float val){
-    pSctDrive self = NULL; 
+    pSctDrive self = NULL;
     int status;
     hdbValue v;
-    
+
     self = (pSctDrive)data;
     v.dataType = HIPFLOAT;
     v.v.doubleValue = (double)val;
     SetHdbProperty(self->write_node,"writestatus", "start");
     status = SetHipadabaPar(self->write_node, v, pCon);
     if(status == 1){
-    	return OKOK;
+        return OKOK;
     } else {
-    	return HWFault;
+        return HWFault;
     }
 }
 /*----------------------------------------------------------------
@@ -122,28 +122,28 @@ static long SCTDRIVSetValue(void *data, SConnection *pCon, float val){
    HWFault when a hardware problem ocurred
    HWPosFault when the hardware cannot reach a position
  Errors are duly to be printed to pCon
- For real motors CheckStatus again shall try hard to fix any 
+ For real motors CheckStatus again shall try hard to fix any
- issues with the motor 
+ issues with the motor
 ------------------------------------------------------------------*/
 static int SCTDRIVCheckStatus(void *data, SConnection *pCon){
-    pSctDrive self = NULL; 
+    pSctDrive self = NULL;
     char script[1024];
     int status;
     Tcl_Interp *pTcl = NULL;
     char *result;
     SConnection *con;
- 
+
     self = (pSctDrive)data;
-    
+
     /*
      * check if the write command has gone through
      */
     if(GetHdbProperty(self->write_node,"writestatus", script,1024)){
-    	if(strcmp(script,"start") == 0){
+        if(strcmp(script,"start") == 0){
-    		return HWBusy;
+            return HWBusy;
-    	}
+        }
     }
-    
+
     /*
      * run the checkstatus script
      */
@@ -155,16 +155,16 @@ static int SCTDRIVCheckStatus(void *data, SConnection *pCon){
       }
       result = script;
     } else {
-      status = SctCallInContext(pCon,script, self->write_node, 
+      status = SctCallInContext(pCon,script, self->write_node,
         self->c, &result);
       if (status == 0) {
-          SCPrintf(pCon,eError," script %s returned %s", 
+          SCPrintf(pCon,eError," script %s returned %s",
-          		script, result);
+                script, result);
         return HWFault;
       }
       if(SctVerbose(self->c)){
-          SCPrintf(pCon,eError," script %s returned %s", 
+          SCPrintf(pCon,eError," script %s returned %s",
-          		script, result);
+                script, result);
       }
     }
      if(strstr(result,"busy") != NULL){
@@ -188,16 +188,16 @@ static int SCTDRIVCheckStatus(void *data, SConnection *pCon){
  On errors, -99999999.99 is returned and messages printed to pCon
 ------------------------------------------------------------------*/
 static float SCTDRIVGetValue(void *data, SConnection *pCon){
-    pSctDrive self = NULL; 
+    pSctDrive self = NULL;
     float val = -99999999.99;
     int status;
     char error[256];
     hdbValue v;
-    
+
     self = (pSctDrive)data;
     if(GetHdbProperty(self->read_node,"geterror", error, 256)){
-    	SCWrite(pCon,error, eError);
+        SCWrite(pCon,error, eError);
-    	return val;
+        return val;
     }
     return (float)self->read_node->value.v.doubleValue;
 }
@@ -205,19 +205,19 @@ static float SCTDRIVGetValue(void *data, SConnection *pCon){
  returns NULL on failure, a new datastructure else
 ------------------------------------------------------------------*/
 static pSctDrive SCTDRIVMakeObject(){
-    pSctDrive self = NULL; 
+    pSctDrive self = NULL;
 
     self = calloc(sizeof(SctDrive),1);
     if(self == NULL){
-    	return NULL;
+        return NULL;
     }
     self->pDes = CreateDescriptor("SctDriveAdapter");
     self->pDriv = CreateDrivableInterface();
     if(self->pDes == NULL  || self->pDriv == NULL){
-    	free(self);
+        free(self);
-    	return NULL;
+        return NULL;
     }
-    
+
     self->pDes->GetInterface = SCTDRIVGetInterface;
     self->pDriv->Halt = SCTDRIVHalt;
     self->pDriv->CheckLimits = SCTDRIVCheckLimits;
@@ -230,36 +230,36 @@ static pSctDrive SCTDRIVMakeObject(){
 /*-----------------------------------------------------------------*/
 static int SctDriveCommand(SConnection *pCon, SicsInterp *sics, void *object,
                int argc, char *argv[]) {
-	pSctDrive self = (pSctDrive)object;
+    pSctDrive self = (pSctDrive)object;
-	float val;
+    float val;
-	
+
-	assert(self != NULL);
+    assert(self != NULL);
-	
+
-	if (self->write_node == NULL) {
+    if (self->write_node == NULL) {
-	  SCWrite(pCon, "ERROR: defunct object", eError);
+      SCWrite(pCon, "ERROR: defunct object", eError);
-	  return 0;
+      return 0;
-	}
+    }
-	/*
+    /*
-	 * only action: print value
+     * only action: print value
-	 */
+     */
-	val = self->pDriv->GetValue(self,pCon);
+    val = self->pDriv->GetValue(self,pCon);
-	SCPrintf(pCon,eValue,"%s = %f", argv[0], val);
+    SCPrintf(pCon,eValue,"%s = %f", argv[0], val);
-	return 1;
+    return 1;
 }
 /*----------------------------------------------------------------*/
 static void SctDriveKill(void *data){
-	pSctDrive self = (pSctDrive)data;
+    pSctDrive self = (pSctDrive)data;
-	
+
-	if(self == NULL){
+    if(self == NULL){
-		return;
+        return;
-	}
+    }
-	if(self->pDriv != NULL){
+    if(self->pDriv != NULL){
-		free(self->pDriv);
+        free(self->pDriv);
-	}
+    }
-	if(self->pDes != NULL){
+    if(self->pDes != NULL){
-		DeleteDescriptor(self->pDes);
+        DeleteDescriptor(self->pDes);
-	}
+    }
-	free(self);
+    free(self);
 }
 /*----------------------------------------------------------------*/
 static hdbCallbackReturn SctDummyCallback(Hdb *node, void *userData,
@@ -274,44 +274,44 @@ static void SctDriveDeleteNode(void *data) {
 /*---------------------------------------------------------------*/
 int ANSTO_SctMakeDriveAdapter(SConnection *pCon, SicsInterp *pSics, void *object,
                int argc, char *argv[]) {
-	pSctDrive pNew = NULL;
+    pSctDrive pNew = NULL;
-	pSICSOBJ obj = NULL;
+    pSICSOBJ obj = NULL;
   hdbCallback *cb;
-	
+
-	pNew = SCTDRIVMakeObject();
+    pNew = SCTDRIVMakeObject();
-	if(pNew == NULL){
+    if(pNew == NULL){
-		SCWrite(pCon,"ERROR: out of memory in ANSTO_SctMakeDriveAdapter",
+        SCWrite(pCon,"ERROR: out of memory in ANSTO_SctMakeDriveAdapter",
-				eError);
+                eError);
-		return 0;
+        return 0;
-	}
+    }
-	
+
-	if(argc < 4){
+    if(argc < 4){
-		SCWrite(pCon,"ERROR: not enough arguments for ANSTO_SctMakeDriveAdapter", eError);
+        SCWrite(pCon,"ERROR: not enough arguments for ANSTO_SctMakeDriveAdapter", eError);
-		return 0;
+        return 0;
-	}
+    }
-	
+
-	pNew->write_node = FindHdbNode(NULL,argv[2], pCon);
+    pNew->write_node = FindHdbNode(NULL,argv[2], pCon);
-	pNew->read_node = FindHdbNode(NULL,argv[3], pCon);
+    pNew->read_node = FindHdbNode(NULL,argv[3], pCon);
-	obj = FindCommandData(pSics,argv[4], "SctController");
+    obj = FindCommandData(pSics,argv[4], "SctController");
-	if(pNew->write_node == NULL || obj == NULL){
+    if(pNew->write_node == NULL || obj == NULL){
-		SCWrite(pCon,"ERROR: node or controller not found", eError);
+        SCWrite(pCon,"ERROR: node or controller not found", eError);
-		SctDriveKill(pNew);
+        SctDriveKill(pNew);
-		return 0;
+        return 0;
-	}
+    }
-	pNew->c =(SctController *)obj->pPrivate;
+    pNew->c =(SctController *)obj->pPrivate;
-  
+
   if (strcasecmp(argv[0],"dynsctdrive") == 0) {
     /* make object dynamic by defining a descriptor command */
     SetDescriptorKey(pNew->pDes, "creationCommand", "0");
   }
-	AddCommand(pSics, argv[1], SctDriveCommand, SctDriveKill, pNew);
+    AddCommand(pSics, argv[1], SctDriveCommand, SctDriveKill, pNew);
-	SetHdbProperty(pNew->write_node,"sicsdev",argv[1]);
+    SetHdbProperty(pNew->write_node,"sicsdev",argv[1]);
-	
+
   cb = MakeHipadabaCallback(SctDummyCallback, pNew, SctDriveDeleteNode);
   assert(cb);
   AppendHipadabaCallback(pNew->write_node, cb);
-	
+
-	return 1;
+    return 1;
 }
 /*---------------------------------------------------------------*/