linse/sics
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

*** empty log message ***

Browse Source
This commit is contained in:
koennecke
2007-11-27 13:36:15 +00:00
parent 1265ae957b
commit 22b0e8ec83
50 changed files with 6025 additions and 171 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
asyncprotocol.c
View File

@ -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);

3
asyncprotocol.h
View File

@ -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 {

45
asyncqueue.c
View File

@ -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;
}

8
asyncqueue.h
View File

@ -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.
*

1
devexec.c
View File

@ -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;

2
diffscan.c
View File

@ -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;

13
exe.w
View File

@ -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

40
exebuf.c
View File

@ -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);

17
exebuf.h
View File

@ -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

4
exebuf.i
View File

@ -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"

6
exeman.i
View File

@ -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"

613
genericcontroller.c Normal file
View File

@ -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;
}

37
genericcontroller.h Normal file
View File

@ -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_*/

19
geninter.c Normal file
View File

@ -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;
}

19
geninter.h Normal file
View File

@ -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_*/

29
hdbqueue.c
View File

@ -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;

28
hipadaba.c
View File

@ -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;
}

1
hipadaba.h
View File

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

6
histsim.c
View File

@ -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;
}

5
hkl.c
View File

@ -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,

15
lld_blob.c
View File

@ -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 )

3
lld_blob.h
View File

@ -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.

7
macro.c
View File

@ -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;
}
/*--------------------------------------------------------------------------*/

3
make_gen
View File

@ -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

4
makefile_slinux
View File

@ -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)\
-ltcl8.3 $(HDFROOT)/lib/libhdf5.a \
LIBS = -L$(HDFROOT)/lib $(SUBLIBS) $(NILIB)\
-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

3
multicounter.c
View File

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

3
napi5.c
View File

@ -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);

7
nserver.c
View File

@ -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();

294
nxcopy.c Normal file
View File

@ -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;
}

16
nxcopy.h Normal file
View File

@ -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_*/

3516
nxinter_wrap.c Normal file
View File

File diff suppressed because it is too large Load Diff

561
nxinterhelper.c Normal file
View File

@ -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;
}
}

68
nxinterhelper.h Normal file
View File

@ -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

9
ofac.c
View File

@ -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;

6
polldriv.c
View File

@ -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();
assert(root != NULL);
node = GetHipadabaNode(root,objectIdentifier);
node = locateSICSNode(pServ->pSics,pCon,objectIdentifier);
if(node == NULL){
SCWrite(pCon,"ERROR: object to poll not found",eError);
return 0;

6
polldriv.tc
View File

@ -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();
assert(root != NULL);
node = GetHipadabaNode(root,objectIdentifier);
node = locateSICSNode(pServ->pSics,pCon,objectIdentifier);
if(node == NULL){
SCWrite(pCon,"ERROR: object to poll not found",eError);
return 0;

8
selvar.c
View File

@ -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)

1
sicshdbadapter.c
View File

@ -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;

91
sicshipadaba.c
View File

@ -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);
return 0;
SCWrite(pCon,"ERROR: attribute not found",eValue);
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);

15
sicshipadaba.h
View File

@ -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.

110
sicsobj.c
View File

@ -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);

2
sicsobj.h
View File

@ -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);

55
sicsstat.tcl
View File

@ -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

16
statemon.c
View File

@ -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;

124
status.c
View File

@ -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;
}

4
status.h
View File

@ -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

3
task.c
View File

@ -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);

2
tasub.c
View File

@ -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){

14
tclintimpl.c
View File

@ -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]);
SCWrite(pCon,pBuffer,eError);
return 0;
if(self->pDriv->GetValue != NULL){
val = self->pDriv->GetValue(self,pCon);
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]);

331
val.lis
View File

@ -1,93 +1,240 @@
==6880== Memcheck, a memory error detector.
==6880== Copyright (C) 2002-2007, and GNU GPL'd, by Julian Seward et al.
==6880== Using LibVEX rev 1732, a library for dynamic binary translation.
==6880== Copyright (C) 2004-2007, and GNU GPL'd, by OpenWorks LLP.
==6880== Using valgrind-3.2.3, a dynamic binary instrumentation framework.
==6880== Copyright (C) 2000-2007, and GNU GPL'd, by Julian Seward et al.
==6880== For more details, rerun with: -v
==6880==
==19540== Memcheck, a memory error detector.
==19540== Copyright (C) 2002-2007, and GNU GPL'd, by Julian Seward et al.
==19540== Using LibVEX rev 1732, a library for dynamic binary translation.
==19540== Copyright (C) 2004-2007, and GNU GPL'd, by OpenWorks LLP.
==19540== Using valgrind-3.2.3, a dynamic binary instrumentation framework.
==19540== Copyright (C) 2000-2007, and GNU GPL'd, by Julian Seward et al.
==19540== For more details, rerun with: -v
==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/trics/trics.tcl:1>> ServerOption AcceptTimeOut 100
sim/trics/trics.tcl:2>> ServerOption ReadUserPasswdTimeout 7000
sim/trics/trics.tcl:3>> ServerOption LogFileDir $loghome
sim/trics/trics.tcl:4>> ServerOption LogFileBaseName $loghome/tricsserver
sim/trics/trics.tcl:5>> ServerOption statusfile ${datahome}tricsstatus.tcl
sim/trics/trics.tcl:6>> ServerOption TecsPort 9753
sim/trics/trics.tcl:7>> ServerOption ServerPort 2911
sim/trics/trics.tcl:8>> ServerOption InterruptPort 2914
sim/trics/trics.tcl:9>> ServerOption TelnetPort 1301
sim/trics/trics.tcl:10>> ServerOption TelWord sicslogin
sim/trics/trics.tcl:11>> ServerOption QuieckPort 2108
sim/trics/trics.tcl:12>> TokenInit connan
sim/trics/trics.tcl:13>> commandlog intervall 10
sim/trics/trics.tcl:14>> commandlog auto
sim/trics/trics.tcl:15>> SicsUser jurg willi 2
sim/trics/trics.tcl:16>> SicsUser oksana sun 1
sim/trics/trics.tcl:17>> SicsUser schaniel brida 2
sim/trics/trics.tcl:18>> SicsUser lnsmanager lnsSICSlns 1
sim/trics/trics.tcl:19>> SicsUser tricsuser 07lns1 2
sim/trics/trics.tcl:20>> SicsUser lnsg 07lns1 2
sim/trics/trics.tcl:21>> VarMake Instrument Text Internal
sim/trics/trics.tcl:22>> Instrument lock
sim/trics/trics.tcl:23>> VarMake Title Text User
sim/trics/trics.tcl:24>> VarMake sample Text User
sim/trics/trics.tcl:25>> sample "Schefer"
sim/trics/trics.tcl:26>> VarMake User Text User
sim/trics/trics.tcl:27>> User "Jurg"
sim/trics/trics.tcl:28>> VarMake fax Text User
sim/trics/trics.tcl:29>> VarMake phone Text User
sim/trics/trics.tcl:30>> FAX "EMERGENCY: 056 - 250.1332"
sim/trics/trics.tcl:31>> PHONE "EMERGENCY: 079 - 692.5617"
sim/trics/trics.tcl:32>> VarMake distance Float User
sim/trics/trics.tcl:33>> VarMake monochromator Text User
sim/trics/trics.tcl:34>> VarMake lambda Float Mugger
sim/trics/trics.tcl:35>> VarMake BatchRoot Text User
sim/trics/trics.tcl:36>> VarMake LastScanCommand Text User
sim/trics/trics.tcl:37>> lastscancommand unknown scan
sim/trics/trics.tcl:38>> ClientPut "Initialising Elephant"
Initialising Elephant
sim/trics/trics.tcl:39>> ClientPut "Initialising Sample Table Motors"
Initialising Sample Table Motors
sim/trics/trics.tcl:40>> cex1 precision .05
sim/trics/trics.tcl:41>> cex1 failafter 5
sim/trics/trics.tcl:42>> cex1 softlowerlim 0
sim/trics/trics.tcl:43>> cex1 softupperlim 360
sim/trics/trics.tcl:44>> cex2 precision .05
sim/trics/trics.tcl:45>> cex2 failafter 5
sim/trics/trics.tcl:46>> cex2 softlowerlim 0
sim/trics/trics.tcl:47>> cex2 softupperlim 360
sim/trics/trics.tcl:48>> stt precision .03
sim/trics/trics.tcl:49>> MakeConfigurableMotor D1W
sim/trics/trics.tcl:50>> D1W drivescript widthscript
sim/trics/trics.tcl:51>> D1W readscript readwidth
sim/trics/trics.tcl:52>> MakeConfigurableMotor D1H
sim/trics/trics.tcl:53>> D1H drivescript heightscript
sim/trics/trics.tcl:54>> D1H readscript readheight
sim/trics/trics.tcl:55>> SicsAlias MOMU A1
sim/trics/trics.tcl:56>> SicsAlias MTVU A12
sim/trics/trics.tcl:57>> SicsAlias MTPU A13
sim/trics/trics.tcl:58>> SicsAlias MGVU A14
sim/trics/trics.tcl:59>> SicsAlias MGPU A15
sim/trics/trics.tcl:60>> SicsAlias MCVU A16
sim/trics/trics.tcl:61>> SicsAlias MOML B1
sim/trics/trics.tcl:62>> SicsAlias MTVL A22
sim/trics/trics.tcl:63>> SicsAlias MTPL A23
sim/trics/trics.tcl:64>> SicsAlias MGVL A24
sim/trics/trics.tcl:65>> SicsAlias MGPL A25
sim/trics/trics.tcl:66>> SicsAlias MCVL A26
sim/trics/trics.tcl:67>> SicsAlias MEXZ A37
sim/trics/trics.tcl:68>> SicsAlias SOM A3
sim/trics/trics.tcl:69>> SicsAlias SOM OM
sim/trics/trics.tcl:70>> SicsAlias STT A4
sim/trics/trics.tcl:71>> SicsAlias STT TH
sim/trics/trics.tcl:72>> SicsAlias SCH A10
sim/trics/trics.tcl:73>> SicsAlias SPH A20
sim/trics/trics.tcl:74>> SicsAlias SCH CH
sim/trics/trics.tcl:75>> SicsAlias SCH CHI
sim/trics/trics.tcl:76>> SicsAlias SPH PH
sim/trics/trics.tcl:77>> SicsAlias DG1 A31
sim/trics/trics.tcl:78>> SicsAlias DG2 A32
sim/trics/trics.tcl:79>> SicsAlias DG3 A33
sim/trics/trics.tcl:80>> SicsAlias FILEEVAL XBU
sim/
sim/laue/laue.tcl:0>> ServerOption ReadTimeOut 10
sim/laue/laue.tcl:1>> ServerOption AcceptTimeOut 10
sim/laue/laue.tcl:2>> ServerOption ReadUserPasswdTimeout 500000
sim/laue/laue.tcl:3>> ServerOption ServerPort 2911
sim/laue/laue.tcl:4>> ServerOption InterruptPort 2913
sim/laue/laue.tcl:5>> ServerOption TelnetPort 1301
sim/laue/laue.tcl:6>> ServerOption TelWord sicslogin
sim/laue/laue.tcl:7>> ServerOption QuieckPort 2108
sim/laue/laue.tcl:8>> TokenInit connan
sim/laue/laue.tcl:9>> ServerOption LogFileDir $loghome
sim/laue/laue.tcl:10>> commandlog auto
sim/laue/laue.tcl:11>> ServerOption statusfile $datahome/lauestatus.tcl
sim/laue/laue.tcl:12>> SicsUser Mugger Mugger 1
sim/laue/laue.tcl:13>> SicsUser lnsmanager lnsSICSlns 1
sim/laue/laue.tcl:14>> SicsUser User User 2
sim/laue/laue.tcl:15>> SicsUser Spy Spy 3
sim/laue/laue.tcl:16>> SicsUser laueuser 07lns1 2
sim/laue/laue.tcl:17>> VarMake Instrument Text Internal
sim/laue/laue.tcl:18>> VarMake sample Text User
sim/laue/laue.tcl:19>> sample " "
sim/laue/laue.tcl:20>> VarMake Title Text User
sim/laue/laue.tcl:21>> Title " "
sim/laue/laue.tcl:22>> VarMake User Text User
sim/laue/laue.tcl:23>> User " "
sim/laue/laue.tcl:24>> VarMake email Text User
sim/laue/laue.tcl:25>> email "unknown"
sim/laue/laue.tcl:26>> VarMake address Text User
sim/laue/laue.tcl:27>> address "unknown"
sim/laue/laue.tcl:28>> VarMake fax Text User
sim/laue/laue.tcl:29>> fax "unknown"
sim/laue/laue.tcl:30>> VarMake phone Text User
sim/laue/laue.tcl:31>> phone "unknown"
sim/laue/laue.tcl:32>> hm configure counter counter
sim/laue/laue.tcl:33>> hm configure amplictrl 1
sim/laue/laue.tcl:34>> hm configure shutterctrl 2
sim/laue/laue.tcl:35>> hm configure clear 1
sim/laue/laue.tcl:36>> hm configure rank 2
sim/laue/laue.tcl:37>> hm configure dim0 768
sim/laue/laue.tcl:38>> hm configure dim1 568
sim/laue/laue.tcl:39>> sicsdatafactory new __transfer
sim/laue/laue.tcl:40>> MakeSicsObj lscan LaueScan
sim/laue/laue.tcl:41>> hmake /sics/lscan/upperpos mugger float
sim/laue/laue.tcl:42>> hmake /sics/lscan/lowerpos mugger float
sim/laue/laue.tcl:43>> hmake /sics/lscan/sttbegin user float
sim/laue/laue.tcl:44>> hmake /sics/lscan/sttend user float
sim/laue/laue.tcl:45>> hmake /sics/lscan/sttstep user float
sim/laue/laue.tcl:46>> hcommand /sics/lscan/run lauescan
sim/laue/laue.tcl:47>> hsetprop /sics/lscan/run type command
sim/laue/laue.tcl:48>> hsetprop /sics/lscan/run priv user
sim/laue/laue.tcl:49>> hmake /sics/lscan/run/mode user text
sim/laue/laue.tcl:50>> hmake /sics/lscan/run/preset user float
sim/laue/laue.tcl:51>> hset /sics/lscan/upperpos 190.
sim/laue/laue.tcl:52>> hset /sics/lscan/lowerpos 5.
sim/laue/laue.tcl:53>> hset /sics/lscan/sttbegin 10.
sim/laue/laue.tcl:54>> hset /sics/lscan/sttend 30.
sim/laue/laue.tcl:55>> hset /sics/lscan/sttstep 5.
sim/laue/laue.tcl:56>> hset /sics/lscan/run/mode timer
sim/laue/laue.tcl:57>> hset /sics/lscan/run/preset 2.
sim/laue/laue.tcl:58>> MakeDataNumber SicsDataNumber $datahome/DataNumber
sim/laue/laue.tcl:59>> VarMake SicsDataPath Text Mugger
sim/laue/laue.tcl:60>> SicsDataPath $datahome/
sim/laue/laue.tcl:61>> SicsDataPath lock
sim/laue/laue.tcl:62>> VarMake SicsDataPrefix Text Mugger
sim/laue/laue.tcl:63>> SicsDataPrefix laue
sim/laue/laue.tcl:64>> SicsDataPrefix lock
sim/laue/laue.tcl:65>> VarMake SicsDataPostFix Text Mugger
sim/laue/laue.tcl:66>> SicsDataPostFix .hdf
sim/laue/laue.tcl:67>> SicsDataPostFix lock
sim/laue/laue.tcl:68>> clientput "Laue configuration done"
Laue configuration done
OK
ERROR: alias daba not recognized
OK
==19540==
==19540== ERROR SUMMARY: 4310127 errors from 22 contexts (suppressed: 29 from 3)
==19540== malloc/free: in use at exit: 73,818 bytes in 1,540 blocks.
==19540== malloc/free: 14,838 allocs, 13,298 frees, 5,407,018 bytes allocated.
==19540== For counts of detected errors, rerun with: -v
==19540== searching for pointers to 1,540 not-freed blocks.
==19540== checked 479,156 bytes.
==19540==
==19540== LEAK SUMMARY:
==19540== definitely lost: 69 bytes in 6 blocks.
==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.