*** empty log message ***

asyncprotocol.c

@@ -93,6 +93,9 @@ int defaultPrepareTxn(pAsyncProtocol p, pAsyncTxn txn, const char* cmd, int cmd_
   }
   txn->out_len = cmd_len;
   txn->out_idx = 0;
+  if(txn->inp_buf != NULL){
+    free(txn->inp_buf);
+  }
   txn->inp_buf = malloc(rsp_len);
   if (txn->inp_buf == NULL) {
     SICSLogWrite("Out of memory in AsyncProtocol::defaultPrepareTxn", eError);

asyncprotocol.h

@@ -21,7 +21,8 @@ typedef enum {
   ATX_NULL=0,
   ATX_TIMEOUT=-1,
   ATX_ACTIVE=1,
-  ATX_COMPLETE=2
+  ATX_COMPLETE=2,
+  ATX_DISCO=3
 } ATX_STATUS;
 
 struct __async_txn {

asyncqueue.c

@@ -8,7 +8,7 @@
  * single command channel.
  *
  * Douglas Clowes, February 2007
- *
+ *  
  */
 
 #include <sys/time.h>
@@ -21,7 +21,6 @@
 #include "asyncqueue.h"
 #include "nwatch.h"
 
-typedef struct __AsyncQueue AsyncQueue, *pAsyncQueue;
 
 typedef struct __async_command AQ_Cmd, *pAQ_Cmd;
 
@@ -130,9 +129,9 @@ static int AQ_Reconnect(pAsyncQueue self)
   return 1;
 }
 
-
 static int CommandTimeout(void* cntx, int mode);
 static int DelayedStart(void* cntx, int mode);
+static int PopCommand(pAsyncQueue self);
 
 static int StartCommand(pAsyncQueue self)
 {
@@ -183,8 +182,14 @@ static int StartCommand(pAsyncQueue self)
     iRet = NETRead(sock, reply, 1, 0);
     if (iRet < 0) { /* EOF */
       iRet = AQ_Reconnect(self);
-      if (iRet == 0)
+      if (iRet <= 0) {
+        myCmd->tran->txn_state = ATX_DISCO;
+        if(myCmd->tran->handleResponse){
+            myCmd->tran->handleResponse(myCmd->tran);
+        }
+        PopCommand(self);
         return 0;
+      }
     }
   }
   /*
@@ -239,7 +244,6 @@ static int QueCommand(pAsyncQueue self, pAQ_Cmd cmd)
   self->command_tail = cmd;
   return 1;
 }
-
 static int PopCommand(pAsyncQueue self)
 {
   pAQ_Cmd myCmd = self->command_head;
@@ -306,10 +310,22 @@ static int MyCallback(void* context, int mode)
     char reply[1];
 
     iRet = NETRead(self->pSock, reply, 1, 0);
+    /* printf(" iRet, char = %d, %d\n", iRet, (int)reply[0]);  */
     if (iRet < 0) { /* EOF */
       iRet = AQ_Reconnect(self);
-      if (iRet <= 0)
+      if (iRet <= 0){
+            /* changed to call handleResponse with a bad status code: MK
+             */
+          pAQ_Cmd myCmd = self->command_head;
+          if(myCmd){
+            myCmd->tran->txn_state = ATX_DISCO;
+            if(myCmd->tran->handleResponse){
+                myCmd->tran->handleResponse(myCmd->tran);
+            }
+            PopCommand(self);
+          }    
         return iRet;
+      }
       /* restart the command */
       StartCommand(self);
       return 1;
@@ -336,7 +352,7 @@ static int MyCallback(void* context, int mode)
   return 1;
 }
 
-int AsyncUnitEnqueHead(pAsyncUnit unit, pAsyncTxn context)
+int AsyncUnitEnqueueHead(pAsyncUnit unit, pAsyncTxn context)
 {
   pAQ_Cmd myCmd = NULL;
 
@@ -412,6 +428,9 @@ pAsyncTxn AsyncUnitPrepareTxn(pAsyncUnit unit,
   if (rsp_len == 0)
     myTxn->inp_buf = NULL;
   else {
+    if(myTxn->inp_buf != NULL){
+        free(myTxn->inp_buf);
+    }
     myTxn->inp_buf = malloc(rsp_len + 1);
     if (myTxn->inp_buf == NULL) {
       SICSLogWrite("ERROR: Out of memory in AsyncUnitPrepareTxn", eError);
@@ -954,3 +973,15 @@ int AsyncUnitDestroy(pAsyncUnit unit)
   return 1;
 }
 
+pAsyncUnit AsyncUnitFromQueue(pAsyncQueue queue){
+    pAsyncUnit result = NULL;
+    
+    result = malloc(sizeof(AsyncUnit));
+    if(result == NULL){
+        return NULL;
+    }
+    memset(result,0,sizeof(AsyncUnit));
+    result->queue = queue;
+    return result;
+}
+

asyncqueue.h

@@ -17,6 +17,9 @@
 #define AQU_RETRY_CMD   -4
 #define AQU_POP_CMD     -5
 
+typedef struct __AsyncQueue AsyncQueue, *pAsyncQueue;
+
+
 /** \brief create an AsyncUnit attached to a named AsyncQueue.
  *
  * \param queueName the name of the AsyncQueue to be used
@@ -24,6 +27,11 @@
  * \return positive if successful
  */
 int AsyncUnitCreate(const char* queueName, pAsyncUnit* unit);
+/** \brief Get an AsyncUnit from a given AsyncQueue
+ * \param queue The AsyncQueue fro which this AsyncUnit is valid
+ * \return a new AsyncUnit or NULL on error
+ */
+pAsyncUnit AsyncUnitFromQueue(pAsyncQueue queue);
 
 /** \brief create an AsyncUnit attached to an anonymous AsyncQueue.
  *

devexec.c

@@ -221,6 +221,7 @@ typedef struct {
     pRes->iLock = 0;
     pRes->drivePrint = 0;
     pRes->paused = 0;
+    pRes->taskRunning = 0;
     pRes->pCall = CreateCallBackInterface();
     pRes->lastRun = time(NULL);
     pRes->pDes->GetInterface = DevexecInterface;

diffscan.c

@@ -336,7 +336,7 @@ static int DiffScanTask(void *pData){
     check for interrupt
   */
   if(SCGetInterrupt(self->scanObject->pCon) >= eAbortScan){
-    pCount->pDriv->Halt(pCount->pDriv);
+    pCount->pCountInt->Halt(pCount);
     pVar->pInter->Halt(pVar->pObject);
     SicsWait(1);
     finish = 0;

exe.w

@@ -89,6 +89,19 @@ The interface to this buffer system comprises:
     */
   int exeBufProcess(pExeBuf self, SicsInterp *pSics, 
 	SConnection *pCon, pICallBack pCall, int echo);
+ /**
+    * Process an exe buffer, but store commands causing errors in a list.
+    * This is used for restoring status files. 
+    * @@param self The exe buffer to process
+    * @@param pSics The SICS interpreter to use for processing
+    * @@param pCon The connection object providing the environment for
+    * processing this buffer.
+    * @@param errCommandList A lld string list for storing commands which 
+    * had errors.
+    * @@return 1 on success, 0 on error
+    */
+  int exeBufProcessErrList(pExeBuf self, SicsInterp *pSics, 
+	SConnection *pCon, int errCommandList);
   /**
     * retrieves the executing range
     * @@param self The exe buffer to query

exebuf.c

@@ -11,6 +11,7 @@
 #include <stdio.h>
 #include <assert.h>
 #include <tcl.h>
+#include "lld_str.h"
 #include "fortify.h"
 #include "sics.h"
 #include "exebuf.h"
@@ -232,6 +233,45 @@ int exeBufProcess(pExeBuf self, SicsInterp *pSics,
   }
   return 1;
 }
+/*---------------------------------------------------------------------*/
+int exeBufProcessErrList(pExeBuf self, SicsInterp *pSics, 
+            SConnection *pCon, int errList){
+  pDynString command = NULL;
+  Tcl_Interp *pTcl = NULL;
+  int status;
+  
+  static int weWantLogging = 1;
+  char *cmd;
+  char cmdName[128];
+  char *ende;
+  int l;
+  
+  assert(self);
+  assert(pSics);
+
+  self->start = 0;
+  self->end = -1;
+  self->lineno = 0;
+  pTcl = InterpGetTcl(pSics);
+
+  while((command = findBlockEnd(self)) != NULL){
+    cmd = GetCharArray(command);
+        
+    status = Tcl_Eval(pTcl,cmd);
+    if(status != TCL_OK){
+        LLDstringAppend(errList,cmd);
+    }
+    DeleteDynString(command);
+    if(SCGetInterrupt(pCon) >= eAbortBatch){
+      SCWrite(pCon,"ERROR: batch processing interrupted",eError);
+      SetStatus(eEager);
+      return 0;
+    } else {
+      SCSetInterrupt(pCon,eContinue);
+    }
+  }
+  return 1;
+}
 /*------------------------------------------------------------------------*/
 void exeBufRange(pExeBuf self, int *start, int *end, int *lineno){
   assert(self);

exebuf.h

@@ -1,5 +1,5 @@
 
-#line 213 "exe.w"
+#line 226 "exe.w"
 
 /**
   * Buffer handling code for the Exe Buffer batch file processing
@@ -63,6 +63,19 @@
     */
   int exeBufProcess(pExeBuf self, SicsInterp *pSics, 
         SConnection *pCon, pICallBack pCall, int echo);
+ /**
+    * Process an exe buffer, but store commands causing errors in a list.
+    * This is used for restoring status files. 
+    * @param self The exe buffer to process
+    * @param pSics The SICS interpreter to use for processing
+    * @param pCon The connection object providing the environment for
+    * processing this buffer.
+    * @param errCommandList A lld string list for storing commands which 
+    * had errors.
+    * @return 1 on success, 0 on error
+    */
+  int exeBufProcessErrList(pExeBuf self, SicsInterp *pSics, 
+        SConnection *pCon, int errCommandList);
   /**
     * retrieves the executing range
     * @param self The exe buffer to query
@@ -89,7 +102,7 @@
     */
   char *exeBufName(pExeBuf self);
 
-#line 226 "exe.w"
+#line 239 "exe.w"
 
 
 #endif

exebuf.i

@@ -1,5 +1,5 @@
 
-#line 204 "exe.w"
+#line 217 "exe.w"
 
 /*--------------------------------------------------------------------
   Internal header file for the exe buffer module. Do not edit. This is
@@ -16,6 +16,6 @@ typedef struct __EXEBUF{
         int lineno;
 } ExeBuf;
 
-#line 209 "exe.w"
+#line 222 "exe.w"
 
 

exeman.i

@@ -1,12 +1,12 @@
 
-#line 182 "exe.w"
+#line 195 "exe.w"
 
 /*-------------------------------------------------------------------
   Internal header file for the exe manager module. Do not edit. This
   is automatically generated from exe.w
 -------------------------------------------------------------------*/
 
-#line 138 "exe.w"
+#line 151 "exe.w"
 
 typedef struct __EXEMAN{
         pObjectDescriptor pDes;
@@ -20,5 +20,5 @@ typedef struct __EXEMAN{
         int echo;
 }ExeMan, *pExeMan;
 
-#line 187 "exe.w"
+#line 200 "exe.w"
 

genericcontroller.c

@@ -0,0 +1,613 @@
+/**
+ * This is a generic controller for devices in SICS. It is configurable via Tcl 
+ * scripts.
+ * 
+ * copyright: see file COPYRIGHT
+ * 
+ * Mark Koennecke, November 2007
+ */
+#include <stdlib.h>
+#include <assert.h>
+#include <tcl.h>
+#include <sics.h> 
+#include <macro.h>
+#include <sicshipadaba.h>
+#include <sicsobj.h>
+#include <dynstring.h>
+#include <genericcontroller.h>
+/*--------------------------------------------------------------------------*/
+static int GenConSetCallback(void *userData, void *callData, pHdb node, 
+    hdbValue v){
+    pSICSOBJ self = (pSICSOBJ)userData;
+    SConnection *pCon = (SConnection *)callData;
+    pGenController priv = NULL;
+    char command[1024];
+    char value[80];
+    int status, privilege;
+    pDynString data;
+    
+    assert(self != NULL);
+    
+    priv = (pGenController)self->pPrivate;
+    
+    /*
+     * check rights
+     */
+    memset(value,0,80);
+    if(GetHdbProperty(node,"priv",value,80) && pCon != NULL){
+        privilege = usInternal;
+        if(strcmp(value,"manager") == 0){
+            privilege = usMugger;
+        }
+        if(strcmp(value,"user") == 0){
+            privilege = usUser;
+        }
+        if(!SCMatchRights(pCon,privilege)){
+            return 0;
+        }
+    }
+    
+    /* 
+     * check writeCommand
+     */
+    memset(value,0,80);
+    GetHdbProperty(node,"writeCommand",value,80);
+    if(strlen(value) < 2){ 
+        if(pCon != NULL){
+            SCWrite(pCon,"ERROR: parameter is read-only",eError);
+            return 0;
+        }
+        return 0;
+    }
+
+    /* 
+     * check status
+     */
+    memset(value,0,80);
+    GetHdbProperty(node,"status",value,80);
+    if(strstr(value,"idle") == NULL){
+        return 0;
+    }
+    SetHdbProperty(node,"status","setting");
+    data = formatValue(v);
+    if(data != NULL){
+       SetHdbProperty(node,"target",GetCharArray(data));
+       DeleteDynString(data);
+    }
+     
+    /*
+     * issue command
+     */
+    if(priv->enqueueNodeHead != NULL){   
+        priv->enqueueNodeHead(self,pCon,node);
+    }  else {
+        if(pCon != NULL){
+            SCWrite(pCon,"ERROR: generic controller NOT configured",
+                    eError);
+        }
+        return 0;    
+    }
+    
+    return 1;        
+}
+/*--------------------------------------------------------------------------*/
+static int GenConGetCallback(void *userData, void *callData, pHdb node, 
+    hdbValue v){
+    pSICSOBJ self = (pSICSOBJ)userData;
+    SConnection *pCon = (SConnection *)callData;
+    pGenController priv = NULL;
+    char command[1024];
+    char value[256];
+    int status, privilege;
+    
+    assert(self != NULL);
+    
+    priv = (pGenController)self->pPrivate;
+    
+   /* 
+     * check status
+     */
+    memset(value,0,80);
+    GetHdbProperty(node,"status",value,80);
+    if(strstr(value,"idle") == NULL){
+        return 1;
+    }
+    SetHdbProperty(node,"status","getting"); 
+    
+    /* 
+     * check readCommand
+     */
+    memset(value,0,256);
+    GetHdbProperty(node,"readCommand",value,255);
+    if(strlen(value) < 2){ 
+        return 0;
+    } else {
+        if(priv->enqueueNode != NULL){
+            priv->enqueueNode(self,pCon, node);
+        } else {
+            if(pCon != NULL){
+                SCWrite(pCon,"ERROR: generic controller connection NOT configured",
+                    eError);
+            }
+            return 0;    
+        }
+    }
+
+    /*
+     * Upper Level GetHipadabaPar will automtaically return the 
+     * node value. Which should have been updated through an update
+     * during the execution of enqueueNode
+     */    
+    
+    return 1;        
+}
+/*---------------------------------------------------------------------------*/
+static pHdb MakeGenConPar(pSICSOBJ self, char *name, int type, int length){
+    pHdb result = NULL;
+    pHdbCallback kalle = NULL;
+    
+    result = MakeHipadabaNode(name,type,length);
+    if(result == NULL){
+        return NULL;
+    }
+    
+    kalle = MakeHipadabaCallback(GenConSetCallback, 
+                                 self,
+                                 NULL,
+                                 -1,
+                                 -1);
+    if(kalle == NULL){
+        return NULL;
+    }
+    AppendHipadabaCallback(result,HCBSET, kalle);
+    
+    kalle = MakeHipadabaCallback(GenConGetCallback, 
+                                 self,
+                                 NULL,
+                                 -1,
+                                 -1);
+    if(kalle == NULL){
+        return NULL;
+    }
+    AppendHipadabaCallback(result,HCBREAD, kalle);
+    
+    SetHdbProperty(result,"priv","manager");
+    SetHdbProperty(result,"readCommand","");
+    SetHdbProperty(result,"writeCommand","");
+    SetHdbProperty(result,"replyCommand","");
+    SetHdbProperty(result,"status","idle");
+    
+    return result;
+}
+/*---------------------------------------------------------------------------*/
+static int MakeGenPar(pSICSOBJ self, SConnection *pCon, 
+    char *argv[], int argc){
+    char buffer[2048];
+    int type, length = 1;
+    pHdb node = NULL , parent;
+    char *pPtr = NULL;
+ 
+    if(argc < 5){
+        snprintf(buffer,2048,"ERROR: insufficient arguments to %s makepar", 
+            argv[0]);
+        SCWrite(pCon,buffer, eError);
+        return 0;
+    }
+    type = convertHdbType(argv[4]);
+     if(argc > 5){
+        length = atoi(argv[5]);
+     }
+     strncpy(buffer,argv[3],2047);
+     pPtr = strrchr(buffer,'/');
+     if(pPtr == NULL){
+        node = MakeGenConPar(self, argv[3], type, length);
+        parent = self->objectNode;
+      } else {
+        *pPtr = '\0';
+         pPtr++;
+         node = MakeGenConPar(self, pPtr, type, length);
+         parent = GetHipadabaNode(self->objectNode,buffer);
+      }
+      if(node == NULL || parent == NULL){
+        SCWrite(pCon,"ERROR: failed to create node or parent not found",
+                eError);
+        return 0;
+      }
+      AddHipadabaChild(parent, node, pCon);
+      SCSendOK(pCon);
+      return 1;
+}
+/*=============================== ==========================================
+ * This stuff is for the Tcl - AsynQueue implementation of GenericController
+ * ==========================================================================*/
+ typedef struct {
+        pHdb node;
+        pSICSOBJ obj; 
+        SConnection *pCon;
+        pGenController priv;
+        pAsyncUnit assi;
+        pAsyncTxn trans;
+        commandContext comCon;
+        char replyCommand[2048];
+ } GenContext, *pGenContext;
+ /*--------------------------------------------------------------------------
+  * This is called by AsyncQueue when a reply has been received.
+  * -------------------------------------------------------------------------*/
+ static int GenConTxnHandler(pAsyncTxn pTxn){
+    pGenContext genCon = NULL;
+    char reply[10240];
+        
+    genCon = (pGenContext)pTxn->cntx;
+    assert(genCon != NULL);
+    
+    memset(reply,0,10240*sizeof(char));
+    switch(pTxn->txn_state){
+        case ATX_NULL:
+        case ATX_ACTIVE:
+            return 1;
+            break;
+         case ATX_TIMEOUT:
+            strcpy(reply,"TIMEOUT");
+            break;
+         case ATX_DISCO:
+            strcpy(reply,"DISCONNECTED");
+            break;
+         case ATX_COMPLETE:
+            strncpy(reply,pTxn->inp_buf,10240);
+            break;
+    }
+    
+    if(genCon->pCon != NULL){
+        SCPushContext2(genCon->pCon, genCon->comCon);
+    }
+    genCon->priv->replyCallback(genCon->obj, genCon->pCon,  
+        genCon->node, genCon->replyCommand, reply, strlen(reply)); 
+    if(genCon->pCon != NULL){
+        SCPopContext(genCon->pCon);
+    }     
+    free(genCon);
+    
+    return 1;
+ }
+/*--------------------------------------------------------------------------*/
+static char *formatCommand(pHdb node, SConnection *pCon){
+    pDynString com = NULL;
+    char value[512];
+    Tcl_Interp *pTcl = NULL;
+    int status;
+    
+    com = CreateDynString(256,128);
+    if(com == NULL){
+        return NULL;
+    }
+    
+    memset(value,0,512);
+    GetHdbProperty(node,"status",value,512);
+    if(strstr(value,"set") != NULL){
+        memset(value,0,512);
+        GetHdbProperty(node,"writeCommand",value,512);
+        DynStringConcat(com,value);
+        DynStringConcatChar(com,' ');
+        memset(value,0,512);
+        GetHdbProperty(node,"target",value,512);
+        DynStringConcat(com,value);
+    } else {
+        memset(value,0,512);
+        GetHdbProperty(node,"readCommand",value,512);
+        DynStringConcat(com,value);
+    }
+    pTcl = InterpGetTcl(pServ->pSics);
+    if(pCon != NULL){
+        MacroPush(pCon);
+    }
+    status = Tcl_Eval(pTcl, GetCharArray(com));
+    if(pCon != NULL){
+        MacroPop();
+    }
+    DeleteDynString(com);
+    if(status != TCL_OK){
+        SetHdbProperty(node,"result", (char *)Tcl_GetStringResult(pTcl));
+        return NULL;
+    }
+    return strdup(Tcl_GetStringResult(pTcl));
+}
+/*--------------------------------------------------------------------------*/
+static pGenContext PrepareToEnque(pSICSOBJ self, SConnection *pCon, pHdb node){
+    pGenContext result = NULL;
+    char *command = NULL;
+    pGenController priv = NULL;
+    
+    priv = (pGenController)self->pPrivate;
+    assert(priv != NULL);
+    
+    command = formatCommand(node, pCon);
+    if(command == NULL){
+        return NULL;
+    }
+    
+    result = malloc(sizeof(GenContext));
+    if(result == NULL){
+        return NULL;
+    }
+    memset(result,0,sizeof(GenContext));
+    if(!GetHdbProperty(node,"replyCommand",result->replyCommand,2048)){
+        if(pCon != NULL){
+            SCWrite(pCon,"ERROR: no replyCommand found",eError);
+        }
+        free(result);
+        return NULL;
+    }
+    
+    result->assi = AsyncUnitFromQueue((pAsyncQueue)priv->comContext);
+    if(result->assi == NULL){
+        return NULL;
+    }
+    result->trans =  AsyncUnitPrepareTxn(result->assi, 
+                                command,strlen(command), 
+                                GenConTxnHandler,
+                                result,
+                                2048);
+    if(result->trans == NULL){
+        return NULL;
+    }
+    result->node = node;
+    result->priv = priv;   
+    result->obj = self;
+    result->pCon = pCon;
+    priv->comError = GCOK;
+    result->comCon = SCGetContext(pCon);
+    free(command); 
+                           
+    return result;
+}
+/*---------------------------------------------------------------------------*/
+static int AsyncEnqueueNode(pSICSOBJ self, SConnection *pCon, pHdb node){
+    pGenContext genCon = NULL;
+    
+    genCon = PrepareToEnque(self, pCon, node);
+    if(genCon == NULL){
+        return 0;
+    }
+    return AsyncUnitEnqueueTxn(genCon->assi, genCon->trans);
+}
+/*---------------------------------------------------------------------------*/
+static int AsyncEnqueueNodeHead(pSICSOBJ self, SConnection *pCon, pHdb node){
+    pGenContext genCon = NULL;
+    
+    genCon = PrepareToEnque(self, pCon, node);
+    if(genCon == NULL){
+        return 0;
+    }
+    return AsyncUnitEnqueueHead(genCon->assi, genCon->trans);
+}
+/*---------------------------------------------------------------------------*/
+static int AsyncReply(pSICSOBJ self, SConnection *pCon, pHdb node,  
+                char *replyCommand, char *reply, int replylen){
+    pDynString com = NULL;
+    Tcl_Interp *pTcl;
+    int status;
+    
+    SetHdbProperty(node,"result",reply);
+    
+    com = CreateDynString(256,128);
+    if(com == NULL){
+        return 0;
+    }
+    DynStringConcat(com, replyCommand);
+    DynStringConcat(com," \"");
+    DynStringConcat(com, reply);
+    DynStringConcat(com,"\"\0");
+    if(pCon != NULL){
+        MacroPush(pCon);
+    }
+    pTcl = InterpGetTcl(pServ->pSics);
+    status = Tcl_Eval(pTcl,GetCharArray(com));
+    if(pCon != NULL){
+        MacroPop();
+    }
+    DeleteDynString(com);
+    if(status != TCL_OK){
+        SetHdbProperty(node,"lastError",(char *)Tcl_GetStringResult(pTcl));
+    }
+    return status;
+}
+/*============= GenController Object Functions ==============================*/
+static int ConnectAsync(pSICSOBJ self, SConnection *pCon, 
+    char *argv[], int argc){
+    pGenController priv = NULL;
+    pAsyncQueue assi = NULL;
+    char buffer[2048];
+    pAsyncUnit uni = NULL;
+
+    priv = (pGenController)self->pPrivate;
+    assert(priv != NULL);
+    
+    if(argc < 4){
+        snprintf(buffer,2048,"ERROR: insufficient arguments to %s asynconnect", 
+            argv[0]);
+        SCWrite(pCon,buffer, eError);
+        return 0;
+    }
+    
+    assi = (pAsyncQueue)FindCommandData(pServ->pSics, argv[3],"AsyncQueue");
+    if(assi == NULL){
+        snprintf(buffer,2048,"ERROR: %s not found or no AsyncQueue", argv[3]);
+        SCWrite(pCon,buffer,eError);
+        return 0;        
+    }
+    
+    priv->comContext = assi;
+    priv->killComContext = NULL; /* not ours, cleaned up by AsyncQueue module */
+    priv->enqueueNode = AsyncEnqueueNode;
+    priv->enqueueNodeHead = AsyncEnqueueNodeHead;
+    priv->replyCallback = AsyncReply;
+    priv->comError = GCOK;
+
+    /*
+     * This unit is solely for the purpose of receiving event notifications 
+     */
+    uni = AsyncUnitFromQueue(assi); 
+
+    SCSendOK(pCon);
+    return 1;
+}
+/*---------------------------------------------------------------------------*/
+int GenControllerConfigure(SConnection *pCon, SicsInterp *pSics,
+    void *pData, int argc, char *argv[]){
+    pSICSOBJ controller = NULL;
+    pGenController self = NULL;
+    char buffer[2048];
+    
+    if(argc < 3){
+        snprintf(buffer,2048,"ERROR: insufficient arguments to %s", argv[0]);
+        SCWrite(pCon,buffer,eError);
+        return 0;
+    }
+    
+    controller = (pSICSOBJ)FindCommandData(pSics,argv[2], "GenericController");
+    if(controller == NULL){
+        snprintf(buffer,2048,"ERROR: controller %s not found", argv[2]);
+        SCWrite(pCon,buffer,eError);
+        return 0;
+    }
+    
+    strtolower(argv[1]);
+    if(strcmp(argv[1],"makepar") == 0){
+        return MakeGenPar(controller,pCon,argv,argc);
+    } else if(strcmp(argv[1],"asynconnect") == 0){
+        return ConnectAsync(controller, pCon, argv, argc);
+    } else {
+        SCWrite(pCon,"ERROR: argument to GenControllerConfigure not found",
+            eError);
+        return 0;
+    }
+    
+    return 1;        
+}
+/*---------------------------------------------------------------------------*/
+static void killGeneric(void *data){
+    pGenController self = (pGenController)data;
+    
+    if(self == NULL){
+        return;
+    }
+    if(self->comContext != NULL && self->killComContext != NULL){
+        self->killComContext(self->comContext);
+    }
+    free(self);
+}
+/*---------------------------------------------------------------------------*/
+static int EnqueFunc(pSICSOBJ self, SConnection *pCon, pHdb commandNode, 
+    pHdb par[], int nPar){
+    pGenController priv = NULL;
+    pHdb node = NULL;
+    char buffer[512];
+    
+    priv = (pGenController)self->pPrivate;
+    assert(priv != NULL);
+    assert(nPar >= 1);
+    
+    node = GetHipadabaNode(self->objectNode,par[0]->value.v.text);
+    if(node == NULL){
+        snprintf(buffer,511,"ERROR: node %s to enqueue not found",
+            par[0]->value.v.text);
+        SCWrite(pCon,buffer,eError);
+        return 0;
+    }
+    
+    if(priv->enqueueNode != NULL){
+        priv->enqueueNode(self, pCon, node);
+    } else {
+        SCWrite(pCon,"ERROR: GenController NOT configured",eError);
+        return 0;
+    }
+    return 1;
+}                           
+/*---------------------------------------------------------------------------*/
+static int EnqueHeadFunc(pSICSOBJ self, SConnection *pCon, Hdb commandNode,
+    pHdb par[], int nPar){
+    pGenController priv = NULL;
+    pHdb node = NULL;
+    char buffer[512];
+    
+    priv = (pGenController)self->pPrivate;
+    assert(priv != NULL);
+    assert(nPar >= 1);
+    
+    node = GetHipadabaNode(self->objectNode,par[0]->value.v.text);
+    if(node == NULL){
+        snprintf(buffer,511,"ERROR: node %s to enqueue not found",
+            par[0]->value.v.text);
+        SCWrite(pCon,buffer,eError);
+        return 0;
+    }
+    
+    if(priv->enqueueNodeHead != NULL){
+        priv->enqueueNodeHead(self, pCon, node);
+    } else {
+        SCWrite(pCon,"ERROR: GenController NOT configured",eError);
+        return 0;
+    }
+    return 1;
+}                           
+/*---------------------------------------------------------------------------*/
+int GenControllerFactory(SConnection *pCon, SicsInterp *pSics,
+    void *pData, int argc, char *argv[]){
+    pSICSOBJ pNew = NULL;
+    pGenController priv = NULL;
+    hdbValue funcValue, textValue;
+    pHdb node = NULL;
+    char line[132];
+    int status;
+    
+    if(argc < 2){
+        SCWrite(pCon,
+        "ERROR: insufficient number of arguments to GenControllerFactrory",
+        eError);
+        return 0; 
+    }        
+    priv = malloc(sizeof(GenController));
+    if(priv == NULL){
+        SCWrite(pCon,"ERROR: out of memory in GenControllerFactory",
+            eError);
+        return 0;
+    }
+    memset(priv,0,sizeof(GenController));   
+        
+    pNew = MakeSICSOBJ(argv[1],"GenericController");
+    if(pNew == NULL){
+        SCWrite(pCon,"ERROR: out of memory in GenControllerFactory",
+            eError);
+        return 0;
+    }
+    pNew->pPrivate = priv;
+    pNew->KillPrivate = killGeneric;
+    
+    textValue = MakeHdbText("Undefined");
+    funcValue = makeHdbData(HIPFUNC,1,EnqueFunc);
+    node = MakeSICSHdbPar("enqueue",usUser, funcValue);
+    AddSICSHdbPar(node,"node",usUser,textValue);
+    AppendHipadabaCallback(node,HCBSET,MakeSICSFuncCallback(pNew));
+    AddHipadabaChild(pNew->objectNode,node,NULL);
+    
+    funcValue = makeHdbData(HIPFUNC,1,EnqueHeadFunc);
+    node = MakeSICSHdbPar("enqueuehead",usUser, funcValue);
+    AddSICSHdbPar(node,"node",usUser,textValue);
+    AppendHipadabaCallback(node,HCBSET,MakeSICSFuncCallback(pNew));
+    AddHipadabaChild(pNew->objectNode,node,NULL);
+    
+    status = AddCommand(pSics,
+                        argv[1],
+                        InvokeSICSOBJ,
+                        KillSICSOBJ,
+                        pNew);
+    if(status != 1){
+        KillSICSOBJ(pNew);
+        SCPrintf(pCon,eError,"ERROR: failed create duplicate command %s", argv[1]);
+        return 0;
+    }
+    SCSendOK(pCon);
+        
+    return 1;
+}
+

genericcontroller.h

@@ -0,0 +1,37 @@
+/**
+ * This is a generic controller for devices in SICS. In its default configuration it
+ * will be configurable via Tcl scripts and used AsynqQueue for communication. But 
+ * it is suitably generic to support other mechanisms as well.  
+ * 
+ * copyright: see file COPYRIGHT
+ * 
+ * Mark Koennecke, November 2007
+ */
+#ifndef GENERICCONTROLLER_H_
+#define GENERICCONTROLLER_H_
+#include <asyncqueue.h>
+#include <sicshipadaba.h>
+
+#define GCTIMEOUT     5001
+#define GCDISCONNECT  5002
+#define GCOK          5000
+#define GCRECONNECT   5003
+#define GCRETRY       5004
+ 
+typedef struct {
+    int (*enqueueNode)(pSICSOBJ self, SConnection *pCon, pHdb node);
+    int (*enqueueNodeHead)(pSICSOBJ self, SConnection *pCon, pHdb node);
+    int (*replyCallback)(pSICSOBJ self, SConnection *pCon, pHdb node, 
+                        char *replyCommand, char *reply, int replylen);
+    void *comContext;
+    void (*killComContext)(void *data);
+    int comError;
+}GenController, *pGenController;
+/*---------------------------------------------------------------------------*/
+int GenControllerFactory(SConnection *pCon, SicsInterp *pSics,
+    void *pData, int argc, char *argv[]);
+/*---------------------------------------------------------------------------*/
+int GenControllerConfigure(SConnection *pCon, SicsInterp *pSics,
+    void *pData, int argc, char *argv[]);
+
+#endif /*GENERICCONTROLLER_H_*/

geninter.c

@@ -0,0 +1,19 @@
+/**
+ * This is the implementation of various SICS internal interfaces based on 
+ * parameters in a generic controller.
+ * 
+ * copyright: see file COPYRIGHT
+ * 
+ * Mark Koennecke, November 2007 
+ */
+#include <stdlib.h>
+#include <assert.h>
+#include <sics.h>
+#include <sicshipadaba.h>
+
+/*---------------------------------------------------------------------------*/
+int GenDrivableFactory(SConnection *pCon, SicsInterp *pSics,
+    void *pData, int argc, char *argv[]){
+        
+    return 1;        
+}

geninter.h

@@ -0,0 +1,19 @@
+/**
+ * This is the implementation of various SICS internal interfaces based on 
+ * parameters in a generic controller.
+ * 
+ * copyright: see file COPYRIGHT
+ * 
+ * Mark Koennecke, November 2007 
+ */
+#ifndef GENINTER_H_
+#define GENINTER_H_
+/**
+ * make a drivable parameter:
+ * Usage:
+ *    MakeGenDrivable  name par-node control-node
+ */ 
+int GenDrivableFactory(SConnection *pCon, SicsInterp *pSics,
+    void *pData, int argc, char *argv[]);
+
+#endif /*GENINTER_H_*/

hdbqueue.c

@@ -68,7 +68,8 @@ static pHdb MakeNewEntry(char *name, pHdbCallback update){
     return entry;
 }
 /*---------------------------------------------------------------------------*/
-static int EnqueFunc(pSICSOBJ self, SConnection *pCon, pHdb par[], int nPar){
+static int EnqueFunc(pSICSOBJ self, SConnection *pCon, Hdb commandNode,
+    pHdb par[], int nPar){
    pHdb entry = NULL;
    pHdb work = NULL;
    char name[80];
@@ -113,7 +114,8 @@ static int EnqueFunc(pSICSOBJ self, SConnection *pCon, pHdb par[], int nPar){
    return 1; 
 }
 /*---------------------------------------------------------------------------*/
-static int AddCmdData(pSICSOBJ self, SConnection *pCon, pHdb par[], int nPar){
+static int AddCmdData(pSICSOBJ self, SConnection *pCon, Hdb comNode,
+    pHdb par[], int nPar){
     pHdb work = NULL;
     pHdb commandNode = NULL;
     char name[80];
@@ -171,7 +173,8 @@ static void sequentialNames(pHdb obj,SConnection *pCon){
     NotifyHipadabaPar(work,pCon);
 }
 /*---------------------------------------------------------------------------*/
-static int Dequeue(pSICSOBJ self, SConnection *pCon, pHdb par[], int nPar){
+static int Dequeue(pSICSOBJ self, SConnection *pCon, pHdb commandNode,
+    pHdb par[], int nPar){
     pHdb work = NULL;
     char name[80];
     pHdbQueue priv = (pHdbQueue)self->pPrivate;
@@ -198,7 +201,8 @@ static int Dequeue(pSICSOBJ self, SConnection *pCon, pHdb par[], int nPar){
     return 0;
 }
 /*---------------------------------------------------------------------------*/
-static int Clean(pSICSOBJ self, SConnection *pCon, pHdb par[], int nPar){
+static int Clean(pSICSOBJ self, SConnection *pCon,Hdb commandNode,
+     pHdb par[], int nPar){
     int i;
     pHdb current = NULL, queue = NULL;
     pHdb currentEntry  = NULL, tmp = NULL;
@@ -225,7 +229,8 @@ static int Clean(pSICSOBJ self, SConnection *pCon, pHdb par[], int nPar){
     return 1;
 }
 /*---------------------------------------------------------------------------*/
-static int CleanAll(pSICSOBJ self, SConnection *pCon, pHdb par[], int nPar){
+static int CleanAll(pSICSOBJ self, SConnection *pCon, pHdb commandNode,
+    pHdb par[], int nPar){
     int i;
     pHdb current = NULL, queue = NULL;
     pHdb currentEntry  = NULL, tmp;
@@ -292,7 +297,8 @@ static int QueueTask(void *pData){
     return 1;
 }
 /*---------------------------------------------------------------------------*/
-static int Start(pSICSOBJ self, SConnection *pCon, pHdb par[], int nPar){
+static int Start(pSICSOBJ self, SConnection *pCon, pHdb commandNode,
+    pHdb par[], int nPar){
     pHdbQueue priv = (pHdbQueue)self->pPrivate;
 
     priv->iStop = 0;    
@@ -313,7 +319,8 @@ static int Start(pSICSOBJ self, SConnection *pCon, pHdb par[], int nPar){
     return 1;
 }   
 /*---------------------------------------------------------------------------*/
-static int Restart(pSICSOBJ self, SConnection *pCon, pHdb par[], int nPar){
+static int Restart(pSICSOBJ self, SConnection *pCon, pHdb commandNode,
+    pHdb par[], int nPar){
     pHdbQueue priv = (pHdbQueue)self->pPrivate;
     pHdb maxCurrent  = NULL;
     
@@ -323,17 +330,19 @@ static int Restart(pSICSOBJ self, SConnection *pCon, pHdb par[], int nPar){
         NotifyHipadabaPar(maxCurrent,pCon);
     }
 
-    return Start(self,pCon,par,nPar);
+    return Start(self,pCon,commandNode,par,nPar);
 }   
 /*---------------------------------------------------------------------------*/
-static int Stop(pSICSOBJ self, SConnection *pCon, pHdb par[], int nPar){
+static int Stop(pSICSOBJ self, SConnection *pCon, pHdb commandNode,
+    pHdb par[], int nPar){
     pHdbQueue priv = (pHdbQueue)self->pPrivate;
     
     priv->iStop = 1;
     return 1; 
 }
 /*----------------------------------------------------------------------------*/
-static int Move(pSICSOBJ self, SConnection *pCon, pHdb par[], int nPar){
+static int Move(pSICSOBJ self, SConnection *pCon, pHdb commandNode,
+     pHdb par[], int nPar){
     pHdb moveNode = NULL;
     pHdb insertNode = NULL;
     pHdb prevNode = NULL, queueNode = NULL;

hipadaba.c

@@ -401,7 +401,7 @@ hdbValue MakeHdbIntArray(int length, int *data){
     return result;
 }
 /*-------------------------------------------------------------------------*/
-hdbValue MakeHdbFloatArrray(int length, double *data){
+hdbValue MakeHdbFloatArray(int length, double *data){
     hdbValue result;
     
     result.dataType = HIPFLOATAR;
@@ -411,6 +411,10 @@ hdbValue MakeHdbFloatArrray(int length, double *data){
 }
 /*-------------------------------------------------------------------------*/
 void ReleaseHdbValue(hdbValue *v){
+    
+    if(v->doNotFree == 1){
+        return;
+    }
     switch(v->dataType){
         case HIPTEXT:
             if(v->v.text != NULL){
@@ -871,10 +875,30 @@ void InternalRemoveHipadabaCallback(pHdb root, int internalID){
     }
 }
 /*=================== parameter interface ====================================*/
+static int canCopy(hdbValue *source, hdbValue *target){
+    if(target->dataType == HIPINTVARAR) {
+        if(source->dataType == HIPINTAR || 
+            source->dataType == HIPINTVARAR){
+            return 1;
+        }
+    }
+    if(target->dataType == HIPFLOATVARAR) {
+        if(source->dataType == HIPFLOATAR || 
+            source->dataType == HIPFLOATVARAR){
+            return 1;
+        }
+    }
+    if(source->dataType != target->dataType){
+        return 0;
+    } else {
+        return 1;
+    }
+}
+/*----------------------------------------------------------------------------*/
 int copyHdbValue(hdbValue *source, hdbValue *target){
     int i;
     
-    if(source->dataType != target->dataType){
+    if(!canCopy(source,target)){
         return 0;
     }
     

hipadaba.h

@@ -52,6 +52,7 @@
 typedef struct __hdbValue {
         int dataType;
         int arrayLength;
+        int doNotFree;
         union __value {
 	       int intValue;
             double doubleValue;

histsim.c

@@ -204,7 +204,13 @@
                             int i, int iStart, int iEnd, HistInt *lData)
  {
    iSet = 2;
+   if(self->data->localBuffer == NULL){
+    resizeBuffer(self->data);
+   }
    iSetVal = lData[0];
+   if(iEnd < getHMDataLength(self->data)){
+      memcpy(self->data->localBuffer+iStart,lData,(iEnd - iStart)*sizeof(HistInt));
+   }
    return 1;
  }
 

hkl.c

@@ -52,7 +52,10 @@
         return 1;
       }
       fprintf(fd,"#Crystallographic Settings\n");
-      fprintf(fd,"%s lambda %f\n",name, self->fLambda);
+      if(self->iManual == 1)
+      {
+        fprintf(fd,"%s lambda %f\n",name, self->fLambda);
+      }
       fprintf(fd,
       "%s setub %8.6f %8.6f %8.6f %8.6f %8.6f %8.6f %8.6f %8.6f %8.6f\n",
          name, 

lld_blob.c

@@ -28,6 +28,21 @@ int LLDblobCreate( void )
     return LLDcreate( sizeof( struct BlobDesc ));
 }
 
+/*---------------------------------------------------------------------*/
+int LLDdeleteBlob(int List)
+{
+    struct BlobDesc Blob ;
+    int status;
+    
+    status = LLDnodePtr2First(List);
+    while(status == 1){
+        LLDnodeDataTo( List, & Blob );
+        free(Blob.data);
+        status = LLDnodePtr2Next(List);
+    }
+    LLDdelete(List);
+    return 1;
+}
 /* ---- LL blob node mangement ---------------------------------------- */
 
 int LLDblobInsert( int List, void * Source, unsigned Size )

lld_blob.h

@@ -20,7 +20,8 @@
 int  LLDblobCreate( void );
                         /* returns list number to use or -1 on failure. */
                         /* MUST be called before using a list of blobs. */
-
+int LLDdeleteBlob(int List);
+                       /* deletes a list and all its data */
 /* ---- Node management --------------------------------------------------
    Functions changing current node pointer to the new node.
    A return value of -1 indicates a memory allocation problem.

macro.c

@@ -70,6 +70,7 @@
 #include "servlog.h"
 #include "stringdict.h"
 #include "exeman.h"
+#include "nxcopy.h"
 
 #define SICSERROR "005567SICS"
 /*----------------------------------------------------------------------------
@@ -301,7 +302,8 @@ static int ProtectedExec(ClientData clientData, Tcl_Interp *interp,
 /*--------------------------------------------------------------------------
   initialises a Tcl-Interpreter, installs SICS unknown mechanism and kills
   a few dangerous commands from the normal Tcl command set 
-*/
+----------------------------------------------------------------------------*/
+extern int Nxinter_SafeInit(Tcl_Interp *pTcl); /* from Swig NeXus Tcl interface */
 
   Tcl_Interp *MacroInit(SicsInterp *pSics)
   {
@@ -345,6 +347,9 @@ static int ProtectedExec(ClientData clientData, Tcl_Interp *interp,
       */
       Tcl_CreateObjCommand(pInter,"exec",ProtectedExec,NULL,KillExec);
 
+      Nxinter_SafeInit(pInter);
+      NXcopy_Init(pInter);
+      
       return pInter;
   }
 /*--------------------------------------------------------------------------*/

make_gen

@@ -33,7 +33,8 @@ SOBJ =  network.o ifile.o conman.o SCinter.o splitter.o passwd.o \
        sinfox.o sicslist.o cone.o hipadaba.o sicshipadaba.o statistics.o \
        moregress.o hdbcommand.o multicounter.o regresscter.o histregress.o \
        sicshdbadapter.o polldriv.o sicspoll.o statemon.o hmslave.o \
-       nwatch.o asyncqueue.o asyncprotocol.o sicsobj.o hdbqueue.o
+       nwatch.o asyncqueue.o asyncprotocol.o sicsobj.o hdbqueue.o\
+       nxcopy.o nxinterhelper.o nxinter_wrap.o genericcontroller.o
  
 MOTOROBJ = motor.o  simdriv.o  
 COUNTEROBJ =  countdriv.o simcter.o counter.o

makefile_slinux

@@ -23,8 +23,8 @@ BINTARGET = bin
 EXTRA=nintf.o
 SUBLIBS = psi/libpsi.a psi/hardsup/libhlib.a matrix/libmatrix.a \
 	psi/tecs/libtecsl.a
-LIBS =  -L$(HDFROOT)/lib $(SUBLIBS) $(NILIB)\
+LIBS =   -L$(HDFROOT)/lib $(SUBLIBS) $(NILIB)\
-       -ltcl8.3 $(HDFROOT)/lib/libhdf5.a  \
+       -ltcl  $(HDFROOT)/lib/libhdf5.a  \
        $(HDFROOT)/lib/libmfhdf.a $(HDFROOT)/lib/libdf.a \
        $(HDFROOT)/lib/libjpeg.a -lsz $(HDFROOT)/lib/libjson.a \
        -ldl -lz -lmxml -lghttp -lm  -lc 

multicounter.c

@@ -372,8 +372,7 @@ int MakeMultiCounter(SConnection *pCon, SicsInterp *pSics,
   pDriv->GetError    = MultiCounterError;
   pDriv->TryAndFixIt = MultiCounterFix;
   pDriv->Set         = MultiCounterSet;
-  pDriv->Send        
+  pDriv->Send        = MultiCounterSend;
-= MultiCounterSend;
   
   /*
     assign interface functions

napi5.c

@@ -934,7 +934,7 @@ static void killAttVID(pNexusFile5 pFile, int vid){
     int rank;
     hsize_t myStart[H5S_MAX_RANK];
     hsize_t mySize[H5S_MAX_RANK];
-    hsize_t size[1],maxdims[H5S_MAX_RANK];
+    hsize_t size[H5S_MAX_RANK],maxdims[H5S_MAX_RANK];
     hid_t   filespace,dataspace; 
   
     pFile = NXI5assert (fid);
@@ -948,6 +948,7 @@ static void killAttVID(pNexusFile5 pFile, int vid){
     {
        myStart[i] = iStart[i];
        mySize[i]  = iSize[i];
+       size[i]    = iSize[i];
     }
     iRet = H5Sget_simple_extent_dims(pFile->iCurrentS, NULL, maxdims);
     dataspace = H5Screate_simple (rank, mySize, NULL);

nserver.c

@@ -273,6 +273,13 @@
      /* install telnet port */
      InstallTelnet();
      
+     /* If the restore file has not been loaded, do so now */
+     if(!hasRestored())
+     {
+        strcpy(pBueffel,"restore");
+        SCInvoke(self->dummyCon,self->pSics,pBueffel);
+     }
+     
      /* exit handlers need to be installed here */
      atexit(StopExit);
      Fortify_CheckAllMemory();

nxcopy.c

@@ -0,0 +1,294 @@
+/**
+ * This defines a couple of Tcl functions which allow to copy data from the 
+ * nxdataset's returned from the swig Tcl interface to NeXus files into 
+ * SICS data structures.
+ * 
+ * copyright: see file COPYRIGHT
+ * 
+ * Mark Koennecke, October 2007
+ */
+#include <sics.h>
+#include "nxdataset.h"
+#include "sicshipadaba.h"
+#include "sicsdata.h"
+#include "nxcopy.h"
+#include "HistMem.h"
+/*-------------------------------------------------------------------------------
+ * decode a SWIG style pointer into the real pointer value.
+ * Stolen from SWIG generated code.
+ --------------------------------------------------------------------------------*/
+static const char *SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
+  register unsigned char *u = (unsigned char *) ptr;
+  register const unsigned char *eu = u + sz;
+  for (; u != eu; ++u) {
+    register char d = *(c++);
+    register unsigned char uu;
+    if ((d >= '0') && (d <= '9'))
+      uu = ((d - '0') << 4);
+    else if ((d >= 'a') && (d <= 'f'))
+      uu = ((d - ('a'-10)) << 4);
+    else 
+      return (char *) 0;
+    d = *(c++);
+    if ((d >= '0') && (d <= '9'))
+      uu |= (d - '0');
+    else if ((d >= 'a') && (d <= 'f'))
+      uu |= (d - ('a'-10));
+    else 
+      return (char *) 0;
+    *u = uu;
+  }
+  return c;
+}
+/*-------------------------------------------------------------------------------*/
+int isTypeAllowed(int type){
+    switch(type){
+        case NX_INT32:
+        case NX_UINT32:
+        case NX_FLOAT32:
+            return 1;
+            break;
+        default:
+            return 0;
+            break;
+    }
+}   
+/*--------------------------------------------------------------------------------
+ * copy an nxdataset to a sicsdata object
+ --------------------------------------------------------------------------------*/
+static int NXDataToSicsdata(ClientData clientData, Tcl_Interp *interp,
+             int objc, Tcl_Obj *CONST objv[]){
+   Tcl_Obj *resultPtr; 
+   const char *text;
+   pNXDS data = NULL;
+   pSICSData sicsData;
+   int length, i;
+                
+   if(objc < 3) {
+        Tcl_WrongNumArgs(interp,objc,objv,"Usage: nxdatatosicsdata nxdata sicsdata");
+        return TCL_ERROR;
+   }
+   resultPtr = Tcl_GetObjResult(interp);
+ 
+   /* 
+    * get nxdataset pointer
+    */
+   text = Tcl_GetStringFromObj(objv[1],NULL);
+   if(strstr(text,"NULL") != NULL){
+        Tcl_SetStringObj(resultPtr,"nxdata argument is NULL pointer",38);
+        return TCL_ERROR;    
+   }
+   text++;
+   SWIG_UnpackData(text,&data,sizeof(void *));
+
+   if(data->magic != MAGIC){
+        Tcl_SetStringObj(resultPtr,"nxdata argument is no valid nxdataset",
+            strlen("nxdata argument is no valid nxdataset"));
+        return TCL_ERROR;    
+   }
+   length = getNXDatasetLength(data);
+   if(!isTypeAllowed(data->type)){
+       Tcl_SetStringObj(resultPtr,"can only copy int and float types",
+        strlen("can only copy int and float types"));
+       return TCL_ERROR;    
+   }
+
+   /*
+    * locate sicsdata 
+    */
+   text = Tcl_GetStringFromObj(objv[2],NULL);
+   sicsData = (pSICSData)FindCommandData(pServ->pSics,(char *)text,"SICSData");
+   if(sicsData == NULL){
+        Tcl_SetStringObj(resultPtr,"sicsdata argument is no valid SICSData",
+            strlen("sicsdata argument is no valid SICSData"));
+        return TCL_ERROR;    
+   }
+   
+   /*
+    * copy the data
+    */
+   if(data->type == NX_FLOAT32){
+        for(i = 0; i < length; i++){
+            setSICSDataFloat(sicsData,i,data->u.fPtr[i]);
+        }
+   } else {
+        for(i = 0; i < length; i++){
+            setSICSDataInt(sicsData,i,data->u.iPtr[i]);
+        }
+   }
+   
+   return TCL_OK;               
+}
+/*--------------------------------------------------------------------------*/
+static hdbValue NXDatasetToHdbValue(pNXDS data){
+    hdbValue val;
+    int length, i;
+    
+    length = getNXDatasetLength(data);
+    switch(getNXDatasetType(data)){
+        case NX_INT32:
+        case NX_UINT32:
+            if(length == 1){
+                val = MakeHdbInt(data->u.iPtr[0]);
+            } else {
+                val = MakeHdbIntArray(length,data->u.iPtr);
+                val.dataType = HIPINTVARAR;
+            }
+            break;
+        case NX_FLOAT32:
+           if(length == 1){
+                val = MakeHdbFloat((double)data->u.fPtr[0]);
+            } else {
+                val = makeHdbValue(HIPFLOATAR,length);
+                for(i = 0; i < length; i++){
+                    val.v.floatArray[i] = (double)data->u.fPtr[i];
+                }
+                val.dataType = HIPFLOATVARAR;
+            }
+            break;
+        case NX_FLOAT64:
+           if(length == 1){
+                val = MakeHdbFloat(data->u.dPtr[0]);
+            } else {
+                val = MakeHdbFloatArray(length,data->u.dPtr);
+            }
+            break;
+        case NX_CHAR:
+        case NX_INT8:
+        case NX_UINT8:
+            val = MakeHdbText(data->u.cPtr);
+            break;
+        case NX_INT16:
+        case NX_UINT16:
+             if(length == 1){
+                val = MakeHdbInt((int)data->u.sPtr[0]);
+             } else {
+                val = makeHdbValue(HIPINTAR,length);
+                for(i = 0; i < length; i++){
+                    val.v.intArray[i] = (int)data->u.sPtr[i];
+                }
+             }  
+             break;        
+    }
+    return val;
+}
+/*---------------------------------------------------------------------------
+ * copy the content of an nxdataset onto a Hipadaba node
+ *---------------------------------------------------------------------------*/
+static int NXDataToHdbNode(ClientData clientData, Tcl_Interp *interp,
+             int objc, Tcl_Obj *CONST objv[]){
+   pNXDS data = NULL;
+   Tcl_Obj *resultPtr;
+   int length, status;
+   const char *text;    
+   pHdb node = NULL;
+   hdbValue val;
+
+   if(objc < 3) {
+        Tcl_WrongNumArgs(interp,objc,objv,"Usage: nxdatatohdb nxdata path");
+        return TCL_ERROR;
+   }
+   resultPtr = Tcl_GetObjResult(interp);
+ 
+   /* 
+    * get nxdataset pointer
+    */
+   text = Tcl_GetStringFromObj(objv[1],NULL);
+   if(strstr(text,"NULL") != NULL){
+        Tcl_SetStringObj(resultPtr,"nxdata argument is NULL pointer",38);
+        return TCL_ERROR;    
+   }
+   text++;
+   SWIG_UnpackData(text,&data,sizeof(void *));
+
+   if(data->magic != MAGIC){
+        Tcl_SetStringObj(resultPtr,"nxdata argument is no valid nxdataset",
+            strlen("nxdata argument is no valid nxdataset"));
+        return TCL_ERROR;    
+   }
+   length = getNXDatasetLength(data);
+
+   /*
+    * locate node
+    */
+   text = Tcl_GetStringFromObj(objv[2],NULL);
+   node =  GetHipadabaNode(GetHipadabaRoot(),(char *)text);
+   if(node == NULL){
+        Tcl_SetStringObj(resultPtr,"path does not point to a valid node",
+            strlen("path does not point to a valid node"));
+        return TCL_ERROR;    
+   }
+   
+   val = NXDatasetToHdbValue(data);
+   status = UpdateHipadabaPar(node,val,NULL);
+   if(status != 1){
+        Tcl_SetStringObj(resultPtr,"data type mismatch",
+            strlen("data type mismatch"));
+        return TCL_ERROR;    
+   }
+   return TCL_OK;                
+}
+/*---------------------------------------------------------------------------*/
+static int NXDataToHM(ClientData clientData, Tcl_Interp *interp,
+             int objc, Tcl_Obj *CONST objv[]){
+   pNXDS data = NULL;
+   Tcl_Obj *resultPtr;
+   int length, status;
+   const char *text; 
+   pHistMem pHM = NULL;   
+   SConnection *pCon = NULL;
+
+   if(objc < 3) {
+        Tcl_WrongNumArgs(interp,objc,objv,"Usage: nxdatatohdb nxdata path");
+        return TCL_ERROR;
+   }
+   resultPtr = Tcl_GetObjResult(interp);
+ 
+   /* 
+    * get nxdataset pointer
+    */
+   text = Tcl_GetStringFromObj(objv[1],NULL);
+   if(strstr(text,"NULL") != NULL){
+        Tcl_SetStringObj(resultPtr,"nxdata argument is NULL pointer",38);
+        return TCL_ERROR;    
+   }
+   text++;
+   SWIG_UnpackData(text,&data,sizeof(void *));
+
+   if(data->magic != MAGIC){
+        Tcl_SetStringObj(resultPtr,"nxdata argument is no valid nxdataset",
+            strlen("nxdata argument is no valid nxdataset"));
+        return TCL_ERROR;    
+   }
+   length = getNXDatasetLength(data);
+   
+   /*
+    * get HM
+    */
+   text = Tcl_GetStringFromObj(objv[2],NULL);
+   pHM = (pHistMem)FindCommandData(pServ->pSics,(char *)text,"HistMem");
+   if(pHM == NULL){
+        Tcl_SetStringObj(resultPtr,"hm argument is not histogram memory",
+            strlen("hm argument is not histogram memory"));
+        return TCL_ERROR;    
+   }
+   
+   if(getNXDatasetType(data) != NX_INT32 || GetHistLength(pHM) < length){
+        Tcl_SetStringObj(resultPtr,"data to hm type or length mismatch",
+            strlen("data to hm type or length mismatch"));
+        return TCL_ERROR;    
+   }
+                
+   pCon = SCCreateDummyConnection(pServ->pSics);             
+   SetHistogram(pHM, pCon, 0,0,length,  data->u.iPtr);
+   SCDeleteConnection(pCon);
+            
+   return TCL_OK;              
+}
+/*---------------------------------------------------------------------------*/
+int NXcopy_Init(Tcl_Interp *pInter){
+    Tcl_CreateObjCommand(pInter,"nxToSicsData",NXDataToSicsdata,NULL,NULL);
+    Tcl_CreateObjCommand(pInter,"nxToHdb",NXDataToHdbNode,NULL,NULL);
+    Tcl_CreateObjCommand(pInter,"nxToHM",NXDataToHM,NULL,NULL);
+    return 1;
+}

nxcopy.h

@@ -0,0 +1,16 @@
+/**
+ * This defines a couple of Tcl functions which allow to copy data from the 
+ * nxdataset's returned from the swig Tcl interface to NeXus files into 
+ * SICS data structures.
+ * 
+ * copyright: see file COPYRIGHT
+ * 
+ * Mark Koennecke, October 2007
+ */
+#ifndef NXCOPY_H_
+#define NXCOPY_H_
+#include <tcl.h>
+
+int NXcopy_Init(Tcl_Interp *pTcl);
+
+#endif /*NXCOPY_H_*/

nxinterhelper.c

@@ -0,0 +1,561 @@
+/*
+  This is a library of support functions and data structures which can be
+  used in order to create interfaces between the NeXus-API and scripting
+  languages or data analysis systems with a native code interface. 
+
+  copyright: GPL
+
+  Mark Koennecke, October 2002
+  Mark Koennecke, November 2002
+*/
+#include <stdlib.h>
+#include <assert.h>
+#include <string.h>
+#include <stdio.h>
+#include "nxinterhelper.h"
+#include "nxdataset.h"
+/*-----------------------------------------------------------------
+  An own error handler. nx_getlasterror will return the test of
+  the last NeXus error.
+  --------------------------------------------------------------------*/
+static char errorText[256]= "";
+
+static void nxinterError(void *pData, char *error){
+  strncpy(errorText,error,255);
+}
+/*-----------------------------------------------------------------------*/
+char *nx_getlasterror(void){
+  return strdup(errorText);
+}
+/*-------------------- opening and closing -------------------------------*/
+void *nx_open(char *filename, int accessMethod){
+  NXhandle handle = NULL;
+  int status;
+
+  NXMSetError(NULL,nxinterError);
+  status = NXopen(filename,(NXaccess)accessMethod, &handle);
+  if(status == NX_OK){
+    return handle;
+  }else{
+    return NULL;
+  }
+}
+/*------------------------------------------------------------------------*/
+void *nx_flush(void *hundle){
+  NXhandle handle;
+  int status;
+
+  handle = (NXhandle)hundle;
+  status = NXflush(&handle);
+  if(status == NX_OK){
+    return handle;
+  } else {
+    return NULL;
+  }
+}
+/*-----------------------------------------------------------------------*/
+void nx_close(void *hundle){
+  NXhandle handle;
+
+  handle = (NXhandle)hundle;
+  NXclose(&handle);
+}
+/*=================== group handling functions ========================*/
+int nx_makegroup(void *handle, char *name, char *nxclass){
+  int status;
+  NXhandle hfil;
+
+  hfil = (NXhandle)handle;
+  status = NXmakegroup(hfil,name, nxclass);
+  if(status == NX_OK){
+    return 1;
+  } else {
+    return 0;
+  }
+}
+/*---------------------------------------------------------------------*/
+int nx_opengroup(void *handle, char *name, char *nxclass){
+  int status;
+  NXhandle hfil;
+
+  hfil = (NXhandle)handle;
+  status = NXopengroup(hfil,name, nxclass);
+  if(status == NX_OK){
+    return 1;
+  } else {
+    return 0;
+  }
+}
+/*---------------------------------------------------------------------*/
+int nx_openpath(void *handle, char *path){
+  int status;
+  NXhandle hfil;
+
+  hfil = (NXhandle)handle;
+  status = NXopenpath(hfil,path);
+  if(status == NX_OK){
+    return 1;
+  } else {
+    return 0;
+  }
+}
+/*---------------------------------------------------------------------*/
+int nx_opengrouppath(void *handle, char *path){
+  int status;
+  NXhandle hfil;
+
+  hfil = (NXhandle)handle;
+  status = NXopengrouppath(hfil,path);
+  if(status == NX_OK){
+    return 1;
+  } else {
+    return 0;
+  }
+}
+/*--------------------------------------------------------------------*/
+int nx_closegroup(void *handle){
+  int status;
+  NXhandle hfil;
+
+  hfil = (NXhandle)handle;
+  status = NXclosegroup(hfil);
+  if(status == NX_OK){
+    return 1;
+  } else {
+    return 0;
+  }
+}
+/*-------------------------------------------------------------------*/
+char *nx_getnextentry(void *handle, char separator){
+  int status, length, type;
+  NXhandle hfil;
+  char *resultBuffer = NULL;
+  NXname group,nxclass;
+
+  hfil = (NXhandle)handle;
+  status = NXgetnextentry(hfil,group, nxclass,&type);
+  if(status == NX_OK){
+    length = 30 + strlen(group) + strlen(nxclass);
+    /*
+      This introduces a memory leak. I had hoped, that swig would
+      kill it for me after use, but I'am afraid, this is not the
+      case. Unfortately I do not know how to fix the issue.
+    */
+    resultBuffer = (char *)malloc(length*sizeof(char));
+    if(resultBuffer == NULL){
+      return NULL;
+    }
+    sprintf(resultBuffer,"%s%c%s%c%d",group,separator,nxclass,
+	    separator,type);
+    return resultBuffer;
+  } else {
+    return NULL;
+  }
+}
+/*-------------------------------------------------------------------*/
+void *nx_getgroupID(void *handle){
+  int status;
+  NXhandle hfil;
+  NXlink *linki;
+
+  linki = (NXlink *)malloc(sizeof(NXlink));
+  if(linki == NULL){
+    return NULL;
+  }
+  hfil = (NXhandle)handle;
+  status = NXgetgroupID(hfil,linki);
+  if(status == NX_OK){
+    return linki;
+  } else {
+    return NULL;
+  }
+}
+/*------------------------------------------------------------------*/
+int  nx_initgroupdir(void *handle){
+  int status;
+  NXhandle hfil;
+
+  hfil = (NXhandle)handle;
+  status = NXinitgroupdir(hfil);
+  if(status == NX_OK){
+    return 1;
+  } else {
+    return 0;
+  }
+}
+/*========================== dataset handling =======================*/
+int nx_makedata(void *ptr, char *name, int rank, int type, 
+		    void *dimPtr){
+  int status;
+  NXhandle hfil;
+  pNXDS dimData;
+
+  hfil = (NXhandle)ptr;
+  dimData = (pNXDS)dimPtr;
+  if(dimData->type != NX_INT32){
+    NXIReportError(NULL,"ERROR: dimension data not integer");
+    return 0;
+  }
+  status = NXmakedata(hfil, name, type, rank, 
+		      dimData->u.iPtr);
+  if(status == NX_OK){
+    return 1;
+  } else {
+    return 0;
+  }
+}
+/*--------------------------------------------------------------------*/
+int nx_compmakedata(void *ptr, char *name, int rank, int type, 
+		    void *dimPtr, void *bufPtr){
+  int status;
+  NXhandle hfil;
+  pNXDS dimData, bufData;
+
+  hfil = (NXhandle)ptr;
+  dimData = (pNXDS)dimPtr;
+  if(dimData->type != NX_INT32){
+    NXIReportError(NULL,"ERROR: dimension data not integer");
+    return 0;
+  }
+  bufData = (pNXDS)bufPtr;
+  status = NXcompmakedata(hfil, name, type, rank, 
+			  dimData->u.iPtr, NX_COMP_LZW,bufData->u.iPtr);
+  if(status == NX_OK){
+    return 1;
+  } else {
+    return 0;
+  }
+}
+/*----------------------------------------------------------------------*/
+int nx_opendata(void *handle, char *name){
+  int status;
+  NXhandle hfil;
+
+  hfil = (NXhandle)handle;
+  status = NXopendata(hfil,name);
+  if(status == NX_OK){
+    return 1;
+  } else {
+    return 0;
+  }
+}
+/*----------------------------------------------------------------------*/
+int nx_closedata(void *handle){
+  int status;
+  NXhandle hfil;
+
+  hfil = (NXhandle)handle;
+  status = NXclosedata(hfil);
+  if(status == NX_OK){
+    return 1;
+  } else {
+    return 0;
+  }
+}
+/*------------------------------------------------------------------------*/
+int nx_putslab(void *handle, void *dataset, void *startDim){
+  int status;
+  NXhandle hfil;
+  pNXDS data;
+  pNXDS start;
+  int  end[NX_MAXRANK], i;
+
+  hfil = (NXhandle)handle;
+  data = (pNXDS)dataset;
+  start = (pNXDS)startDim;
+  for(i = 0; i < data->rank;i++){
+    end[i] = data->dim[i];
+  }
+
+  status = NXputslab(hfil,data->u.ptr,start->u.iPtr,end);
+  if(status == NX_OK){
+    return 1;
+  } else {
+    return 0;
+  }
+}
+/*-----------------------------------------------------------------------*/
+void *nx_getslab(void *handle, void *startdim, void *sizedim){
+  pNXDS resultdata;
+  pNXDS start, size;
+  int status, rank, type, dim[NX_MAXRANK];
+  NXhandle hfil;
+
+  hfil = (NXhandle)handle;
+  start = (pNXDS)startdim;
+  size =   (pNXDS)sizedim;
+
+  /*
+    get info first, then allocate data
+  */
+  status = NXgetinfo(hfil, &rank,dim,&type);
+  if(status != NX_OK){
+    return NULL;
+  }
+  
+  resultdata = createNXDataset(rank,type,size->u.iPtr);
+  if(resultdata == NULL){
+    return NULL;
+  }
+
+  status = NXgetslab(hfil,resultdata->u.ptr,start->u.iPtr,
+		     size->u.iPtr);
+  if(status == NX_OK){
+    return resultdata;
+  }else{
+    dropNXDataset(resultdata);
+    return NULL;
+  }
+}
+/*------------------------------------------------------------------------*/
+void *nx_getds(void *handle, char *name){
+  pNXDS result = NULL;
+  int rank, type,dim[NX_MAXRANK],status;
+  NXhandle hfil;
+
+  hfil = (NXhandle)handle;
+  status = NXopendata(hfil,name);
+  if(status != NX_OK){
+    return NULL;
+  }
+
+  status = NXgetinfo(hfil,&rank,dim,&type);
+  if(status != NX_OK){
+    return NULL;
+  }
+
+  result = createNXDataset(rank,type,dim);
+  if(result == NULL){
+    NXclosedata(hfil);
+    return NULL;
+  }
+
+  status = NXgetdata(hfil,result->u.ptr);
+  if(result == NULL){
+    NXclosedata(hfil);
+    dropNXDataset(result);
+    return NULL;
+  }
+  NXclosedata(hfil);
+  return result;
+}
+/*----------------------------------------------------------------------*/
+int   nx_putds(void *handle, char *name, void *dataset){
+  NXhandle hfil;
+  int status;
+  pNXDS data;
+
+  hfil = (NXhandle)handle;
+  data = (pNXDS)dataset;
+
+  status = NXopendata(hfil,name);
+  if(status != NX_OK){
+    status = NXmakedata(hfil,name,data->type,data->rank,data->dim);
+    if(status != NX_OK){
+      return 0;
+    }
+    NXopendata(hfil,name);
+  }
+
+  status = NXputdata(hfil,data->u.ptr);
+  NXclosedata(hfil);
+  if(status != NX_OK){
+    return 0;
+  }else{
+    return 1;
+  }
+}
+/*------------------------------------------------------------------------*/
+void *nx_getdata(void *handle){
+  pNXDS result = NULL;
+  int rank, type,dim[NX_MAXRANK],status;
+  NXhandle hfil;
+
+
+  hfil = (NXhandle)handle;
+  status = NXgetinfo(hfil,&rank,dim,&type);
+  if(status != NX_OK){
+    return NULL;
+  }
+
+  result = createNXDataset(rank,type,dim);
+  if(result == NULL){
+    NXclosedata(hfil);
+    return NULL;
+  }
+
+  status = NXgetdata(hfil,result->u.ptr);
+  if(result == NULL){
+    dropNXDataset(result);
+    return NULL;
+  }
+  return result;
+}
+/*----------------------------------------------------------------------*/
+int   nx_putdata(void *handle, void *dataset){
+  NXhandle hfil;
+  int status;
+  pNXDS data;
+
+  hfil = (NXhandle)handle;
+  data = (pNXDS)dataset;
+
+  if(data == NULL){
+    NXIReportError(NULL,"ERROR: NULL data pointer in nx_putdata");
+    return 0;
+  }
+
+  status = NXputdata(hfil,data->u.ptr);
+  if(status != NX_OK){
+    return 0;
+  }else{
+    return 1;
+  }
+}
+/*----------------------------------------------------------------------*/
+void *nx_getinfo(void *handle){
+  NXhandle hfil;
+  int status, type, rank, dim[NX_MAXRANK], rdim[1], i;
+  pNXDS data = NULL;
+
+  hfil = (NXhandle)handle;
+
+  status = NXgetinfo(handle,&rank,dim,&type);
+  if(status != NX_OK){
+    return NULL;
+  }
+  rdim[0] = 2 + rank;
+  data = createNXDataset(1,NX_INT32,rdim);
+  data->u.iPtr[0] = type;
+  data->u.iPtr[1] = rank;
+  for(i = 0; i < rank; i++){
+    data->u.iPtr[2+i] = dim[i];
+  }
+  return data;
+}
+/*----------------------------------------------------------------------*/
+void *nx_getdataID(void *handle){
+  NXhandle hfil;
+  int status;
+  NXlink *linki;
+
+  linki = (NXlink *)malloc(sizeof(NXlink));
+  if(linki == NULL){
+    return NULL;
+  }
+
+  hfil = (NXhandle)handle;
+  status = NXgetdataID(hfil,linki);
+  if(status == NX_OK){
+    return linki;
+  } else {
+    free(linki);
+    return NULL;
+  }
+}
+/*-------------------------------------------------------------------*/
+char *nx_getnextattr(void *handle, char separator){
+  int status, length, type;
+  char *result;
+  NXhandle hfil;
+  NXname aName;
+
+  hfil = (NXhandle)handle;
+  status = NXgetnextattr(hfil,aName, &length, &type);
+  if(status == NX_OK){
+    /*
+      This introduces a memory leak. I had hoped, that swig would
+      kill it for me after use, but I'am afraid, this is not the
+      case. Unfortately I do not know how to fix the issue.
+    */
+    result = (char *)malloc((20+strlen(aName))*sizeof(char));
+    if(result == NULL){
+      return NULL;
+    }
+    memset(result,0,(20+strlen(aName))*sizeof(char));
+    sprintf(result,"%s%c%d%c%d", aName,separator,
+	    length,separator,type);
+    return result;
+  } else {
+    return NULL;
+  }
+}
+/*-------------------------------------------------------------------*/
+int   nx_putattr(void *handle, char *name, void *ds){
+  int status;
+  NXhandle hfil;
+  pNXDS data;
+
+  hfil = (NXhandle)handle;
+  data = (pNXDS)ds;
+  status = NXputattr(hfil,name,data->u.ptr,data->dim[0],data->type);
+  if(status == NX_OK){
+    return 1;
+  }else{
+    return 0;
+  }
+}
+/*-------------------------------------------------------------------*/
+void *nx_getattr(void *handle, char *name, int type, int length){
+  NXhandle hfil;
+  int status, tp, ll, dim[1];
+  pNXDS data = NULL;
+
+
+  hfil = (NXhandle)handle;
+
+  /*
+    prepare dataset
+  */
+  dim[0] = length+1;
+  data = createNXDataset(1,type,dim);
+  if(data == NULL){
+    return NULL;
+  }
+  
+  /*
+    finally read the real data
+  */
+  ll = length;
+  tp = type;
+  status = NXgetattr(hfil,name,data->u.ptr,&ll,&tp);
+  if(status != NX_OK){
+    dropNXDataset(data);
+    return NULL;
+  }
+
+  return data;
+}
+/*-----------------------------------------------------------------------*/
+int nx_makelink(void *handle, void *link){
+  NXhandle hfil;
+  NXlink* lk;
+  int status;
+
+  hfil = (NXhandle)handle;
+  lk = (NXlink *)link;
+
+  status = NXmakelink(hfil,lk);
+  if(status == NX_OK){
+    return 1;
+  }else{
+    return 0;
+  }
+}
+/*-----------------------------------------------------------------------*/
+int nx_opensourcegroup(void *handle){
+  NXhandle hfil;
+  int status;
+
+  hfil = (NXhandle)handle;
+
+  status = NXopensourcegroup(hfil);
+  if(status == NX_OK){
+    return 1;
+  }else{
+    return 0;
+  }
+}
+
+
+

nxinterhelper.h

@@ -0,0 +1,68 @@
+/*
+  This is a library of support functions and data structures which can be
+  used in order to create interfaces between the NeXus-API and scripting
+  languages or data analysis systems with a native code interface. 
+
+  copyright: GPL
+
+  Mark Koennecke, October 2002
+*/
+
+#ifndef NXINTERHELPER
+#define NXINTERHELPER
+
+#include <napi.h>
+
+/*------------- opening and closing section ---------------------*/
+void *nx_open(char *filename, int accessMethod);
+void *nx_flush(void *handle);
+void  nx_close(void *handle);
+/*--------------- group handling section ------------------------*/
+int nx_makegroup(void *handle, char *name, char *nxclass);
+int nx_opengroup(void *handle, char *name, char *nxclass);
+int nx_opengrouppath(void *handle, char *path);
+int nx_openpath(void *handle, char *path);
+int nx_closegroup(void *handle);
+char *nx_getnextentry(void *handle, char separator);
+void *nx_getgroupID(void *handle);
+int nx_initgroupdir(void *handle);
+
+/*---------------- dataset handling -----------------------------*/
+int nx_makedata(void *ptr, char *name, int rank, int type, void *dimPtr);
+int nx_compmakedata(void *ptr, char *name, int rank, int type, 
+		    void *dimPtr, void *bufPtr);
+
+int nx_opendata(void *handle, char *name);
+int nx_closedata(void *handle);
+
+int nx_putslab(void *handle, void *dataset, void *startDim);
+void *nx_getslab(void *handle, void *startdim, void *size);
+
+void *nx_getds(void *handle, char *name);
+int   nx_putds(void *handle, char *name, void *dataset);
+
+void *nx_getdata(void *handle);
+int   nx_putdata(void *handle,void *dataset);
+
+void *nx_getinfo(void *handle);
+void *nx_getdataID(void *handle);
+
+/*-------------------- attributes --------------------------------*/
+char *nx_getnextattr(void *handle, char separator);
+int   nx_putattr(void *handle, char *name, void *ds);
+void *nx_getattr(void *handle, char *name, int type, int length); 
+
+
+/*---------------------- link -----------------------------------*/
+int nx_makelink(void *handle, void *link);
+int nx_opensourcegroup(void *handle);
+/*----------------- error handling -----------------------------*/
+char *nx_getlasterror(void);
+
+#endif
+
+
+
+
+
+

ofac.c

@@ -126,6 +126,7 @@
 #include "asyncprotocol.h"
 #include "sicsobj.h"
 #include "hdbqueue.h"
+#include "genericcontroller.h"
 /*----------------------- Server options creation -------------------------*/
   static int IFServerOption(SConnection *pCon, SicsInterp *pSics, void *pData,
                      int argc, char *argv[])
@@ -231,8 +232,6 @@
      AddCommand(pInter,"status",  UserStatus,NULL,NULL);
      AddCommand(pInter,"ResetServer",ResetStatus,NULL,NULL);
      AddCommand(pInter,"Dir",ListObjects,NULL,NULL);    
-     AddCommand(pInter,"Backup",BackupStatus,NULL,NULL);
-     AddCommand(pInter,"Restore",RestoreStatus,NULL,NULL);
      AddCommand(pInter,"SetInt", SetSICSInterrupt,NULL,NULL);
      AddCommand(pInter,"GetInt",GetSICSInterrupt,NULL,NULL);
      AddCommand(pInter,"SICSType",SICSType,NULL,NULL);
@@ -345,6 +344,8 @@
      AddCommand(pInter,"MakeAsyncQueue",AsyncQueueFactory,NULL,NULL);
      AddCommand(pInter,"MakeSicsObj",InstallSICSOBJ,NULL,NULL);
      AddCommand(pInter,"MakeHdbQueue",MakeHDBQueue,NULL,NULL);
+     AddCommand(pInter,"MakeGenController",GenControllerFactory,NULL,NULL);
+     AddCommand(pInter,"genconfigure",GenControllerConfigure,NULL,NULL);
 
     /*
       install site specific commands
@@ -417,7 +418,8 @@
     RemoveCommand(pSics,"MakeAsyncQueue"); 
     RemoveCommand(pSics,"MakeAsyncProtocol"); 
     RemoveCommand(pSics,"MakeSicsObject"); 
-    RemoveCommand(pSics,"MakeHdbQueue"); 
+    RemoveCommand(pSics,"MakeGenController"); 
+    RemoveCommand(pSics,"genconfigure"); 
     /*
       remove site specific installation commands
     */
@@ -459,6 +461,7 @@
      }
      MakeExeManager(pCon,pSics,NULL,1, NULL);
      InitIniCommands(pSics,pServ->pTasker);
+     InstallBckRestore(pCon,pSics);
      
      pCon->iFiles = 0;
      

polldriv.c

@@ -47,12 +47,10 @@ static int pollHdb(struct __POLLDRIV *self, SConnection *pCon){
 /*-----------------------------------------------------------------------*/
 static pPollDriv makeHdbDriver(SConnection *pCon, char *objectIdentifier,
     int argc, char *argv[]){
-    pHdb root = NULL, node = NULL;
+    pHdb node = NULL;
     pPollDriv pNew = NULL;
     
-    root = GetHipadabaRoot();
+    node = locateSICSNode(pServ->pSics,pCon,objectIdentifier);
-    assert(root != NULL);
-    node = GetHipadabaNode(root,objectIdentifier);
     if(node == NULL){
         SCWrite(pCon,"ERROR: object to poll not found",eError);
         return 0;

polldriv.tc

@@ -43,12 +43,10 @@ static int pollHdb(struct __POLLDRIV *self, SConnection *pCon){
 /*-----------------------------------------------------------------------*/
 static pPollDriv makeHdbDriver(SConnection *pCon, char *objectIdentifier,
     int argc, char *argv[]){
-    pHdb root = NULL, node = NULL;
+    pHdb node = NULL;
     pPollDriv pNew = NULL;
     
-    root = GetHipadabaRoot();
+    node = locateSICSNode(pServ->pSics,pCon,objectIdentifier);
-    assert(root != NULL);
-    node = GetHipadabaNode(root,objectIdentifier);
     if(node == NULL){
         SCWrite(pCon,"ERROR: object to poll not found",eError);
         return 0;

selvar.c

@@ -163,6 +163,7 @@
  static int  CheckVal(void *pSelf, SConnection *pCon )
  {
     pSelVar self = NULL;
+    int status;
     
     self = (pSelVar)pSelf;
     assert(self);
@@ -173,7 +174,12 @@
     
     self->pCon = pCon;
     InvokeCallBack(self->pCall, WLCHANGE, self);
-    return MonoCheck(self->pSel,pCon);
+    status = MonoCheck(self->pSel,pCon);
+    if(status != HWBusy)
+    {
+        InvokeCallBack(self->pCall, WLCHANGE, self);
+    }
+    return status;
  }
 /*------------------------------------------------------------------------*/
  static int  HaltSelVar(void *pSelf)

sicshdbadapter.c

@@ -315,6 +315,7 @@ static pHdb MakeHMDataNode(pHistMem pHM, char *name){
     if(node == NULL){
         return NULL;
     }
+    node->value.doNotFree = 1;
     pCall = MakeHipadabaCallback(HMDataGetCallback,pHM,NULL,-1,-1);
     if(pCall == NULL){
         return NULL;

sicshipadaba.c

@@ -27,7 +27,7 @@
 #include <splitter.h>
 #include "sicsobj.h"
 
-/*== there can be only hipadaba in SICS, some globals to care for that == */
+/*== there can be only one hipadaba in SICS, some globals to care for that == */
 static pHdb root = NULL;
 static pSicsPoll poller = NULL;
 typedef enum {
@@ -173,7 +173,7 @@ static int SICSFuncCallback(void *userData, void *callData, pHdb node,
     }       
     func = (SICSOBJFunc)node->value.v.obj;
     if(func != NULL){
-        return func((pSICSOBJ)userData,(SConnection *)callData, par,nPar);
+        return func((pSICSOBJ)userData,(SConnection *)callData, node, par,nPar);
     } else {
         printf("Great Badness in calling SICSFuncCallback\n");
         return 0;
@@ -1241,7 +1241,7 @@ int ProcessSICSHdbPar(pHdb root, SConnection *pCon,
             SCWrite(pCon,"ERROR: out of memory reading parameter data",eError);
             return 0;
          }
-         DynStringInsert(parData," =", 0);
+         DynStringInsert(parData," = ", 0);
          DynStringInsert(parData,argv[0],0);
          if(printPrefix != NULL){
             DynStringInsert(parData,printPrefix,0);
@@ -1521,7 +1521,7 @@ static char *hdbTypes[] = {"none",
                       "func",
                       NULL}; 
 /*-------------------------------------------------------------------------*/
-static int convertHdbType(char *text){
+int convertHdbType(char *text){
     int type;
 
     type = 0;
@@ -1594,7 +1594,7 @@ static int MakeHdbNode(SConnection *pCon, SicsInterp *pSics, void *pData,
      if(strlen(pPtr) < 1) {
         parent = root;
      } else {
-        parent = GetHipadabaNode(root,buffer);
+        parent = locateSICSNode(pSics,pCon,buffer);
      }
      if(parent == NULL){
         snprintf(buffer2,512,"ERROR: parent %s for new node does not exist",
@@ -1672,7 +1672,7 @@ static int MakeHdbScriptNode(SConnection *pCon, SicsInterp *pSics, void *pData,
      if(strlen(pPtr) < 1) {
         parent = root;
      } else {
-        parent = GetHipadabaNode(root,buffer);
+        parent = locateSICSNode(pSics,pCon,buffer);
      }
      if(parent == NULL){
         snprintf(buffer2,512,"ERROR: parent %s for new node does not exist",
@@ -1742,7 +1742,7 @@ static int DeleteHdbNode(SConnection *pCon, SicsInterp *pSics, void *pData,
     return 1;        
 }
 /*---------------------------------------------------------------------------*/
-static pHdb locateSICSNode(SicsInterp *pSics, SConnection *pCon, char *path){
+pHdb locateSICSNode(SicsInterp *pSics, SConnection *pCon, char *path){
     pHdb result = NULL;
     char *pPtr = NULL, sicsObj[128], error[256];
     pDummy pDum = NULL;
@@ -1840,9 +1840,11 @@ static int UpdateHdbNode(SConnection *pCon, SicsInterp *pSics, void *pData,
     char error[512];
     int i, status;
     
+    /*
     if(!SCMatchRights(pCon,usUser)){
         return 0;
     }
+    */
 
     if(argc < 2) {
         SCWrite(pCon,"ERROR: insufficient number of arguments to UpdateHdbNode",
@@ -1856,7 +1858,7 @@ static int UpdateHdbNode(SConnection *pCon, SicsInterp *pSics, void *pData,
     }
     if(argc > 2){
       if(!cloneHdbValue(&targetNode->value,&newValue)){
-          SCWrite(pCon,"ERROR: out of mmeory cloning node",
+          SCWrite(pCon,"ERROR: out of memory cloning node",
               eError);
           return 0;
       }
@@ -1875,6 +1877,7 @@ static int UpdateHdbNode(SConnection *pCon, SicsInterp *pSics, void *pData,
           SCWrite(pCon,error, eError);
           return 0;
       }
+      DeleteDynString(parData);
     } else {
         memset(&newValue,0,sizeof(hdbValue));
     	GetHipadabaPar(targetNode,&newValue,pCon);
@@ -1956,6 +1959,44 @@ static int GetHdbNode(SConnection *pCon, SicsInterp *pSics, void *pData,
     
     return 1;  
 }
+/*---------------------------------------------------------------------------*/
+static int GetHdbVal(SConnection *pCon, SicsInterp *pSics, void *pData,
+    int argc, char *argv[]){
+    pHdb targetNode = NULL;
+    hdbValue newValue;
+    pDynString parData = NULL;
+    char error[512], oriPath[512];
+    int i, status, protocol, outCode;
+    char value[80];
+
+    if(argc < 2) {
+        SCWrite(pCon,"ERROR: need path to node to print",eError);
+        return 0;
+    }
+    
+    strncpy(oriPath,argv[1], 511);
+    targetNode = locateSICSNode(pSics,pCon,argv[1]);
+    if(targetNode == NULL){
+        return 0;
+    }
+    memset(&newValue,0,sizeof(hdbValue));
+    GetHipadabaPar(targetNode, &newValue, pCon);
+    parData = formatValue(newValue);
+    if(parData == NULL){
+        SCWrite(pCon,"ERROR: out of memory formatting data",eError);
+        return 0;
+    } else {
+        if ((protocol = isJSON(pCon)) == 1) 
+          outCode = eHdbEvent;
+        else
+            outCode = eEvent;
+        SCWrite(pCon,GetCharArray(parData), outCode);
+        DeleteDynString(parData);
+        ReleaseHdbValue(&newValue);
+        return 1;        
+    }
+    return 1;  
+}
 /*--------------------------------------------------------------------------*/
 static int countChildren(pHdb node){
     pHdb current = NULL;
@@ -2539,7 +2580,7 @@ static int SicsCommandNode(SConnection *pCon, SicsInterp *pSics, void *pData,
     if(strlen(pPtr) < 1) {
         parent = root;
     } else {
-        parent = GetHipadabaNode(root,buffer);
+        parent = locateSICSNode(pSics,pCon,buffer);
     }
     if(parent == NULL){
         snprintf(buffer2,512,"ERROR: parent %s for new node does not exist",
@@ -2607,18 +2648,42 @@ static int GetSICSHdbProperty(SConnection *pCon, SicsInterp *pSics, void *pData,
     }
     targetNode = locateSICSNode(pSics,pCon,argv[1]);
     if(targetNode == NULL){
-    	SCWrite(pCon,"ERROR: node not found",eValue);
+        SCWrite(pCon,"ERROR: node not found",eValue);
         return 0;
     }
     status = GetHdbProperty(targetNode,argv[2],buffer,511);
     if(status != 1){
-    	SCWrite(pCon,"ERROR: attribute not found",eValue);
+        SCWrite(pCon,"ERROR: attribute not found",eValue);
-    	return 0;
+        return 0;
     }
     SCPrintf(pCon,eValue,"%s.%s = %s", argv[1], argv[2], buffer);
     return 1;
  }
  /*--------------------------------------------------------------------------*/
+static int GetSICSHdbPropertyVal(SConnection *pCon, SicsInterp *pSics, void *pData,
+    int argc, char *argv[]){
+    pHdb targetNode = NULL;
+    char buffer[512];
+    int status;
+
+    if(argc < 3) {
+        SCWrite(pCon,"ERROR: need path key as parameters",eError);
+        return 0;
+    }
+    targetNode = locateSICSNode(pSics,pCon,argv[1]);
+    if(targetNode == NULL){
+        SCWrite(pCon,"ERROR: node not found",eValue);
+        return 0;
+    }
+    status = GetHdbProperty(targetNode,argv[2],buffer,511);
+    if(status != 1){
+        SCWrite(pCon,"ERROR: attribute not found",eValue);
+        return 0;
+    }
+    SCPrintf(pCon,eValue,"%s", buffer);
+    return 1;
+ }
+ /*--------------------------------------------------------------------------*/
 static int ListSICSHdbProperty(SConnection *pCon, SicsInterp *pSics, void *pData,
     int argc, char *argv[]){
     pHdb targetNode = NULL;
@@ -2670,6 +2735,7 @@ int InstallSICSHipadaba(SConnection *pCon, SicsInterp *pSics, void *pData,
     AddCommand(pSics,"hset", SetHdbNode, NULL, NULL);
     AddCommand(pSics,"hupdate", UpdateHdbNode, NULL, NULL);
     AddCommand(pSics,"hget", GetHdbNode, NULL, NULL);
+    AddCommand(pSics,"hval", GetHdbVal, NULL, NULL);
     AddCommand(pSics,"hzipget",ZipGetHdbNode, NULL, NULL);
     AddCommand(pSics,"hlist", ListHdbNode, NULL, NULL);
     AddCommand(pSics,"hnotify", AutoNotifyHdbNode, NULL, NULL);
@@ -2681,6 +2747,7 @@ int InstallSICSHipadaba(SConnection *pCon, SicsInterp *pSics, void *pData,
     AddCommand(pSics,"hcommand",SicsCommandNode, NULL, NULL);
     AddCommand(pSics,"hsetprop",SetSICSHdbProperty, NULL, NULL);
     AddCommand(pSics,"hgetprop",GetSICSHdbProperty, NULL, NULL);
+    AddCommand(pSics,"hgetpropval",GetSICSHdbPropertyVal, NULL, NULL);
     AddCommand(pSics,"hlistprop",ListSICSHdbProperty, NULL, NULL);
 
     InstallSICSPoll(pCon,pSics,pData,argc,argv);

sicshipadaba.h

@@ -280,6 +280,14 @@ int SICSHdbSetPar(void *obj, SConnection *pCon,
  */
 int isSICSHdbRO(pHdb node);     
 /*============= common SICS Interactions ===================================*/
+/**
+ * locate a SICS Hdb node, thereby honouring the /sics/object/par syntax
+ * @param pSics, the SICS interpreter
+ * @param pCon A connection to report errors too
+ * @param path The path to locate
+ * @return The demanded node or NULL in case of failure
+ */
+pHdb locateSICSNode(SicsInterp *pSics, SConnection *pCon, char *path);
 /**
  * Install a SICS automatic notification callback on the node. This is
  * a default callback using the current connection with its current 
@@ -352,6 +360,13 @@ pDynString formatValue(hdbValue v);
  * @return 0 on failure, 1 on success
  */
 int readHdbValue(hdbValue *v, char *data, char *error, int errlen);
+/**
+ * convert from test to a Hipadaba type
+ * @param text The type text
+ * @return The converted Hipadaba type
+ */
+int convertHdbType(char *text);
+
 /*================= SICS Interpreter Interface ===========================*/
 /**
  * InstallHipadaba installs the Hipadaba commands into the SICS interpreter. 

sicsobj.c

@@ -6,10 +6,15 @@
  * Mark Koennecke, July 2007
  */
 #include <sics.h>
+#include <tcl.h>
 #include "assert.h"
 #include "ifile.h"
 #include "sicsobj.h"
+#include "dynstring.h"
+#include "macro.h"
 #include "sicshipadaba.h"
+
+extern int decodeSICSPriv(char *txt); /* from access.c */
 /*--------------------------------------------------------------------------*/
 static void DefaultKill(void *data){
     return;
@@ -92,10 +97,104 @@ static int invokeOBJFunction(pSICSOBJ object, pHdb commandNode, SConnection *pCo
             SCWrite(pCon,"ERROR: internal error, function not found",eError);
             return 0;
         }
-        status = pFunc(object, pCon, parArray,count);
+        status = pFunc(object, pCon, commandNode, parArray,count);
         return status;
 }
 /*---------------------------------------------------------------------------*/
+static int ScriptObjFunc(pSICSOBJ obj, SConnection *pCon, pHdb commandNode,
+    pHdb par[], int nCount){
+    int status, i;
+    Tcl_Interp *pTcl = NULL;
+    Tcl_DString com;
+    char value[256];
+    pDynString val  = NULL;
+    char *pPtr = NULL;
+    
+    memset(value,0,256);
+    GetHdbProperty(commandNode,"priv",value,256);
+    status = decodeSICSPriv(value);
+    if(!SCMatchRights(pCon,status)){
+        return 0;
+    }
+    
+    if(GetHdbProperty(commandNode,"script",value,256) != 1){
+        SCWrite(pCon,"ERROR: script property not configured on this node",
+            eError);
+        return 0;
+    }
+    
+    Tcl_DStringInit(&com);
+    Tcl_DStringAppend(&com,value,strlen(value));
+    for(i = 0; i < nCount; i++){
+        val = formatValue(par[i]->value);
+        if(val != NULL){
+            Tcl_DStringAppend(&com," ", 1);
+            pPtr = GetCharArray(val);
+            Tcl_DStringAppend(&com,pPtr,strlen(pPtr));
+            DeleteDynString(val);
+        }
+    }
+    
+    MacroPush(pCon);
+    pTcl = InterpGetTcl(pServ->pSics);
+    status = Tcl_Eval(pTcl,Tcl_DStringValue(&com));
+    Tcl_DStringFree(&com);
+    MacroPop();
+    
+    if(status == TCL_OK){
+        SCWrite(pCon,Tcl_GetStringResult(pTcl),eValue);
+        return 1;
+    }  else {
+        SCWrite(pCon,Tcl_GetStringResult(pTcl),eError);
+        return 0;
+    }
+    return 1;        
+}
+/*--------------------------------------------------------------------------*/
+static int MakeScriptFunc(pSICSOBJ self, SConnection *pCon, 
+    int argc, char *argv[]){
+    char path[512], *pPtr = NULL;    
+    pHdb parent = NULL, node = NULL;
+    hdbValue func;
+        
+    if(argc < 5){
+        SCWrite(pCon,
+        "ERROR: not enough arguments: obj makescriptfunc path script priv",
+        eError);
+        return 0;
+    }        
+    
+    if(!SCMatchRights(pCon,usMugger)){
+        return 0;
+    }
+    
+    
+    strncpy(path,argv[2],511);
+    pPtr = strrchr(path,'/');
+    if(pPtr == NULL){
+        /* no hierarchy */
+        parent = self->objectNode;
+        node = MakeHipadabaNode(path,HIPFUNC,1);
+    } else {
+        /* hierarchy */
+        *pPtr = '\0';
+        parent = GetHipadabaNode(self->objectNode,path);
+        pPtr++;
+        node = MakeHipadabaNode(pPtr,HIPFUNC,1);
+    }
+    if(parent == NULL || node == NULL){
+        SCWrite(pCon,"ERROR: root path error or out of memory",eError);
+        return 0;
+    }
+    node->value.v.obj = ScriptObjFunc;
+    SetHdbProperty(node,"script",argv[3]);
+    SetHdbProperty(node,"priv",argv[4]);
+    AppendHipadabaCallback(node,HCBSET,MakeSICSFuncCallback(self));
+    AddHipadabaChild(parent,node,pCon);
+    SCSendOK(pCon);    
+    return 1;
+}
+/*---------------------------------------------------------------------------*/
 int InvokeSICSOBJ(SConnection *pCon, SicsInterp *pSics, void *pData, 
     int argc, char *argv[]){
     pSICSOBJ self = NULL;
@@ -106,7 +205,7 @@ int InvokeSICSOBJ(SConnection *pCon, SicsInterp *pSics, void *pData,
     self = (pSICSOBJ)pData;
     assert(self != NULL);
     
-    if(argc < 1){
+    if(argc < 2){
         SCWrite(pCon,"ERROR: Nothing to process",eError);
         return -1; 
     }
@@ -114,10 +213,15 @@ int InvokeSICSOBJ(SConnection *pCon, SicsInterp *pSics, void *pData,
     if(parNode != NULL && parNode->value.dataType == HIPFUNC){
         status = invokeOBJFunction(self, parNode, pCon, argc-2, &argv[2]);
     } else {
-        status = ProcessSICSHdbPar(self->objectNode,pCon, argv[0], 
+        strncpy(buffer,argv[0],130);
+        strcat(buffer," ");
+        status = ProcessSICSHdbPar(self->objectNode,pCon, buffer, 
             argc-1,&argv[1]);
     }
     if(status == -1){
+        if(strcmp(argv[1],"makescriptfunc") == 0) {
+            return MakeScriptFunc(self,pCon,argc,argv);
+        }
         snprintf(buffer,131,"ERROR: no command or parameter found for key: %s", 
             argv[1]);
         SCWrite(pCon,buffer,eError);

sicsobj.h

@@ -23,7 +23,7 @@ typedef struct {
 }SICSOBJ, *pSICSOBJ;
 /*-----------------------------------------------------------------------*/
 typedef int (*SICSOBJFunc)(pSICSOBJ self, SConnection *pCon, 
-    pHdb par[], int nPar);
+    pHdb commandNode, pHdb par[], int nPar);
 /*======================= Live & Death  =================================*/
 pSICSOBJ MakeSICSOBJ(char *name, char *class);
 void KillSICSOBJ(void *data);

sicsstat.tcl

@@ -1,7 +1,60 @@
 exe batchpath ./
 exe syspath ./
+sample  
+sample setAccess 2
+title  
+title setAccess 2
+user  
+user setAccess 2
+email unknown
+email setAccess 2
+address unknown
+address setAccess 2
+fax unknown
+fax setAccess 2
+phone unknown
+phone setAccess 2
+# Motor som
+som sign 1.000000
+som SoftZero 0.000000
+som SoftLowerLim -180.000000
+som SoftUpperLim 180.000000
+som Fixed -1.000000
+som InterruptMode 0.000000
+som precision 0.010000
+som ignorefault 0.000000
+som AccessCode 2.000000
+som failafter 3.000000
+som maxretry 3.000000
+som movecount 10.000000
+# Motor stt
+stt sign 1.000000
+stt SoftZero 0.000000
+stt SoftLowerLim 0.000000
+stt SoftUpperLim 120.000000
+stt Fixed -1.000000
+stt InterruptMode 0.000000
+stt precision 0.010000
+stt ignorefault 0.000000
+stt AccessCode 2.000000
+stt failafter 3.000000
+stt maxretry 3.000000
+stt movecount 10.000000
+# Motor dth
+dth sign 1.000000
+dth SoftZero 0.000000
+dth SoftLowerLim 0.000000
+dth SoftUpperLim 200.000000
+dth Fixed -1.000000
+dth InterruptMode 0.000000
+dth precision 0.010000
+dth ignorefault 0.000000
+dth AccessCode 2.000000
+dth failafter 3.000000
+dth maxretry 3.000000
+dth movecount 10.000000
 # Counter counter
-counter SetPreset 3.000000
+counter SetPreset 1000.000000
 counter SetMode Timer
 hm CountMode timer
 hm preset 3.000000

statemon.c

@@ -320,7 +320,21 @@ int StateMonAction(SConnection *pCon, SicsInterp *pSics, void *pData,
         SCRegister(pCon,pSics, self->pCall,lID);
     	SCSendOK(pCon);
     	return 1;
-    }      
+    } else if(strcmp(argv[1],"start") == 0) {
+        if(argc > 2){
+            InvokeCallBack(self->pCall,STSTART,argv[2]);
+            SCSendOK(pCon);
+            return 1;
+        }
+        return 0;
+    } else if(strcmp(argv[1],"stop") == 0) {
+        if(argc > 2){
+            InvokeCallBack(self->pCall,STEND,argv[2]);
+            SCSendOK(pCon);
+            return 1;
+        }
+        return 0;
+    }     
     
     SCWrite(pCon,"ERROR: keyword not recognized",eError);                            	
 	return 0;                                        	

status.c

@@ -9,6 +9,9 @@
 
 	Updated in order to prevent status floods
         Mark Koennecke, July 2004
+       
+    Reworked restore to keep parameters from uninitialized devices
+        Mark Koennecke, November 2007    
 
 	Copyright:
 
@@ -50,6 +53,9 @@
 #include "interrupt.h"
 #include "devexec.h"
 #include "sicshipadaba.h"
+#include "lld_str.h"
+#include "lld.h"
+#include "exebuf.h"
 #undef VALUECHANGE
 #define VALUECHANGE 2
 
@@ -397,28 +403,116 @@ static int motorSave = 0;
       SCSendOK(pCon);
       return 1;
    } 
+/*---------------------------------------------------------------------*/  
+static int restoreOccurred = 0;
+int hasRestored(){
+    return restoreOccurred;
+}
+/*---------------------------------------------------------------------------*/
+typedef struct {
+    pObjectDescriptor pDes;
+    int errList;
+}RestoreObj, *pRestoreObj; 
+/*---------------------------------------------------------------------------*/
+static void killRestore(void *data){
+    pRestoreObj self = (pRestoreObj)data;
+    if(self == NULL){
+        return;
+    }
+    if(self->errList >= 0){
+        LLDdeleteBlob(self->errList);
+    }
+    if(self->pDes != NULL){
+        DeleteDescriptor(self->pDes);
+    }
+    free(self);
+}  
+/*--------------------------------------------------------------------------*/
+static int SaveRestore(void *obj, char *name, FILE *fd){
+    int status;
+    char buffer[1024];
+    
+    pRestoreObj self = (pRestoreObj)obj;
+    if(self == NULL){
+        return 0;
+    }
+    status = LLDnodePtr2First(self->errList);
+    while(status == 1){
+        LLDstringData(self->errList,buffer);
+        fprintf(fd,"%s\n", buffer);
+        status = LLDnodePtr2Next(self->errList);
+    }
+    
+    return 1;
+} 
+/*---------------------------------------------------------------------------*/
+int InstallBckRestore(SConnection *pCon, SicsInterp *pSics){
+    pRestoreObj pNew = NULL;
+    
+    pNew = malloc(sizeof(RestoreObj));
+    if(pNew  == NULL){
+        SCWrite(pCon,"ERROR: no memory to create restore object! This is SERIOUS!!!",
+            eError);
+         return 0;
+    }
+    pNew->pDes = CreateDescriptor("BckRestore");
+    pNew->errList =   LLDstringCreate();  
+    if(pNew->pDes == NULL || pNew->errList < 0){
+        SCWrite(pCon,"ERROR: no memory to create restore object! This is SERIOUS!!!",
+            eError);
+         return 0;
+    }
+    pNew->pDes->SaveStatus = SaveRestore;
+    AddCommand(pSics,"Backup",BackupStatus,NULL,NULL);
+    AddCommand(pSics,"Restore",RestoreStatus,killRestore,pNew);
+    
+    return 1;         
+}
+/*-----------------------------------------------------------------------*/
+static int listRestoreErr(pRestoreObj self, SConnection *pCon){
+   char buffer[1024];
+   int status;
+   pDynString data = NULL;
+ 
+   SCStartBuffering(pCon);
+   status = LLDnodePtr2First(self->errList);
+    while(status == 1){
+        LLDstringData(self->errList,buffer);
+        SCWrite(pCon,buffer,eValue);
+        status = LLDnodePtr2Next(self->errList);
+    }
+    data = SCEndBuffering(pCon);
+    if(data != NULL){
+        SCWrite(pCon,GetCharArray(data),eValue);
+    }   
+    return 1;
+}
 /*-----------------------------------------------------------------------*/   
    int RestoreStatus(SConnection *pCon, SicsInterp *pSics, void *pData,
                   int argc, char *argv[])
-   {
+    {
      char pBueffel[512];
      int iRights;
      int iRet;
      char *pFile = NULL;
      writeFunc oldWrite;
+     pExeBuf buffi = NULL;
+     pRestoreObj self = (pRestoreObj)pData;    
      
      assert(pSics);
      assert(pCon);
+     assert(self != NULL);
 
+ 
       if(argc < 2)
       {
         pFile = IFindOption(pSICSOptions,"statusfile");
         if(pFile)
         {
-           sprintf(pBueffel,"FileEval %s",pFile);
+           sprintf(pBueffel,"%s",pFile);
         }
         else
-	{
+    	{
            SCWrite(pCon,"ERROR: No filename given for backup, Aborted.",
                    eError);
            return 0;
@@ -426,16 +520,35 @@ static int motorSave = 0;
       }
       else
       {
-          sprintf(pBueffel,"FileEval %s",argv[1]);
+          if(strcmp(argv[1],"listerr") == 0){
+                return listRestoreErr(self,pCon);
+          } else {
+              sprintf(pBueffel,"%s",argv[1]);
+          }
       }
       
+      buffi = exeBufCreate("restore");
+      if(buffi == NULL){
+        SCWrite(pCon,"ERROR: failed to allocate buffer for restore",eError);
+        return 0;
+      }
+      iRet = exeBufLoad(buffi,pBueffel);
+      if(iRet != 1){
+        exeBufDelete(buffi);
+        SCWrite(pCon,"ERROR: failed open status file",eError);
+        return 0;
+      } 
+      LLDdeleteBlob(self->errList);
+      self->errList = LLDstringCreate();     
       iRights = SCGetRights(pCon);
       pCon->iUserRights = usInternal;
       oldWrite = SCGetWriteFunc(pCon);
       SCSetWriteFunc(pCon,SCNotWrite);
-      iRet = InterpExecute(pSics,pCon,pBueffel);
+      iRet = exeBufProcessErrList(buffi,pSics,pCon,self->errList); 
+      restoreOccurred = 1;
       SCSetWriteFunc(pCon,oldWrite);
       pCon->iUserRights = iRights;
+      exeBufDelete(buffi);
       /*
 	if we do not override parameterChange here, the backup file
 	would be overwritten after each restore... Not the right thing
@@ -445,4 +558,3 @@ static int motorSave = 0;
       SCSendOK(pCon);
       return iRet;
    }
-

status.h

@@ -50,11 +50,13 @@
    int ResetStatus(SConnection *pCon, SicsInterp *pSics, void *pData,
                   int argc, char *argv[]);
 
+   int InstallBckRestore(SConnection *pCon, SicsInterp *pSics);
    int BackupStatus(SConnection *pCon, SicsInterp *pSics, void *pData,
                   int argc, char *argv[]);
+
    int RestoreStatus(SConnection *pCon, SicsInterp *pSics, void *pData,
                   int argc, char *argv[]);
-                 
+   int hasRestored();                 
    
                                  
 #endif

task.c

@@ -243,7 +243,8 @@
      IncrTaskPointer(self);
      while(self->iStop == 0)
      {
-       if((self->pCurrent != pEnd) && (self->pCurrent->iStatus == READY)) 
+       if((self->pCurrent != pEnd) && (self->pCurrent->iStatus == READY) 
+            && self->pCurrent != NULL) 
            /* omit ourselves! */
        {
          iRet = self->pCurrent->pRun(self->pCurrent->pData);

tasub.c

@@ -1158,7 +1158,7 @@ static int calcUBFromCell(ptasUB self, SConnection *pCon){
         return 0;
     }
     if(mat_det(UB) < .000001){
-       SCWrite(pCon,"ERROR: invalid UB matrix, check reflections",eError);
+       SCWrite(pCon,"ERROR: invalid UB matrix, check cell",eError);
         return 0;
     }
     if(self->machine.UB != NULL){

tclintimpl.c

@@ -136,13 +136,21 @@ int TclIntAction(SConnection *pCon, SicsInterp *pSics, void *pData,
   pTclInt self = NULL;
   char pBuffer[1024];
   char *cmd;
+  float val;
 
   self = (pTclInt)pData;
   assert(self);
   if(argc < 2){
-    sprintf(pBuffer,"ERROR: %s expects at least one argument!", argv[0]);
+    if(self->pDriv->GetValue != NULL){
-    SCWrite(pCon,pBuffer,eError);
+        val = self->pDriv->GetValue(self,pCon);
-    return 0;
+        snprintf(pBuffer,1024,"%s = %f", argv[0], val);
+        SCWrite(pCon,pBuffer,eValue);
+        return 1;
+    } else {
+        sprintf(pBuffer,"ERROR: %s expects at least one argument!", argv[0]);
+        SCWrite(pCon,pBuffer,eError);
+        return 0;
+    }
   }
 
   strtolower(argv[1]);

val.lis

@@ -1,93 +1,240 @@
-==6880== Memcheck, a memory error detector.
+==19540== Memcheck, a memory error detector.
-==6880== Copyright (C) 2002-2007, and GNU GPL'd, by Julian Seward et al.
+==19540== Copyright (C) 2002-2007, and GNU GPL'd, by Julian Seward et al.
-==6880== Using LibVEX rev 1732, a library for dynamic binary translation.
+==19540== Using LibVEX rev 1732, a library for dynamic binary translation.
-==6880== Copyright (C) 2004-2007, and GNU GPL'd, by OpenWorks LLP.
+==19540== Copyright (C) 2004-2007, and GNU GPL'd, by OpenWorks LLP.
-==6880== Using valgrind-3.2.3, a dynamic binary instrumentation framework.
+==19540== Using valgrind-3.2.3, a dynamic binary instrumentation framework.
-==6880== Copyright (C) 2000-2007, and GNU GPL'd, by Julian Seward et al.
+==19540== Copyright (C) 2000-2007, and GNU GPL'd, by Julian Seward et al.
-==6880== For more details, rerun with: -v
+==19540== For more details, rerun with: -v
-==6880== 
+==19540== 
+==19540== Syscall param write(buf) points to uninitialised byte(s)
+==19540==    at 0x41DA1FE: __write_nocancel (in /lib/tls/libc-2.3.2.so)
+==19540==    by 0x81D25BD: H5FD_sec2_write (in /afs/psi.ch/user/k/koennecke/src/workspace/sics/SICServer)
+==19540==  Address 0xBEFF3BFA is on thread 1's stack
+==19540== 
+==19540== Source and destination overlap in memcpy(0x4445028, 0x43CE7E8, 1744896)
+==19540==    at 0x401C96D: memcpy (mc_replace_strmem.c:116)
+==19540==    by 0x8241BDA: H5V_memcpyvv (in /afs/psi.ch/user/k/koennecke/src/workspace/sics/SICServer)
+==19540== 
+==19540== Invalid read of size 1
+==19540==    at 0x401C988: memcpy (mc_replace_strmem.c:406)
+==19540==    by 0x8241BDA: H5V_memcpyvv (in /afs/psi.ch/user/k/koennecke/src/workspace/sics/SICServer)
+==19540==  Address 0x4445027 is 1 bytes before a block of size 1,744,896 alloc'd
+==19540==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==19540==    by 0x81B8BDE: H5D_istore_chunk_alloc (in /afs/psi.ch/user/k/koennecke/src/workspace/sics/SICServer)
+==19540== 
+==19540== Invalid read of size 1
+==19540==    at 0x401C98D: memcpy (mc_replace_strmem.c:406)
+==19540==    by 0x8241BDA: H5V_memcpyvv (in /afs/psi.ch/user/k/koennecke/src/workspace/sics/SICServer)
+==19540==  Address 0x4445026 is 2 bytes before a block of size 1,744,896 alloc'd
+==19540==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==19540==    by 0x81B8BDE: H5D_istore_chunk_alloc (in /afs/psi.ch/user/k/koennecke/src/workspace/sics/SICServer)
+==19540== 
+==19540== Invalid read of size 1
+==19540==    at 0x401C993: memcpy (mc_replace_strmem.c:406)
+==19540==    by 0x8241BDA: H5V_memcpyvv (in /afs/psi.ch/user/k/koennecke/src/workspace/sics/SICServer)
+==19540==  Address 0x4445025 is 3 bytes before a block of size 1,744,896 alloc'd
+==19540==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==19540==    by 0x81B8BDE: H5D_istore_chunk_alloc (in /afs/psi.ch/user/k/koennecke/src/workspace/sics/SICServer)
+==19540== 
+==19540== Invalid read of size 1
+==19540==    at 0x401C99A: memcpy (mc_replace_strmem.c:406)
+==19540==    by 0x8241BDA: H5V_memcpyvv (in /afs/psi.ch/user/k/koennecke/src/workspace/sics/SICServer)
+==19540==  Address 0x4445024 is 4 bytes before a block of size 1,744,896 alloc'd
+==19540==    at 0x401A846: malloc (vg_replace_malloc.c:149)
+==19540==    by 0x81B8BDE: H5D_istore_chunk_alloc (in /afs/psi.ch/user/k/koennecke/src/workspace/sics/SICServer)
+==19540== 
+==19540== Conditional jump or move depends on uninitialised value(s)
+==19540==    at 0x40D60F5: (within /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D6945: (within /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D598F: deflate (in /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D3C7F: compress2 (in /usr/lib/libz.so.1.1.4)
+==19540==    by 0x8243947: H5Z_filter_deflate (in /afs/psi.ch/user/k/koennecke/src/workspace/sics/SICServer)
+==19540== 
+==19540== Conditional jump or move depends on uninitialised value(s)
+==19540==    at 0x40D609F: (within /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D6945: (within /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D598F: deflate (in /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D3C7F: compress2 (in /usr/lib/libz.so.1.1.4)
+==19540==    by 0x8243947: H5Z_filter_deflate (in /afs/psi.ch/user/k/koennecke/src/workspace/sics/SICServer)
+==19540== 
+==19540== Conditional jump or move depends on uninitialised value(s)
+==19540==    at 0x40D60FE: (within /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D6945: (within /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D598F: deflate (in /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D3C7F: compress2 (in /usr/lib/libz.so.1.1.4)
+==19540==    by 0x8243947: H5Z_filter_deflate (in /afs/psi.ch/user/k/koennecke/src/workspace/sics/SICServer)
+==19540== 
+==19540== Conditional jump or move depends on uninitialised value(s)
+==19540==    at 0x40D60D8: (within /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D6945: (within /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D598F: deflate (in /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D3C7F: compress2 (in /usr/lib/libz.so.1.1.4)
+==19540==    by 0x8243947: H5Z_filter_deflate (in /afs/psi.ch/user/k/koennecke/src/workspace/sics/SICServer)
+==19540== 
+==19540== Conditional jump or move depends on uninitialised value(s)
+==19540==    at 0x40D6107: (within /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D6945: (within /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D598F: deflate (in /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D3C7F: compress2 (in /usr/lib/libz.so.1.1.4)
+==19540==    by 0x8243947: H5Z_filter_deflate (in /afs/psi.ch/user/k/koennecke/src/workspace/sics/SICServer)
+==19540== 
+==19540== Conditional jump or move depends on uninitialised value(s)
+==19540==    at 0x40D6110: (within /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D6945: (within /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D598F: deflate (in /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D3C7F: compress2 (in /usr/lib/libz.so.1.1.4)
+==19540==    by 0x8243947: H5Z_filter_deflate (in /afs/psi.ch/user/k/koennecke/src/workspace/sics/SICServer)
+==19540== 
+==19540== Use of uninitialised value of size 4
+==19540==    at 0x40D68E5: (within /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D598F: deflate (in /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D3C7F: compress2 (in /usr/lib/libz.so.1.1.4)
+==19540==    by 0x8243947: H5Z_filter_deflate (in /afs/psi.ch/user/k/koennecke/src/workspace/sics/SICServer)
+==19540== 
+==19540== Use of uninitialised value of size 4
+==19540==    at 0x40D68F7: (within /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D598F: deflate (in /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D3C7F: compress2 (in /usr/lib/libz.so.1.1.4)
+==19540==    by 0x8243947: H5Z_filter_deflate (in /afs/psi.ch/user/k/koennecke/src/workspace/sics/SICServer)
+==19540== 
+==19540== Use of uninitialised value of size 4
+==19540==    at 0x40D6B50: (within /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D598F: deflate (in /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D3C7F: compress2 (in /usr/lib/libz.so.1.1.4)
+==19540==    by 0x8243947: H5Z_filter_deflate (in /afs/psi.ch/user/k/koennecke/src/workspace/sics/SICServer)
+==19540== 
+==19540== Use of uninitialised value of size 4
+==19540==    at 0x40D6B65: (within /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D598F: deflate (in /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D3C7F: compress2 (in /usr/lib/libz.so.1.1.4)
+==19540==    by 0x8243947: H5Z_filter_deflate (in /afs/psi.ch/user/k/koennecke/src/workspace/sics/SICServer)
+==19540== 
+==19540== Conditional jump or move depends on uninitialised value(s)
+==19540==    at 0x40D60DF: (within /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D6945: (within /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D598F: deflate (in /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D3C7F: compress2 (in /usr/lib/libz.so.1.1.4)
+==19540==    by 0x8243947: H5Z_filter_deflate (in /afs/psi.ch/user/k/koennecke/src/workspace/sics/SICServer)
+==19540== 
+==19540== Conditional jump or move depends on uninitialised value(s)
+==19540==    at 0x40D60E8: (within /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D6945: (within /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D598F: deflate (in /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D3C7F: compress2 (in /usr/lib/libz.so.1.1.4)
+==19540==    by 0x8243947: H5Z_filter_deflate (in /afs/psi.ch/user/k/koennecke/src/workspace/sics/SICServer)
+==19540== 
+==19540== Conditional jump or move depends on uninitialised value(s)
+==19540==    at 0x40D6119: (within /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D6945: (within /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D598F: deflate (in /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D3C7F: compress2 (in /usr/lib/libz.so.1.1.4)
+==19540==    by 0x8243947: H5Z_filter_deflate (in /afs/psi.ch/user/k/koennecke/src/workspace/sics/SICServer)
+==19540== 
+==19540== Conditional jump or move depends on uninitialised value(s)
+==19540==    at 0x40D6122: (within /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D6945: (within /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D598F: deflate (in /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D3C7F: compress2 (in /usr/lib/libz.so.1.1.4)
+==19540==    by 0x8243947: H5Z_filter_deflate (in /afs/psi.ch/user/k/koennecke/src/workspace/sics/SICServer)
+==19540== 
+==19540== Conditional jump or move depends on uninitialised value(s)
+==19540==    at 0x40D612B: (within /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D6945: (within /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D598F: deflate (in /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D3C7F: compress2 (in /usr/lib/libz.so.1.1.4)
+==19540==    by 0x8243947: H5Z_filter_deflate (in /afs/psi.ch/user/k/koennecke/src/workspace/sics/SICServer)
+==19540== 
+==19540== Conditional jump or move depends on uninitialised value(s)
+==19540==    at 0x40D6134: (within /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D6945: (within /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D598F: deflate (in /usr/lib/libz.so.1.1.4)
+==19540==    by 0x40D3C7F: compress2 (in /usr/lib/libz.so.1.1.4)
+==19540==    by 0x8243947: H5Z_filter_deflate (in /afs/psi.ch/user/k/koennecke/src/workspace/sics/SICServer)
 WARNING: Cannot log(Accepted dummy connection )
-sim/trics/trics.tcl:0>> ServerOption ReadTimeOut  100
+sim/laue/laue.tcl:0>> ServerOption ReadTimeOut  10
-sim/trics/trics.tcl:1>> ServerOption AcceptTimeOut  100
+sim/laue/laue.tcl:1>> ServerOption AcceptTimeOut  10 
-sim/trics/trics.tcl:2>> ServerOption ReadUserPasswdTimeout  7000 
+sim/laue/laue.tcl:2>> ServerOption ReadUserPasswdTimeout  500000 
-sim/trics/trics.tcl:3>> ServerOption LogFileDir $loghome
+sim/laue/laue.tcl:3>> ServerOption ServerPort 2911
-sim/trics/trics.tcl:4>> ServerOption LogFileBaseName  $loghome/tricsserver
+sim/laue/laue.tcl:4>> ServerOption InterruptPort 2913
-sim/trics/trics.tcl:5>> ServerOption statusfile ${datahome}tricsstatus.tcl
+sim/laue/laue.tcl:5>> ServerOption TelnetPort 1301
-sim/trics/trics.tcl:6>> ServerOption TecsPort 9753
+sim/laue/laue.tcl:6>> ServerOption TelWord sicslogin
-sim/trics/trics.tcl:7>> ServerOption ServerPort 2911
+sim/laue/laue.tcl:7>> ServerOption QuieckPort 2108
-sim/trics/trics.tcl:8>> ServerOption InterruptPort 2914
+sim/laue/laue.tcl:8>> TokenInit connan
-sim/trics/trics.tcl:9>> ServerOption TelnetPort 1301
+sim/laue/laue.tcl:9>> ServerOption LogFileDir $loghome
-sim/trics/trics.tcl:10>> ServerOption TelWord    sicslogin
+sim/laue/laue.tcl:10>> commandlog auto
-sim/trics/trics.tcl:11>> ServerOption QuieckPort 2108
+sim/laue/laue.tcl:11>> ServerOption statusfile $datahome/lauestatus.tcl
-sim/trics/trics.tcl:12>> TokenInit connan
+sim/laue/laue.tcl:12>> SicsUser Mugger Mugger  1
-sim/trics/trics.tcl:13>> commandlog intervall 10
+sim/laue/laue.tcl:13>> SicsUser lnsmanager lnsSICSlns  1
-sim/trics/trics.tcl:14>> commandlog auto
+sim/laue/laue.tcl:14>> SicsUser User   User      2
-sim/trics/trics.tcl:15>> SicsUser jurg   willi 2
+sim/laue/laue.tcl:15>> SicsUser Spy    Spy       3
-sim/trics/trics.tcl:16>> SicsUser oksana sun 1
+sim/laue/laue.tcl:16>> SicsUser laueuser 07lns1  2
-sim/trics/trics.tcl:17>> SicsUser schaniel brida 2
+sim/laue/laue.tcl:17>> VarMake Instrument Text Internal 
-sim/trics/trics.tcl:18>> SicsUser lnsmanager   lnsSICSlns 1
+sim/laue/laue.tcl:18>> VarMake sample Text User
-sim/trics/trics.tcl:19>> SicsUser tricsuser   07lns1 2
+sim/laue/laue.tcl:19>> sample " "
-sim/trics/trics.tcl:20>> SicsUser lnsg  07lns1 2
+sim/laue/laue.tcl:20>> VarMake Title Text User
-sim/trics/trics.tcl:21>> VarMake Instrument Text Internal
+sim/laue/laue.tcl:21>> Title " "
-sim/trics/trics.tcl:22>> Instrument lock
+sim/laue/laue.tcl:22>> VarMake User  Text User
-sim/trics/trics.tcl:23>> VarMake Title Text User
+sim/laue/laue.tcl:23>> User  " "
-sim/trics/trics.tcl:24>> VarMake sample Text User
+sim/laue/laue.tcl:24>> VarMake email Text User
-sim/trics/trics.tcl:25>> sample "Schefer"
+sim/laue/laue.tcl:25>> email "unknown"
-sim/trics/trics.tcl:26>> VarMake User  Text User
+sim/laue/laue.tcl:26>> VarMake address Text User
-sim/trics/trics.tcl:27>> User  "Jurg"
+sim/laue/laue.tcl:27>> address "unknown"
-sim/trics/trics.tcl:28>> VarMake fax Text User
+sim/laue/laue.tcl:28>> VarMake fax Text User
-sim/trics/trics.tcl:29>> VarMake phone Text User
+sim/laue/laue.tcl:29>> fax "unknown"
-sim/trics/trics.tcl:30>> FAX   "EMERGENCY: 056 - 250.1332"
+sim/laue/laue.tcl:30>> VarMake phone Text User
-sim/trics/trics.tcl:31>> PHONE "EMERGENCY: 079 - 692.5617"
+sim/laue/laue.tcl:31>> phone "unknown"
-sim/trics/trics.tcl:32>> VarMake distance Float User
+sim/laue/laue.tcl:32>> hm configure counter counter
-sim/trics/trics.tcl:33>> VarMake monochromator  Text User
+sim/laue/laue.tcl:33>> hm configure amplictrl 1
-sim/trics/trics.tcl:34>> VarMake lambda Float Mugger
+sim/laue/laue.tcl:34>> hm configure shutterctrl 2
-sim/trics/trics.tcl:35>> VarMake BatchRoot Text User
+sim/laue/laue.tcl:35>> hm configure clear 1
-sim/trics/trics.tcl:36>> VarMake LastScanCommand Text User
+sim/laue/laue.tcl:36>> hm configure rank 2
-sim/trics/trics.tcl:37>> lastscancommand unknown scan
+sim/laue/laue.tcl:37>> hm configure dim0 768
-sim/trics/trics.tcl:38>> ClientPut "Initialising Elephant"
+sim/laue/laue.tcl:38>> hm configure dim1 568
-Initialising Elephant
+sim/laue/laue.tcl:39>> sicsdatafactory new __transfer
-sim/trics/trics.tcl:39>> ClientPut "Initialising Sample Table Motors"
+sim/laue/laue.tcl:40>> MakeSicsObj lscan LaueScan
-Initialising Sample Table Motors
+sim/laue/laue.tcl:41>> hmake /sics/lscan/upperpos mugger  float
-sim/trics/trics.tcl:40>> cex1 precision .05
+sim/laue/laue.tcl:42>> hmake /sics/lscan/lowerpos mugger  float
-sim/trics/trics.tcl:41>> cex1 failafter 5
+sim/laue/laue.tcl:43>> hmake /sics/lscan/sttbegin user    float
-sim/trics/trics.tcl:42>> cex1 softlowerlim 0
+sim/laue/laue.tcl:44>> hmake /sics/lscan/sttend   user    float
-sim/trics/trics.tcl:43>> cex1 softupperlim 360
+sim/laue/laue.tcl:45>> hmake /sics/lscan/sttstep  user    float
-sim/trics/trics.tcl:44>> cex2 precision .05
+sim/laue/laue.tcl:46>> hcommand /sics/lscan/run lauescan
-sim/trics/trics.tcl:45>> cex2 failafter 5
+sim/laue/laue.tcl:47>> hsetprop /sics/lscan/run type command
-sim/trics/trics.tcl:46>> cex2 softlowerlim 0
+sim/laue/laue.tcl:48>> hsetprop /sics/lscan/run priv user
-sim/trics/trics.tcl:47>> cex2 softupperlim 360
+sim/laue/laue.tcl:49>> hmake /sics/lscan/run/mode    user   text
-sim/trics/trics.tcl:48>> stt precision .03
+sim/laue/laue.tcl:50>> hmake /sics/lscan/run/preset  user   float
-sim/trics/trics.tcl:49>> MakeConfigurableMotor D1W
+sim/laue/laue.tcl:51>> hset /sics/lscan/upperpos 190.
-sim/trics/trics.tcl:50>> D1W drivescript widthscript
+sim/laue/laue.tcl:52>> hset /sics/lscan/lowerpos 5.
-sim/trics/trics.tcl:51>> D1W readscript readwidth
+sim/laue/laue.tcl:53>> hset /sics/lscan/sttbegin 10.
-sim/trics/trics.tcl:52>> MakeConfigurableMotor D1H
+sim/laue/laue.tcl:54>> hset /sics/lscan/sttend   30.
-sim/trics/trics.tcl:53>> D1H drivescript heightscript
+sim/laue/laue.tcl:55>> hset /sics/lscan/sttstep  5.
-sim/trics/trics.tcl:54>> D1H readscript readheight
+sim/laue/laue.tcl:56>> hset /sics/lscan/run/mode timer
-sim/trics/trics.tcl:55>> SicsAlias MOMU A1
+sim/laue/laue.tcl:57>> hset /sics/lscan/run/preset 2.
-sim/trics/trics.tcl:56>> SicsAlias MTVU A12
+sim/laue/laue.tcl:58>> MakeDataNumber SicsDataNumber $datahome/DataNumber
-sim/trics/trics.tcl:57>> SicsAlias MTPU A13
+sim/laue/laue.tcl:59>> VarMake SicsDataPath Text Mugger
-sim/trics/trics.tcl:58>> SicsAlias MGVU A14
+sim/laue/laue.tcl:60>> SicsDataPath $datahome/
-sim/trics/trics.tcl:59>> SicsAlias MGPU A15
+sim/laue/laue.tcl:61>> SicsDataPath lock
-sim/trics/trics.tcl:60>> SicsAlias MCVU A16
+sim/laue/laue.tcl:62>> VarMake SicsDataPrefix Text Mugger
-sim/trics/trics.tcl:61>> SicsAlias MOML B1
+sim/laue/laue.tcl:63>> SicsDataPrefix laue
-sim/trics/trics.tcl:62>> SicsAlias MTVL A22
+sim/laue/laue.tcl:64>> SicsDataPrefix lock
-sim/trics/trics.tcl:63>> SicsAlias MTPL A23
+sim/laue/laue.tcl:65>> VarMake SicsDataPostFix Text Mugger
-sim/trics/trics.tcl:64>> SicsAlias MGVL A24
+sim/laue/laue.tcl:66>> SicsDataPostFix .hdf
-sim/trics/trics.tcl:65>> SicsAlias MGPL A25
+sim/laue/laue.tcl:67>> SicsDataPostFix lock
-sim/trics/trics.tcl:66>> SicsAlias MCVL A26
+sim/laue/laue.tcl:68>> clientput "Laue configuration done"
-sim/trics/trics.tcl:67>> SicsAlias MEXZ A37
+Laue configuration done
-sim/trics/trics.tcl:68>> SicsAlias SOM A3
+OK
-sim/trics/trics.tcl:69>> SicsAlias SOM OM
+ERROR: alias daba not recognized 
-sim/trics/trics.tcl:70>> SicsAlias STT A4
+OK
-sim/trics/trics.tcl:71>> SicsAlias STT TH
+==19540== 
-sim/trics/trics.tcl:72>> SicsAlias SCH A10
+==19540== ERROR SUMMARY: 4310127 errors from 22 contexts (suppressed: 29 from 3)
-sim/trics/trics.tcl:73>> SicsAlias SPH A20
+==19540== malloc/free: in use at exit: 73,818 bytes in 1,540 blocks.
-sim/trics/trics.tcl:74>> SicsAlias SCH CH
+==19540== malloc/free: 14,838 allocs, 13,298 frees, 5,407,018 bytes allocated.
-sim/trics/trics.tcl:75>> SicsAlias SCH CHI
+==19540== For counts of detected errors, rerun with: -v
-sim/trics/trics.tcl:76>> SicsAlias SPH PH
+==19540== searching for pointers to 1,540 not-freed blocks.
-sim/trics/trics.tcl:77>> SicsAlias DG1 A31
+==19540== checked 479,156 bytes.
-sim/trics/trics.tcl:78>> SicsAlias DG2 A32
+==19540== 
-sim/trics/trics.tcl:79>> SicsAlias DG3 A33
+==19540== LEAK SUMMARY:
-sim/trics/trics.tcl:80>> SicsAlias FILEEVAL XBU
+==19540==    definitely lost: 69 bytes in 6 blocks.
-sim/
+==19540==      possibly lost: 8,000 bytes in 1 blocks.
+==19540==    still reachable: 65,749 bytes in 1,533 blocks.
+==19540==         suppressed: 0 bytes in 0 blocks.
+==19540== Rerun with --leak-check=full to see details of leaked memory.