From 22b0e8ec83f1c4aeeb3b88884e933c46d6bf48d8 Mon Sep 17 00:00:00 2001 From: koennecke Date: Tue, 27 Nov 2007 13:36:15 +0000 Subject: [PATCH] *** empty log message *** --- asyncprotocol.c | 3 + asyncprotocol.h | 3 +- asyncqueue.c | 45 +- asyncqueue.h | 8 + devexec.c | 1 + diffscan.c | 2 +- exe.w | 13 + exebuf.c | 40 + exebuf.h | 17 +- exebuf.i | 4 +- exeman.i | 6 +- genericcontroller.c | 613 ++++++++ genericcontroller.h | 37 + geninter.c | 19 + geninter.h | 19 + hdbqueue.c | 29 +- hipadaba.c | 28 +- hipadaba.h | 1 + histsim.c | 6 + hkl.c | 5 +- lld_blob.c | 15 + lld_blob.h | 3 +- macro.c | 7 +- make_gen | 3 +- makefile_slinux | 4 +- multicounter.c | 3 +- napi5.c | 3 +- nserver.c | 7 + nxcopy.c | 294 ++++ nxcopy.h | 16 + nxinter_wrap.c | 3516 +++++++++++++++++++++++++++++++++++++++++++ nxinterhelper.c | 561 +++++++ nxinterhelper.h | 68 + ofac.c | 9 +- polldriv.c | 6 +- polldriv.tc | 6 +- selvar.c | 8 +- sicshdbadapter.c | 1 + sicshipadaba.c | 91 +- sicshipadaba.h | 15 + sicsobj.c | 110 +- sicsobj.h | 2 +- sicsstat.tcl | 55 +- statemon.c | 16 +- status.c | 124 +- status.h | 4 +- task.c | 3 +- tasub.c | 2 +- tclintimpl.c | 14 +- val.lis | 331 ++-- 50 files changed, 6025 insertions(+), 171 deletions(-) create mode 100644 genericcontroller.c create mode 100644 genericcontroller.h create mode 100644 geninter.c create mode 100644 geninter.h create mode 100644 nxcopy.c create mode 100644 nxcopy.h create mode 100644 nxinter_wrap.c create mode 100644 nxinterhelper.c create mode 100644 nxinterhelper.h diff --git a/asyncprotocol.c b/asyncprotocol.c index 35fa8526..211dba1c 100644 --- a/asyncprotocol.c +++ b/asyncprotocol.c @@ -93,6 +93,9 @@ int defaultPrepareTxn(pAsyncProtocol p, pAsyncTxn txn, const char* cmd, int cmd_ } txn->out_len = cmd_len; txn->out_idx = 0; + if(txn->inp_buf != NULL){ + free(txn->inp_buf); + } txn->inp_buf = malloc(rsp_len); if (txn->inp_buf == NULL) { SICSLogWrite("Out of memory in AsyncProtocol::defaultPrepareTxn", eError); diff --git a/asyncprotocol.h b/asyncprotocol.h index 2bf04d18..528dcb98 100644 --- a/asyncprotocol.h +++ b/asyncprotocol.h @@ -21,7 +21,8 @@ typedef enum { ATX_NULL=0, ATX_TIMEOUT=-1, ATX_ACTIVE=1, - ATX_COMPLETE=2 + ATX_COMPLETE=2, + ATX_DISCO=3 } ATX_STATUS; struct __async_txn { diff --git a/asyncqueue.c b/asyncqueue.c index fe7254a6..a86f561e 100644 --- a/asyncqueue.c +++ b/asyncqueue.c @@ -8,7 +8,7 @@ * single command channel. * * Douglas Clowes, February 2007 - * + * */ #include @@ -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; +} + diff --git a/asyncqueue.h b/asyncqueue.h index c066d284..4f5bfc53 100644 --- a/asyncqueue.h +++ b/asyncqueue.h @@ -17,6 +17,9 @@ #define AQU_RETRY_CMD -4 #define AQU_POP_CMD -5 +typedef struct __AsyncQueue AsyncQueue, *pAsyncQueue; + + /** \brief create an AsyncUnit attached to a named AsyncQueue. * * \param queueName the name of the AsyncQueue to be used @@ -24,6 +27,11 @@ * \return positive if successful */ int AsyncUnitCreate(const char* queueName, pAsyncUnit* unit); +/** \brief Get an AsyncUnit from a given AsyncQueue + * \param queue The AsyncQueue fro which this AsyncUnit is valid + * \return a new AsyncUnit or NULL on error + */ +pAsyncUnit AsyncUnitFromQueue(pAsyncQueue queue); /** \brief create an AsyncUnit attached to an anonymous AsyncQueue. * diff --git a/devexec.c b/devexec.c index c4df66e9..7272490e 100644 --- a/devexec.c +++ b/devexec.c @@ -221,6 +221,7 @@ typedef struct { pRes->iLock = 0; pRes->drivePrint = 0; pRes->paused = 0; + pRes->taskRunning = 0; pRes->pCall = CreateCallBackInterface(); pRes->lastRun = time(NULL); pRes->pDes->GetInterface = DevexecInterface; diff --git a/diffscan.c b/diffscan.c index 22cf3b74..08fd95d3 100644 --- a/diffscan.c +++ b/diffscan.c @@ -336,7 +336,7 @@ static int DiffScanTask(void *pData){ check for interrupt */ if(SCGetInterrupt(self->scanObject->pCon) >= eAbortScan){ - pCount->pDriv->Halt(pCount->pDriv); + pCount->pCountInt->Halt(pCount); pVar->pInter->Halt(pVar->pObject); SicsWait(1); finish = 0; diff --git a/exe.w b/exe.w index 47579b99..cd01232c 100644 --- a/exe.w +++ b/exe.w @@ -89,6 +89,19 @@ The interface to this buffer system comprises: */ int exeBufProcess(pExeBuf self, SicsInterp *pSics, SConnection *pCon, pICallBack pCall, int echo); + /** + * Process an exe buffer, but store commands causing errors in a list. + * This is used for restoring status files. + * @@param self The exe buffer to process + * @@param pSics The SICS interpreter to use for processing + * @@param pCon The connection object providing the environment for + * processing this buffer. + * @@param errCommandList A lld string list for storing commands which + * had errors. + * @@return 1 on success, 0 on error + */ + int exeBufProcessErrList(pExeBuf self, SicsInterp *pSics, + SConnection *pCon, int errCommandList); /** * retrieves the executing range * @@param self The exe buffer to query diff --git a/exebuf.c b/exebuf.c index 431a6d33..3fad44f1 100644 --- a/exebuf.c +++ b/exebuf.c @@ -11,6 +11,7 @@ #include #include #include +#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); diff --git a/exebuf.h b/exebuf.h index 21058511..bb1edba4 100644 --- a/exebuf.h +++ b/exebuf.h @@ -1,5 +1,5 @@ -#line 213 "exe.w" +#line 226 "exe.w" /** * Buffer handling code for the Exe Buffer batch file processing @@ -63,6 +63,19 @@ */ int exeBufProcess(pExeBuf self, SicsInterp *pSics, SConnection *pCon, pICallBack pCall, int echo); + /** + * Process an exe buffer, but store commands causing errors in a list. + * This is used for restoring status files. + * @param self The exe buffer to process + * @param pSics The SICS interpreter to use for processing + * @param pCon The connection object providing the environment for + * processing this buffer. + * @param errCommandList A lld string list for storing commands which + * had errors. + * @return 1 on success, 0 on error + */ + int exeBufProcessErrList(pExeBuf self, SicsInterp *pSics, + SConnection *pCon, int errCommandList); /** * retrieves the executing range * @param self The exe buffer to query @@ -89,7 +102,7 @@ */ char *exeBufName(pExeBuf self); -#line 226 "exe.w" +#line 239 "exe.w" #endif diff --git a/exebuf.i b/exebuf.i index 5ce8fea3..32da477f 100644 --- a/exebuf.i +++ b/exebuf.i @@ -1,5 +1,5 @@ -#line 204 "exe.w" +#line 217 "exe.w" /*-------------------------------------------------------------------- Internal header file for the exe buffer module. Do not edit. This is @@ -16,6 +16,6 @@ typedef struct __EXEBUF{ int lineno; } ExeBuf; -#line 209 "exe.w" +#line 222 "exe.w" diff --git a/exeman.i b/exeman.i index 965dc003..8b8512fb 100644 --- a/exeman.i +++ b/exeman.i @@ -1,12 +1,12 @@ -#line 182 "exe.w" +#line 195 "exe.w" /*------------------------------------------------------------------- Internal header file for the exe manager module. Do not edit. This is automatically generated from exe.w -------------------------------------------------------------------*/ -#line 138 "exe.w" +#line 151 "exe.w" typedef struct __EXEMAN{ pObjectDescriptor pDes; @@ -20,5 +20,5 @@ typedef struct __EXEMAN{ int echo; }ExeMan, *pExeMan; -#line 187 "exe.w" +#line 200 "exe.w" diff --git a/genericcontroller.c b/genericcontroller.c new file mode 100644 index 00000000..ef43f811 --- /dev/null +++ b/genericcontroller.c @@ -0,0 +1,613 @@ +/** + * This is a generic controller for devices in SICS. It is configurable via Tcl + * scripts. + * + * copyright: see file COPYRIGHT + * + * Mark Koennecke, November 2007 + */ +#include +#include +#include +#include +#include +#include +#include +#include +#include +/*--------------------------------------------------------------------------*/ +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; +} + diff --git a/genericcontroller.h b/genericcontroller.h new file mode 100644 index 00000000..2ba805a7 --- /dev/null +++ b/genericcontroller.h @@ -0,0 +1,37 @@ +/** + * This is a generic controller for devices in SICS. In its default configuration it + * will be configurable via Tcl scripts and used AsynqQueue for communication. But + * it is suitably generic to support other mechanisms as well. + * + * copyright: see file COPYRIGHT + * + * Mark Koennecke, November 2007 + */ +#ifndef GENERICCONTROLLER_H_ +#define GENERICCONTROLLER_H_ +#include +#include + +#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_*/ diff --git a/geninter.c b/geninter.c new file mode 100644 index 00000000..0567494b --- /dev/null +++ b/geninter.c @@ -0,0 +1,19 @@ +/** + * This is the implementation of various SICS internal interfaces based on + * parameters in a generic controller. + * + * copyright: see file COPYRIGHT + * + * Mark Koennecke, November 2007 + */ +#include +#include +#include +#include + +/*---------------------------------------------------------------------------*/ +int GenDrivableFactory(SConnection *pCon, SicsInterp *pSics, + void *pData, int argc, char *argv[]){ + + return 1; +} diff --git a/geninter.h b/geninter.h new file mode 100644 index 00000000..05a469cd --- /dev/null +++ b/geninter.h @@ -0,0 +1,19 @@ +/** + * This is the implementation of various SICS internal interfaces based on + * parameters in a generic controller. + * + * copyright: see file COPYRIGHT + * + * Mark Koennecke, November 2007 + */ +#ifndef GENINTER_H_ +#define GENINTER_H_ +/** + * make a drivable parameter: + * Usage: + * MakeGenDrivable name par-node control-node + */ +int GenDrivableFactory(SConnection *pCon, SicsInterp *pSics, + void *pData, int argc, char *argv[]); + +#endif /*GENINTER_H_*/ diff --git a/hdbqueue.c b/hdbqueue.c index e59b7474..ebf0c7c6 100644 --- a/hdbqueue.c +++ b/hdbqueue.c @@ -68,7 +68,8 @@ static pHdb MakeNewEntry(char *name, pHdbCallback update){ return entry; } /*---------------------------------------------------------------------------*/ -static int EnqueFunc(pSICSOBJ self, SConnection *pCon, pHdb par[], int nPar){ +static int EnqueFunc(pSICSOBJ self, SConnection *pCon, Hdb commandNode, + pHdb par[], int nPar){ pHdb entry = NULL; pHdb work = NULL; char name[80]; @@ -113,7 +114,8 @@ static int EnqueFunc(pSICSOBJ self, SConnection *pCon, pHdb par[], int nPar){ return 1; } /*---------------------------------------------------------------------------*/ -static int AddCmdData(pSICSOBJ self, SConnection *pCon, pHdb par[], int nPar){ +static int AddCmdData(pSICSOBJ self, SConnection *pCon, Hdb comNode, + pHdb par[], int nPar){ pHdb work = NULL; pHdb commandNode = NULL; char name[80]; @@ -171,7 +173,8 @@ static void sequentialNames(pHdb obj,SConnection *pCon){ NotifyHipadabaPar(work,pCon); } /*---------------------------------------------------------------------------*/ -static int Dequeue(pSICSOBJ self, SConnection *pCon, pHdb par[], int nPar){ +static int Dequeue(pSICSOBJ self, SConnection *pCon, pHdb commandNode, + pHdb par[], int nPar){ pHdb work = NULL; char name[80]; pHdbQueue priv = (pHdbQueue)self->pPrivate; @@ -198,7 +201,8 @@ static int Dequeue(pSICSOBJ self, SConnection *pCon, pHdb par[], int nPar){ return 0; } /*---------------------------------------------------------------------------*/ -static int Clean(pSICSOBJ self, SConnection *pCon, pHdb par[], int nPar){ +static int Clean(pSICSOBJ self, SConnection *pCon,Hdb commandNode, + pHdb par[], int nPar){ int i; pHdb current = NULL, queue = NULL; pHdb currentEntry = NULL, tmp = NULL; @@ -225,7 +229,8 @@ static int Clean(pSICSOBJ self, SConnection *pCon, pHdb par[], int nPar){ return 1; } /*---------------------------------------------------------------------------*/ -static int CleanAll(pSICSOBJ self, SConnection *pCon, pHdb par[], int nPar){ +static int CleanAll(pSICSOBJ self, SConnection *pCon, pHdb commandNode, + pHdb par[], int nPar){ int i; pHdb current = NULL, queue = NULL; pHdb currentEntry = NULL, tmp; @@ -292,7 +297,8 @@ static int QueueTask(void *pData){ return 1; } /*---------------------------------------------------------------------------*/ -static int Start(pSICSOBJ self, SConnection *pCon, pHdb par[], int nPar){ +static int Start(pSICSOBJ self, SConnection *pCon, pHdb commandNode, + pHdb par[], int nPar){ pHdbQueue priv = (pHdbQueue)self->pPrivate; priv->iStop = 0; @@ -313,7 +319,8 @@ static int Start(pSICSOBJ self, SConnection *pCon, pHdb par[], int nPar){ return 1; } /*---------------------------------------------------------------------------*/ -static int Restart(pSICSOBJ self, SConnection *pCon, pHdb par[], int nPar){ +static int Restart(pSICSOBJ self, SConnection *pCon, pHdb commandNode, + pHdb par[], int nPar){ pHdbQueue priv = (pHdbQueue)self->pPrivate; pHdb maxCurrent = NULL; @@ -323,17 +330,19 @@ static int Restart(pSICSOBJ self, SConnection *pCon, pHdb par[], int nPar){ NotifyHipadabaPar(maxCurrent,pCon); } - return Start(self,pCon,par,nPar); + return Start(self,pCon,commandNode,par,nPar); } /*---------------------------------------------------------------------------*/ -static int Stop(pSICSOBJ self, SConnection *pCon, pHdb par[], int nPar){ +static int Stop(pSICSOBJ self, SConnection *pCon, pHdb commandNode, + pHdb par[], int nPar){ pHdbQueue priv = (pHdbQueue)self->pPrivate; priv->iStop = 1; return 1; } /*----------------------------------------------------------------------------*/ -static int Move(pSICSOBJ self, SConnection *pCon, pHdb par[], int nPar){ +static int Move(pSICSOBJ self, SConnection *pCon, pHdb commandNode, + pHdb par[], int nPar){ pHdb moveNode = NULL; pHdb insertNode = NULL; pHdb prevNode = NULL, queueNode = NULL; diff --git a/hipadaba.c b/hipadaba.c index 6dfb9a64..594e638c 100644 --- a/hipadaba.c +++ b/hipadaba.c @@ -401,7 +401,7 @@ hdbValue MakeHdbIntArray(int length, int *data){ return result; } /*-------------------------------------------------------------------------*/ -hdbValue MakeHdbFloatArrray(int length, double *data){ +hdbValue MakeHdbFloatArray(int length, double *data){ hdbValue result; result.dataType = HIPFLOATAR; @@ -411,6 +411,10 @@ hdbValue MakeHdbFloatArrray(int length, double *data){ } /*-------------------------------------------------------------------------*/ void ReleaseHdbValue(hdbValue *v){ + + if(v->doNotFree == 1){ + return; + } switch(v->dataType){ case HIPTEXT: if(v->v.text != NULL){ @@ -871,10 +875,30 @@ void InternalRemoveHipadabaCallback(pHdb root, int internalID){ } } /*=================== parameter interface ====================================*/ +static int canCopy(hdbValue *source, hdbValue *target){ + if(target->dataType == HIPINTVARAR) { + if(source->dataType == HIPINTAR || + source->dataType == HIPINTVARAR){ + return 1; + } + } + if(target->dataType == HIPFLOATVARAR) { + if(source->dataType == HIPFLOATAR || + source->dataType == HIPFLOATVARAR){ + return 1; + } + } + if(source->dataType != target->dataType){ + return 0; + } else { + return 1; + } +} +/*----------------------------------------------------------------------------*/ int copyHdbValue(hdbValue *source, hdbValue *target){ int i; - if(source->dataType != target->dataType){ + if(!canCopy(source,target)){ return 0; } diff --git a/hipadaba.h b/hipadaba.h index 4a003bbc..fdc90d56 100644 --- a/hipadaba.h +++ b/hipadaba.h @@ -52,6 +52,7 @@ typedef struct __hdbValue { int dataType; int arrayLength; + int doNotFree; union __value { int intValue; double doubleValue; diff --git a/histsim.c b/histsim.c index 5ddc574f..be6a0d79 100644 --- a/histsim.c +++ b/histsim.c @@ -204,7 +204,13 @@ int i, int iStart, int iEnd, HistInt *lData) { iSet = 2; + if(self->data->localBuffer == NULL){ + resizeBuffer(self->data); + } iSetVal = lData[0]; + if(iEnd < getHMDataLength(self->data)){ + memcpy(self->data->localBuffer+iStart,lData,(iEnd - iStart)*sizeof(HistInt)); + } return 1; } diff --git a/hkl.c b/hkl.c index 15e412e3..4351f20c 100644 --- a/hkl.c +++ b/hkl.c @@ -52,7 +52,10 @@ return 1; } fprintf(fd,"#Crystallographic Settings\n"); - fprintf(fd,"%s lambda %f\n",name, self->fLambda); + if(self->iManual == 1) + { + fprintf(fd,"%s lambda %f\n",name, self->fLambda); + } fprintf(fd, "%s setub %8.6f %8.6f %8.6f %8.6f %8.6f %8.6f %8.6f %8.6f %8.6f\n", name, diff --git a/lld_blob.c b/lld_blob.c index 1db5bafc..99e560bb 100644 --- a/lld_blob.c +++ b/lld_blob.c @@ -28,6 +28,21 @@ int LLDblobCreate( void ) return LLDcreate( sizeof( struct BlobDesc )); } +/*---------------------------------------------------------------------*/ +int LLDdeleteBlob(int List) +{ + struct BlobDesc Blob ; + int status; + + status = LLDnodePtr2First(List); + while(status == 1){ + LLDnodeDataTo( List, & Blob ); + free(Blob.data); + status = LLDnodePtr2Next(List); + } + LLDdelete(List); + return 1; +} /* ---- LL blob node mangement ---------------------------------------- */ int LLDblobInsert( int List, void * Source, unsigned Size ) diff --git a/lld_blob.h b/lld_blob.h index 56386eb8..56ceab06 100644 --- a/lld_blob.h +++ b/lld_blob.h @@ -20,7 +20,8 @@ int LLDblobCreate( void ); /* returns list number to use or -1 on failure. */ /* MUST be called before using a list of blobs. */ - +int LLDdeleteBlob(int List); + /* deletes a list and all its data */ /* ---- Node management -------------------------------------------------- Functions changing current node pointer to the new node. A return value of -1 indicates a memory allocation problem. diff --git a/macro.c b/macro.c index ced502fe..81837df4 100644 --- a/macro.c +++ b/macro.c @@ -70,6 +70,7 @@ #include "servlog.h" #include "stringdict.h" #include "exeman.h" +#include "nxcopy.h" #define SICSERROR "005567SICS" /*---------------------------------------------------------------------------- @@ -301,7 +302,8 @@ static int ProtectedExec(ClientData clientData, Tcl_Interp *interp, /*-------------------------------------------------------------------------- initialises a Tcl-Interpreter, installs SICS unknown mechanism and kills a few dangerous commands from the normal Tcl command set -*/ +----------------------------------------------------------------------------*/ +extern int Nxinter_SafeInit(Tcl_Interp *pTcl); /* from Swig NeXus Tcl interface */ Tcl_Interp *MacroInit(SicsInterp *pSics) { @@ -345,6 +347,9 @@ static int ProtectedExec(ClientData clientData, Tcl_Interp *interp, */ Tcl_CreateObjCommand(pInter,"exec",ProtectedExec,NULL,KillExec); + Nxinter_SafeInit(pInter); + NXcopy_Init(pInter); + return pInter; } /*--------------------------------------------------------------------------*/ diff --git a/make_gen b/make_gen index bf2c5708..dd40bf20 100644 --- a/make_gen +++ b/make_gen @@ -33,7 +33,8 @@ SOBJ = network.o ifile.o conman.o SCinter.o splitter.o passwd.o \ sinfox.o sicslist.o cone.o hipadaba.o sicshipadaba.o statistics.o \ moregress.o hdbcommand.o multicounter.o regresscter.o histregress.o \ sicshdbadapter.o polldriv.o sicspoll.o statemon.o hmslave.o \ - nwatch.o asyncqueue.o asyncprotocol.o sicsobj.o hdbqueue.o + nwatch.o asyncqueue.o asyncprotocol.o sicsobj.o hdbqueue.o\ + nxcopy.o nxinterhelper.o nxinter_wrap.o genericcontroller.o MOTOROBJ = motor.o simdriv.o COUNTEROBJ = countdriv.o simcter.o counter.o diff --git a/makefile_slinux b/makefile_slinux index 85f284b4..a9c11577 100644 --- a/makefile_slinux +++ b/makefile_slinux @@ -23,8 +23,8 @@ BINTARGET = bin EXTRA=nintf.o SUBLIBS = psi/libpsi.a psi/hardsup/libhlib.a matrix/libmatrix.a \ psi/tecs/libtecsl.a -LIBS = -L$(HDFROOT)/lib $(SUBLIBS) $(NILIB)\ - -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 diff --git a/multicounter.c b/multicounter.c index 97b6ea3a..674fd3c3 100644 --- a/multicounter.c +++ b/multicounter.c @@ -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 diff --git a/napi5.c b/napi5.c index 3e087125..f730d98e 100644 --- a/napi5.c +++ b/napi5.c @@ -934,7 +934,7 @@ static void killAttVID(pNexusFile5 pFile, int vid){ int rank; hsize_t myStart[H5S_MAX_RANK]; hsize_t mySize[H5S_MAX_RANK]; - hsize_t size[1],maxdims[H5S_MAX_RANK]; + hsize_t size[H5S_MAX_RANK],maxdims[H5S_MAX_RANK]; hid_t filespace,dataspace; pFile = NXI5assert (fid); @@ -948,6 +948,7 @@ static void killAttVID(pNexusFile5 pFile, int vid){ { myStart[i] = iStart[i]; mySize[i] = iSize[i]; + size[i] = iSize[i]; } iRet = H5Sget_simple_extent_dims(pFile->iCurrentS, NULL, maxdims); dataspace = H5Screate_simple (rank, mySize, NULL); diff --git a/nserver.c b/nserver.c index ad3aaaae..574063c8 100644 --- a/nserver.c +++ b/nserver.c @@ -273,6 +273,13 @@ /* install telnet port */ InstallTelnet(); + /* If the restore file has not been loaded, do so now */ + if(!hasRestored()) + { + strcpy(pBueffel,"restore"); + SCInvoke(self->dummyCon,self->pSics,pBueffel); + } + /* exit handlers need to be installed here */ atexit(StopExit); Fortify_CheckAllMemory(); diff --git a/nxcopy.c b/nxcopy.c new file mode 100644 index 00000000..116b00b1 --- /dev/null +++ b/nxcopy.c @@ -0,0 +1,294 @@ +/** + * This defines a couple of Tcl functions which allow to copy data from the + * nxdataset's returned from the swig Tcl interface to NeXus files into + * SICS data structures. + * + * copyright: see file COPYRIGHT + * + * Mark Koennecke, October 2007 + */ +#include +#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; +} diff --git a/nxcopy.h b/nxcopy.h new file mode 100644 index 00000000..539fae36 --- /dev/null +++ b/nxcopy.h @@ -0,0 +1,16 @@ +/** + * This defines a couple of Tcl functions which allow to copy data from the + * nxdataset's returned from the swig Tcl interface to NeXus files into + * SICS data structures. + * + * copyright: see file COPYRIGHT + * + * Mark Koennecke, October 2007 + */ +#ifndef NXCOPY_H_ +#define NXCOPY_H_ +#include + +int NXcopy_Init(Tcl_Interp *pTcl); + +#endif /*NXCOPY_H_*/ diff --git a/nxinter_wrap.c b/nxinter_wrap.c new file mode 100644 index 00000000..a2dda998 --- /dev/null +++ b/nxinter_wrap.c @@ -0,0 +1,3516 @@ +/* ---------------------------------------------------------------------------- + * This file was automatically generated by SWIG (http://www.swig.org). + * Version 1.3.31 + * + * This file is not intended to be easily readable and contains a number of + * coding conventions designed to improve portability and efficiency. Do not make + * changes to this file unless you know what you are doing--modify the SWIG + * interface file instead. + * ----------------------------------------------------------------------------- */ + +/* ----------------------------------------------------------------------------- + * This section contains generic SWIG labels for method/variable + * declarations/attributes, and other compiler dependent labels. + * ----------------------------------------------------------------------------- */ + +/* template workaround for compilers that cannot correctly implement the C++ standard */ +#ifndef SWIGTEMPLATEDISAMBIGUATOR +# if defined(__SUNPRO_CC) +# if (__SUNPRO_CC <= 0x560) +# define SWIGTEMPLATEDISAMBIGUATOR template +# else +# define SWIGTEMPLATEDISAMBIGUATOR +# endif +# else +# define SWIGTEMPLATEDISAMBIGUATOR +# endif +#endif + +/* inline attribute */ +#ifndef SWIGINLINE +# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__)) +# define SWIGINLINE inline +# else +# define SWIGINLINE +# endif +#endif + +/* attribute recognised by some compilers to avoid 'unused' warnings */ +#ifndef SWIGUNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +# elif defined(__ICC) +# define SWIGUNUSED __attribute__ ((__unused__)) +# else +# define SWIGUNUSED +# endif +#endif + +#ifndef SWIGUNUSEDPARM +# ifdef __cplusplus +# define SWIGUNUSEDPARM(p) +# else +# define SWIGUNUSEDPARM(p) p SWIGUNUSED +# endif +#endif + +/* internal SWIG method */ +#ifndef SWIGINTERN +# define SWIGINTERN static SWIGUNUSED +#endif + +/* internal inline SWIG method */ +#ifndef SWIGINTERNINLINE +# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE +#endif + +/* exporting methods */ +#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4) +# ifndef GCC_HASCLASSVISIBILITY +# define GCC_HASCLASSVISIBILITY +# endif +#endif + +#ifndef SWIGEXPORT +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# if defined(STATIC_LINKED) +# define SWIGEXPORT +# else +# define SWIGEXPORT __declspec(dllexport) +# endif +# else +# if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY) +# define SWIGEXPORT __attribute__ ((visibility("default"))) +# else +# define SWIGEXPORT +# endif +# endif +#endif + +/* calling conventions for Windows */ +#ifndef SWIGSTDCALL +# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__) +# define SWIGSTDCALL __stdcall +# else +# define SWIGSTDCALL +# endif +#endif + +/* Deal with Microsoft's attempt at deprecating C standard runtime functions */ +#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE) +# define _CRT_SECURE_NO_DEPRECATE +#endif + + +#include +#include +#include +#include +#include +#include + +/* ----------------------------------------------------------------------------- + * swigrun.swg + * + * This file contains generic CAPI SWIG runtime support for pointer + * type checking. + * ----------------------------------------------------------------------------- */ + +/* This should only be incremented when either the layout of swig_type_info changes, + or for whatever reason, the runtime changes incompatibly */ +#define SWIG_RUNTIME_VERSION "3" + +/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */ +#ifdef SWIG_TYPE_TABLE +# define SWIG_QUOTE_STRING(x) #x +# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x) +# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE) +#else +# define SWIG_TYPE_TABLE_NAME +#endif + +/* + You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for + creating a static or dynamic library from the swig runtime code. + In 99.9% of the cases, swig just needs to declare them as 'static'. + + But only do this if is strictly necessary, ie, if you have problems + with your compiler or so. +*/ + +#ifndef SWIGRUNTIME +# define SWIGRUNTIME SWIGINTERN +#endif + +#ifndef SWIGRUNTIMEINLINE +# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE +#endif + +/* Generic buffer size */ +#ifndef SWIG_BUFFER_SIZE +# define SWIG_BUFFER_SIZE 1024 +#endif + +/* Flags for pointer conversions */ +#define SWIG_POINTER_DISOWN 0x1 + +/* Flags for new pointer objects */ +#define SWIG_POINTER_OWN 0x1 + + +/* + Flags/methods for returning states. + + The swig conversion methods, as ConvertPtr, return and integer + that tells if the conversion was successful or not. And if not, + an error code can be returned (see swigerrors.swg for the codes). + + Use the following macros/flags to set or process the returning + states. + + In old swig versions, you usually write code as: + + if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) { + // success code + } else { + //fail code + } + + Now you can be more explicit as: + + int res = SWIG_ConvertPtr(obj,vptr,ty.flags); + if (SWIG_IsOK(res)) { + // success code + } else { + // fail code + } + + that seems to be the same, but now you can also do + + Type *ptr; + int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags); + if (SWIG_IsOK(res)) { + // success code + if (SWIG_IsNewObj(res) { + ... + delete *ptr; + } else { + ... + } + } else { + // fail code + } + + I.e., now SWIG_ConvertPtr can return new objects and you can + identify the case and take care of the deallocation. Of course that + requires also to SWIG_ConvertPtr to return new result values, as + + int SWIG_ConvertPtr(obj, ptr,...) { + if () { + if () { + *ptr = ; + return SWIG_NEWOBJ; + } else { + *ptr = ; + return SWIG_OLDOBJ; + } + } else { + return SWIG_BADOBJ; + } + } + + Of course, returning the plain '0(success)/-1(fail)' still works, but you can be + more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the + swig errors code. + + Finally, if the SWIG_CASTRANK_MODE is enabled, the result code + allows to return the 'cast rank', for example, if you have this + + int food(double) + int fooi(int); + + and you call + + food(1) // cast rank '1' (1 -> 1.0) + fooi(1) // cast rank '0' + + just use the SWIG_AddCast()/SWIG_CheckState() + + + */ +#define SWIG_OK (0) +#define SWIG_ERROR (-1) +#define SWIG_IsOK(r) (r >= 0) +#define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError) + +/* The CastRankLimit says how many bits are used for the cast rank */ +#define SWIG_CASTRANKLIMIT (1 << 8) +/* The NewMask denotes the object was created (using new/malloc) */ +#define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1) +/* The TmpMask is for in/out typemaps that use temporal objects */ +#define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1) +/* Simple returning values */ +#define SWIG_BADOBJ (SWIG_ERROR) +#define SWIG_OLDOBJ (SWIG_OK) +#define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK) +#define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK) +/* Check, add and del mask methods */ +#define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r) +#define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r) +#define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK)) +#define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r) +#define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r) +#define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK)) + + +/* Cast-Rank Mode */ +#if defined(SWIG_CASTRANK_MODE) +# ifndef SWIG_TypeRank +# define SWIG_TypeRank unsigned long +# endif +# ifndef SWIG_MAXCASTRANK /* Default cast allowed */ +# define SWIG_MAXCASTRANK (2) +# endif +# define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1) +# define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK) +SWIGINTERNINLINE int SWIG_AddCast(int r) { + return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r; +} +SWIGINTERNINLINE int SWIG_CheckState(int r) { + return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; +} +#else /* no cast-rank mode */ +# define SWIG_AddCast +# define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0) +#endif + + + + +#include + +#ifdef __cplusplus +extern "C" { +#endif + +typedef void *(*swig_converter_func)(void *); +typedef struct swig_type_info *(*swig_dycast_func)(void **); + +/* Structure to store inforomation on one type */ +typedef struct swig_type_info { + const char *name; /* mangled name of this type */ + const char *str; /* human readable name of this type */ + swig_dycast_func dcast; /* dynamic cast function down a hierarchy */ + struct swig_cast_info *cast; /* linked list of types that can cast into this type */ + void *clientdata; /* language specific type data */ + int owndata; /* flag if the structure owns the clientdata */ +} swig_type_info; + +/* Structure to store a type and conversion function used for casting */ +typedef struct swig_cast_info { + swig_type_info *type; /* pointer to type that is equivalent to this type */ + swig_converter_func converter; /* function to cast the void pointers */ + struct swig_cast_info *next; /* pointer to next cast in linked list */ + struct swig_cast_info *prev; /* pointer to the previous cast */ +} swig_cast_info; + +/* Structure used to store module information + * Each module generates one structure like this, and the runtime collects + * all of these structures and stores them in a circularly linked list.*/ +typedef struct swig_module_info { + swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */ + size_t size; /* Number of types in this module */ + struct swig_module_info *next; /* Pointer to next element in circularly linked list */ + swig_type_info **type_initial; /* Array of initially generated type structures */ + swig_cast_info **cast_initial; /* Array of initially generated casting structures */ + void *clientdata; /* Language specific module data */ +} swig_module_info; + +/* + Compare two type names skipping the space characters, therefore + "char*" == "char *" and "Class" == "Class", etc. + + Return 0 when the two name types are equivalent, as in + strncmp, but skipping ' '. +*/ +SWIGRUNTIME int +SWIG_TypeNameComp(const char *f1, const char *l1, + const char *f2, const char *l2) { + for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) { + while ((*f1 == ' ') && (f1 != l1)) ++f1; + while ((*f2 == ' ') && (f2 != l2)) ++f2; + if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1; + } + return (l1 - f1) - (l2 - f2); +} + +/* + Check type equivalence in a name list like ||... + Return 0 if not equal, 1 if equal +*/ +SWIGRUNTIME int +SWIG_TypeEquiv(const char *nb, const char *tb) { + int equiv = 0; + const char* te = tb + strlen(tb); + const char* ne = nb; + while (!equiv && *ne) { + for (nb = ne; *ne; ++ne) { + if (*ne == '|') break; + } + equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0; + if (*ne) ++ne; + } + return equiv; +} + +/* + Check type equivalence in a name list like ||... + Return 0 if equal, -1 if nb < tb, 1 if nb > tb +*/ +SWIGRUNTIME int +SWIG_TypeCompare(const char *nb, const char *tb) { + int equiv = 0; + const char* te = tb + strlen(tb); + const char* ne = nb; + while (!equiv && *ne) { + for (nb = ne; *ne; ++ne) { + if (*ne == '|') break; + } + equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0; + if (*ne) ++ne; + } + return equiv; +} + + +/* think of this as a c++ template<> or a scheme macro */ +#define SWIG_TypeCheck_Template(comparison, ty) \ + if (ty) { \ + swig_cast_info *iter = ty->cast; \ + while (iter) { \ + if (comparison) { \ + if (iter == ty->cast) return iter; \ + /* Move iter to the top of the linked list */ \ + iter->prev->next = iter->next; \ + if (iter->next) \ + iter->next->prev = iter->prev; \ + iter->next = ty->cast; \ + iter->prev = 0; \ + if (ty->cast) ty->cast->prev = iter; \ + ty->cast = iter; \ + return iter; \ + } \ + iter = iter->next; \ + } \ + } \ + return 0 + +/* + Check the typename +*/ +SWIGRUNTIME swig_cast_info * +SWIG_TypeCheck(const char *c, swig_type_info *ty) { + SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty); +} + +/* Same as previous function, except strcmp is replaced with a pointer comparison */ +SWIGRUNTIME swig_cast_info * +SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) { + SWIG_TypeCheck_Template(iter->type == from, into); +} + +/* + Cast a pointer up an inheritance hierarchy +*/ +SWIGRUNTIMEINLINE void * +SWIG_TypeCast(swig_cast_info *ty, void *ptr) { + return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr); +} + +/* + Dynamic pointer casting. Down an inheritance hierarchy +*/ +SWIGRUNTIME swig_type_info * +SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) { + swig_type_info *lastty = ty; + if (!ty || !ty->dcast) return ty; + while (ty && (ty->dcast)) { + ty = (*ty->dcast)(ptr); + if (ty) lastty = ty; + } + return lastty; +} + +/* + Return the name associated with this type +*/ +SWIGRUNTIMEINLINE const char * +SWIG_TypeName(const swig_type_info *ty) { + return ty->name; +} + +/* + Return the pretty name associated with this type, + that is an unmangled type name in a form presentable to the user. +*/ +SWIGRUNTIME const char * +SWIG_TypePrettyName(const swig_type_info *type) { + /* The "str" field contains the equivalent pretty names of the + type, separated by vertical-bar characters. We choose + to print the last name, as it is often (?) the most + specific. */ + if (!type) return NULL; + if (type->str != NULL) { + const char *last_name = type->str; + const char *s; + for (s = type->str; *s; s++) + if (*s == '|') last_name = s+1; + return last_name; + } + else + return type->name; +} + +/* + Set the clientdata field for a type +*/ +SWIGRUNTIME void +SWIG_TypeClientData(swig_type_info *ti, void *clientdata) { + swig_cast_info *cast = ti->cast; + /* if (ti->clientdata == clientdata) return; */ + ti->clientdata = clientdata; + + while (cast) { + if (!cast->converter) { + swig_type_info *tc = cast->type; + if (!tc->clientdata) { + SWIG_TypeClientData(tc, clientdata); + } + } + cast = cast->next; + } +} +SWIGRUNTIME void +SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) { + SWIG_TypeClientData(ti, clientdata); + ti->owndata = 1; +} + +/* + Search for a swig_type_info structure only by mangled name + Search is a O(log #types) + + We start searching at module start, and finish searching when start == end. + Note: if start == end at the beginning of the function, we go all the way around + the circular list. +*/ +SWIGRUNTIME swig_type_info * +SWIG_MangledTypeQueryModule(swig_module_info *start, + swig_module_info *end, + const char *name) { + swig_module_info *iter = start; + do { + if (iter->size) { + register size_t l = 0; + register size_t r = iter->size - 1; + do { + /* since l+r >= 0, we can (>> 1) instead (/ 2) */ + register size_t i = (l + r) >> 1; + const char *iname = iter->types[i]->name; + if (iname) { + register int compare = strcmp(name, iname); + if (compare == 0) { + return iter->types[i]; + } else if (compare < 0) { + if (i) { + r = i - 1; + } else { + break; + } + } else if (compare > 0) { + l = i + 1; + } + } else { + break; /* should never happen */ + } + } while (l <= r); + } + iter = iter->next; + } while (iter != end); + return 0; +} + +/* + Search for a swig_type_info structure for either a mangled name or a human readable name. + It first searches the mangled names of the types, which is a O(log #types) + If a type is not found it then searches the human readable names, which is O(#types). + + We start searching at module start, and finish searching when start == end. + Note: if start == end at the beginning of the function, we go all the way around + the circular list. +*/ +SWIGRUNTIME swig_type_info * +SWIG_TypeQueryModule(swig_module_info *start, + swig_module_info *end, + const char *name) { + /* STEP 1: Search the name field using binary search */ + swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name); + if (ret) { + return ret; + } else { + /* STEP 2: If the type hasn't been found, do a complete search + of the str field (the human readable name) */ + swig_module_info *iter = start; + do { + register size_t i = 0; + for (; i < iter->size; ++i) { + if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name))) + return iter->types[i]; + } + iter = iter->next; + } while (iter != end); + } + + /* neither found a match */ + return 0; +} + +/* + Pack binary data into a string +*/ +SWIGRUNTIME char * +SWIG_PackData(char *c, void *ptr, size_t sz) { + static const char hex[17] = "0123456789abcdef"; + register const unsigned char *u = (unsigned char *) ptr; + register const unsigned char *eu = u + sz; + for (; u != eu; ++u) { + register unsigned char uu = *u; + *(c++) = hex[(uu & 0xf0) >> 4]; + *(c++) = hex[uu & 0xf]; + } + return c; +} + +/* + Unpack binary data from a string +*/ +SWIGRUNTIME 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; +} + +/* + Pack 'void *' into a string buffer. +*/ +SWIGRUNTIME char * +SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) { + char *r = buff; + if ((2*sizeof(void *) + 2) > bsz) return 0; + *(r++) = '_'; + r = SWIG_PackData(r,&ptr,sizeof(void *)); + if (strlen(name) + 1 > (bsz - (r - buff))) return 0; + strcpy(r,name); + return buff; +} + +SWIGRUNTIME const char * +SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) { + if (*c != '_') { + if (strcmp(c,"NULL") == 0) { + *ptr = (void *) 0; + return name; + } else { + return 0; + } + } + return SWIG_UnpackData(++c,ptr,sizeof(void *)); +} + +SWIGRUNTIME char * +SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) { + char *r = buff; + size_t lname = (name ? strlen(name) : 0); + if ((2*sz + 2 + lname) > bsz) return 0; + *(r++) = '_'; + r = SWIG_PackData(r,ptr,sz); + if (lname) { + strncpy(r,name,lname+1); + } else { + *r = 0; + } + return buff; +} + +SWIGRUNTIME const char * +SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) { + if (*c != '_') { + if (strcmp(c,"NULL") == 0) { + memset(ptr,0,sz); + return name; + } else { + return 0; + } + } + return SWIG_UnpackData(++c,ptr,sz); +} + +#ifdef __cplusplus +} +#endif + +/* Errors in SWIG */ +#define SWIG_UnknownError -1 +#define SWIG_IOError -2 +#define SWIG_RuntimeError -3 +#define SWIG_IndexError -4 +#define SWIG_TypeError -5 +#define SWIG_DivisionByZero -6 +#define SWIG_OverflowError -7 +#define SWIG_SyntaxError -8 +#define SWIG_ValueError -9 +#define SWIG_SystemError -10 +#define SWIG_AttributeError -11 +#define SWIG_MemoryError -12 +#define SWIG_NullReferenceError -13 + + + +/* ----------------------------------------------------------------------------- + * error manipulation + * ----------------------------------------------------------------------------- */ + +SWIGINTERN const char* +SWIG_Tcl_ErrorType(int code) { + const char* type = 0; + switch(code) { + case SWIG_MemoryError: + type = "MemoryError"; + break; + case SWIG_IOError: + type = "IOError"; + break; + case SWIG_RuntimeError: + type = "RuntimeError"; + break; + case SWIG_IndexError: + type = "IndexError"; + break; + case SWIG_TypeError: + type = "TypeError"; + break; + case SWIG_DivisionByZero: + type = "ZeroDivisionError"; + break; + case SWIG_OverflowError: + type = "OverflowError"; + break; + case SWIG_SyntaxError: + type = "SyntaxError"; + break; + case SWIG_ValueError: + type = "ValueError"; + break; + case SWIG_SystemError: + type = "SystemError"; + break; + case SWIG_AttributeError: + type = "AttributeError"; + break; + default: + type = "RuntimeError"; + } + return type; +} + + +SWIGINTERN void +SWIG_Tcl_SetErrorObj(Tcl_Interp *interp, const char *ctype, Tcl_Obj *obj) +{ + Tcl_ResetResult(interp); + Tcl_SetObjResult(interp, obj); + Tcl_SetErrorCode(interp, "SWIG", ctype, NULL); +} + +SWIGINTERN void +SWIG_Tcl_SetErrorMsg(Tcl_Interp *interp, const char *ctype, const char *mesg) +{ + Tcl_ResetResult(interp); + Tcl_SetErrorCode(interp, "SWIG", ctype, NULL); + Tcl_AppendResult(interp, ctype, " ", mesg, NULL); + /* + Tcl_AddErrorInfo(interp, ctype); + Tcl_AddErrorInfo(interp, " "); + Tcl_AddErrorInfo(interp, mesg); + */ +} + +SWIGINTERNINLINE void +SWIG_Tcl_AddErrorMsg(Tcl_Interp *interp, const char* mesg) +{ + Tcl_AddErrorInfo(interp, mesg); +} + + + +/* ----------------------------------------------------------------------------- + * SWIG API. Portion that goes into the runtime + * ----------------------------------------------------------------------------- */ +#ifdef __cplusplus +extern "C" { +#endif + +/* ----------------------------------------------------------------------------- + * Constant declarations + * ----------------------------------------------------------------------------- */ + +/* Constant Types */ +#define SWIG_TCL_POINTER 4 +#define SWIG_TCL_BINARY 5 + +/* Constant information structure */ +typedef struct swig_const_info { + int type; + char *name; + long lvalue; + double dvalue; + void *pvalue; + swig_type_info **ptype; +} swig_const_info; + +typedef int (*swig_wrapper)(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST []); +typedef int (*swig_wrapper_func)(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST []); +typedef char *(*swig_variable_func)(ClientData, Tcl_Interp *, char *, char *, int); +typedef void (*swig_delete_func)(ClientData); + +typedef struct swig_method { + const char *name; + swig_wrapper method; +} swig_method; + +typedef struct swig_attribute { + const char *name; + swig_wrapper getmethod; + swig_wrapper setmethod; +} swig_attribute; + +typedef struct swig_class { + const char *name; + swig_type_info **type; + swig_wrapper constructor; + void (*destructor)(void *); + swig_method *methods; + swig_attribute *attributes; + struct swig_class **bases; + char **base_names; + swig_module_info *module; +} swig_class; + +typedef struct swig_instance { + Tcl_Obj *thisptr; + void *thisvalue; + swig_class *classptr; + int destroy; + Tcl_Command cmdtok; +} swig_instance; + +/* Structure for command table */ +typedef struct { + const char *name; + int (*wrapper)(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST []); + ClientData clientdata; +} swig_command_info; + +/* Structure for variable linking table */ +typedef struct { + const char *name; + void *addr; + char * (*get)(ClientData, Tcl_Interp *, char *, char *, int); + char * (*set)(ClientData, Tcl_Interp *, char *, char *, int); +} swig_var_info; + + +/* -----------------------------------------------------------------------------* + * Install a constant object + * -----------------------------------------------------------------------------*/ + +static Tcl_HashTable swigconstTable; +static int swigconstTableinit = 0; + +SWIGINTERN void +SWIG_Tcl_SetConstantObj(Tcl_Interp *interp, const char* name, Tcl_Obj *obj) { + int newobj; + Tcl_ObjSetVar2(interp,Tcl_NewStringObj(name,-1), NULL, obj, TCL_GLOBAL_ONLY); + Tcl_SetHashValue(Tcl_CreateHashEntry(&swigconstTable, name, &newobj), (ClientData) obj); +} + +SWIGINTERN Tcl_Obj * +SWIG_Tcl_GetConstantObj(const char *key) { + Tcl_HashEntry *entryPtr; + if (!swigconstTableinit) return 0; + entryPtr = Tcl_FindHashEntry(&swigconstTable, key); + if (entryPtr) { + return (Tcl_Obj *) Tcl_GetHashValue(entryPtr); + } + return 0; +} + +#ifdef __cplusplus +} +#endif + + + +/* ----------------------------------------------------------------------------- + * See the LICENSE file for information on copyright, usage and redistribution + * of SWIG, and the README file for authors - http://www.swig.org/release.html. + * + * tclrun.swg + * + * This file contains the runtime support for Tcl modules and includes + * code for managing global variables and pointer type checking. + * ----------------------------------------------------------------------------- */ + +/* Common SWIG API */ + +/* for raw pointers */ +#define SWIG_ConvertPtr(oc, ptr, ty, flags) SWIG_Tcl_ConvertPtr(interp, oc, ptr, ty, flags) +#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Tcl_NewPointerObj(ptr, type, flags) + +/* for raw packed data */ +#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Tcl_ConvertPacked(interp, obj, ptr, sz, ty) +#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Tcl_NewPackedObj(ptr, sz, type) + +/* for class or struct pointers */ +#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_Tcl_ConvertPtr(interp, obj, pptr, type, flags) +#define SWIG_NewInstanceObj(thisvalue, type, flags) SWIG_Tcl_NewInstanceObj(interp, thisvalue, type, flags) + +/* for C or C++ function pointers */ +#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Tcl_ConvertPtr(interp, obj, pptr, type, 0) +#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Tcl_NewPointerObj(ptr, type, 0) + +/* for C++ member pointers, ie, member methods */ +#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Tcl_ConvertPacked(interp,obj, ptr, sz, ty) +#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Tcl_NewPackedObj(ptr, sz, type) + + +/* Runtime API */ + +#define SWIG_GetModule(clientdata) SWIG_Tcl_GetModule((Tcl_Interp *) (clientdata)) +#define SWIG_SetModule(clientdata, pointer) SWIG_Tcl_SetModule((Tcl_Interp *) (clientdata), pointer) + + +/* Error manipulation */ + +#define SWIG_ErrorType(code) SWIG_Tcl_ErrorType(code) +#define SWIG_Error(code, msg) SWIG_Tcl_SetErrorMsg(interp, SWIG_Tcl_ErrorType(code), msg) +#define SWIG_fail goto fail + + +/* Tcl-specific SWIG API */ + +#define SWIG_Acquire(ptr) SWIG_Tcl_Acquire(ptr) +#define SWIG_MethodCommand SWIG_Tcl_MethodCommand +#define SWIG_Disown(ptr) SWIG_Tcl_Disown(ptr) +#define SWIG_ConvertPtrFromString(c, ptr, ty, flags) SWIG_Tcl_ConvertPtrFromString(interp, c, ptr, ty, flags) +#define SWIG_MakePtr(c, ptr, ty, flags) SWIG_Tcl_MakePtr(c, ptr, ty, flags) +#define SWIG_PointerTypeFromString(c) SWIG_Tcl_PointerTypeFromString(c) +#define SWIG_GetArgs SWIG_Tcl_GetArgs +#define SWIG_GetConstantObj(key) SWIG_Tcl_GetConstantObj(key) +#define SWIG_ObjectConstructor SWIG_Tcl_ObjectConstructor +#define SWIG_Thisown(ptr) SWIG_Tcl_Thisown(ptr) +#define SWIG_ObjectDelete SWIG_Tcl_ObjectDelete + + +#define SWIG_TCL_DECL_ARGS_2(arg1, arg2) (Tcl_Interp *interp SWIGUNUSED, arg1, arg2) +#define SWIG_TCL_CALL_ARGS_2(arg1, arg2) (interp, arg1, arg2) +/* ----------------------------------------------------------------------------- + * pointers/data manipulation + * ----------------------------------------------------------------------------- */ + +/* For backward compatibility only */ +#define SWIG_POINTER_EXCEPTION 0 +#define SWIG_GetConstant SWIG_GetConstantObj +#define SWIG_Tcl_GetConstant SWIG_Tcl_GetConstantObj + + +#ifdef __cplusplus +extern "C" { +#if 0 +} /* cc-mode */ +#endif +#endif + +/* Object support */ + +SWIGRUNTIME Tcl_HashTable* +SWIG_Tcl_ObjectTable(void) { + static Tcl_HashTable swigobjectTable; + static int swigobjectTableinit = 0; + if (!swigobjectTableinit) { + Tcl_InitHashTable(&swigobjectTable, TCL_ONE_WORD_KEYS); + swigobjectTableinit = 1; + } + return &swigobjectTable; +} + +/* Acquire ownership of a pointer */ +SWIGRUNTIME void +SWIG_Tcl_Acquire(void *ptr) { + int newobj; + Tcl_CreateHashEntry(SWIG_Tcl_ObjectTable(), (char *) ptr, &newobj); +} + +SWIGRUNTIME int +SWIG_Tcl_Thisown(void *ptr) { + if (Tcl_FindHashEntry(SWIG_Tcl_ObjectTable(), (char *) ptr)) { + return 1; + } + return 0; +} + +/* Disown a pointer. Returns 1 if we owned it to begin with */ +SWIGRUNTIME int +SWIG_Tcl_Disown(void *ptr) { + Tcl_HashEntry *entryPtr = Tcl_FindHashEntry(SWIG_Tcl_ObjectTable(), (char *) ptr); + if (entryPtr) { + Tcl_DeleteHashEntry(entryPtr); + return 1; + } + return 0; +} + +/* Convert a pointer value */ +SWIGRUNTIME int +SWIG_Tcl_ConvertPtrFromString(Tcl_Interp *interp, const char *c, void **ptr, swig_type_info *ty, int flags) { + swig_cast_info *tc; + /* Pointer values must start with leading underscore */ + while (*c != '_') { + *ptr = (void *) 0; + if (strcmp(c,"NULL") == 0) return SWIG_OK; + /* Hmmm. It could be an object name. */ + if (Tcl_VarEval(interp,c," cget -this", (char *) NULL) == TCL_OK) { + Tcl_Obj *result = Tcl_GetObjResult(interp); + c = Tcl_GetStringFromObj(result, NULL); + continue; + } + Tcl_ResetResult(interp); + return SWIG_ERROR; + } + c++; + c = SWIG_UnpackData(c,ptr,sizeof(void *)); + if (ty) { + tc = c ? SWIG_TypeCheck(c,ty) : 0; + if (!tc) { + return SWIG_ERROR; + } + if (flags & SWIG_POINTER_DISOWN) { + SWIG_Disown((void *) *ptr); + } + *ptr = SWIG_TypeCast(tc,(void *) *ptr); + } + return SWIG_OK; +} + +/* Convert a pointer value */ +SWIGRUNTIMEINLINE int +SWIG_Tcl_ConvertPtr(Tcl_Interp *interp, Tcl_Obj *oc, void **ptr, swig_type_info *ty, int flags) { + return SWIG_Tcl_ConvertPtrFromString(interp, Tcl_GetStringFromObj(oc,NULL), ptr, ty, flags); +} + +/* Convert a pointer value */ +SWIGRUNTIME char * +SWIG_Tcl_PointerTypeFromString(char *c) { + char d; + /* Pointer values must start with leading underscore. NULL has no type */ + if (*c != '_') { + return 0; + } + c++; + /* Extract hex value from pointer */ + while ((d = *c)) { + if (!(((d >= '0') && (d <= '9')) || ((d >= 'a') && (d <= 'f')))) break; + c++; + } + return c; +} + +/* Convert a packed value value */ +SWIGRUNTIME int +SWIG_Tcl_ConvertPacked(Tcl_Interp *SWIGUNUSEDPARM(interp) , Tcl_Obj *obj, void *ptr, int sz, swig_type_info *ty) { + swig_cast_info *tc; + const char *c; + + if (!obj) goto type_error; + c = Tcl_GetStringFromObj(obj,NULL); + /* Pointer values must start with leading underscore */ + if (*c != '_') goto type_error; + c++; + c = SWIG_UnpackData(c,ptr,sz); + if (ty) { + tc = SWIG_TypeCheck(c,ty); + if (!tc) goto type_error; + } + return SWIG_OK; + + type_error: + + return SWIG_ERROR; +} + + +/* Take a pointer and convert it to a string */ +SWIGRUNTIME void +SWIG_Tcl_MakePtr(char *c, void *ptr, swig_type_info *ty, int flags) { + if (ptr) { + *(c++) = '_'; + c = SWIG_PackData(c,&ptr,sizeof(void *)); + strcpy(c,ty->name); + } else { + strcpy(c,(char *)"NULL"); + } + flags = 0; +} + +/* Create a new pointer object */ +SWIGRUNTIMEINLINE Tcl_Obj * +SWIG_Tcl_NewPointerObj(void *ptr, swig_type_info *type, int flags) { + Tcl_Obj *robj; + char result[SWIG_BUFFER_SIZE]; + SWIG_MakePtr(result,ptr,type,flags); + robj = Tcl_NewStringObj(result,-1); + return robj; +} + +SWIGRUNTIME Tcl_Obj * +SWIG_Tcl_NewPackedObj(void *ptr, int sz, swig_type_info *type) { + char result[1024]; + char *r = result; + if ((2*sz + 1 + strlen(type->name)) > 1000) return 0; + *(r++) = '_'; + r = SWIG_PackData(r,ptr,sz); + strcpy(r,type->name); + return Tcl_NewStringObj(result,-1); +} + +/* -----------------------------------------------------------------------------* + * Get type list + * -----------------------------------------------------------------------------*/ + +SWIGRUNTIME swig_module_info * +SWIG_Tcl_GetModule(Tcl_Interp *interp) { + const char *data; + swig_module_info *ret = 0; + + /* first check if pointer already created */ + data = Tcl_GetVar(interp, (char *)"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, TCL_GLOBAL_ONLY); + if (data) { + SWIG_UnpackData(data, &ret, sizeof(swig_type_info **)); + } + + return ret; +} + +SWIGRUNTIME void +SWIG_Tcl_SetModule(Tcl_Interp *interp, swig_module_info *module) { + char buf[SWIG_BUFFER_SIZE]; + char *data; + + /* create a new pointer */ + data = SWIG_PackData(buf, &module, sizeof(swig_type_info **)); + *data = 0; + Tcl_SetVar(interp, (char *)"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, buf, 0); +} + +/* -----------------------------------------------------------------------------* + * Object auxiliars + * -----------------------------------------------------------------------------*/ + + +SWIGRUNTIME void +SWIG_Tcl_ObjectDelete(ClientData clientData) { + swig_instance *si = (swig_instance *) clientData; + if ((si) && (si->destroy) && (SWIG_Disown(si->thisvalue))) { + if (si->classptr->destructor) { + (si->classptr->destructor)(si->thisvalue); + } + } + Tcl_DecrRefCount(si->thisptr); + free(si); +} + +/* Function to invoke object methods given an instance */ +SWIGRUNTIME int +SWIG_Tcl_MethodCommand(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST _objv[]) { + char *method, *attrname; + swig_instance *inst = (swig_instance *) clientData; + swig_method *meth; + swig_attribute *attr; + Tcl_Obj *oldarg; + Tcl_Obj **objv; + int rcode; + swig_class *cls; + swig_class *cls_stack[64]; + int cls_stack_bi[64]; + int cls_stack_top = 0; + int numconf = 2; + int bi; + + objv = (Tcl_Obj **) _objv; + if (objc < 2) { + Tcl_SetResult(interp, (char *) "wrong # args.", TCL_STATIC); + return TCL_ERROR; + } + method = Tcl_GetStringFromObj(objv[1],NULL); + if (strcmp(method,"-acquire") == 0) { + inst->destroy = 1; + SWIG_Acquire(inst->thisvalue); + return TCL_OK; + } + if (strcmp(method,"-disown") == 0) { + if (inst->destroy) { + SWIG_Disown(inst->thisvalue); + } + inst->destroy = 0; + return TCL_OK; + } + if (strcmp(method,"-delete") == 0) { + Tcl_DeleteCommandFromToken(interp,inst->cmdtok); + return TCL_OK; + } + cls_stack[cls_stack_top] = inst->classptr; + cls_stack_bi[cls_stack_top] = -1; + cls = inst->classptr; + while (1) { + bi = cls_stack_bi[cls_stack_top]; + cls = cls_stack[cls_stack_top]; + if (bi != -1) { + if (!cls->bases[bi] && cls->base_names[bi]) { + /* lookup and cache the base class */ + swig_type_info *info = SWIG_TypeQueryModule(cls->module, cls->module, cls->base_names[bi]); + if (info) cls->bases[bi] = (swig_class *) info->clientdata; + } + cls = cls->bases[bi]; + if (cls) { + cls_stack_bi[cls_stack_top]++; + cls_stack_top++; + cls_stack[cls_stack_top] = cls; + cls_stack_bi[cls_stack_top] = -1; + continue; + } + } + if (!cls) { + cls_stack_top--; + if (cls_stack_top < 0) break; + else continue; + } + cls_stack_bi[cls_stack_top]++; + + meth = cls->methods; + /* Check for methods */ + while (meth && meth->name) { + if (strcmp(meth->name,method) == 0) { + oldarg = objv[1]; + objv[1] = inst->thisptr; + Tcl_IncrRefCount(inst->thisptr); + rcode = (*meth->method)(clientData,interp,objc,objv); + objv[1] = oldarg; + Tcl_DecrRefCount(inst->thisptr); + return rcode; + } + meth++; + } + /* Check class methods for a match */ + if (strcmp(method,"cget") == 0) { + if (objc < 3) { + Tcl_SetResult(interp, (char *) "wrong # args.", TCL_STATIC); + return TCL_ERROR; + } + attrname = Tcl_GetStringFromObj(objv[2],NULL); + attr = cls->attributes; + while (attr && attr->name) { + if ((strcmp(attr->name, attrname) == 0) && (attr->getmethod)) { + oldarg = objv[1]; + objv[1] = inst->thisptr; + Tcl_IncrRefCount(inst->thisptr); + rcode = (*attr->getmethod)(clientData,interp,2, objv); + objv[1] = oldarg; + Tcl_DecrRefCount(inst->thisptr); + return rcode; + } + attr++; + } + if (strcmp(attrname, "-this") == 0) { + Tcl_SetObjResult(interp, Tcl_DuplicateObj(inst->thisptr)); + return TCL_OK; + } + if (strcmp(attrname, "-thisown") == 0) { + if (SWIG_Thisown(inst->thisvalue)) { + Tcl_SetResult(interp,(char*)"1",TCL_STATIC); + } else { + Tcl_SetResult(interp,(char*)"0",TCL_STATIC); + } + return TCL_OK; + } + } else if (strcmp(method, "configure") == 0) { + int i; + if (objc < 4) { + Tcl_SetResult(interp, (char *) "wrong # args.", TCL_STATIC); + return TCL_ERROR; + } + i = 2; + while (i < objc) { + attrname = Tcl_GetStringFromObj(objv[i],NULL); + attr = cls->attributes; + while (attr && attr->name) { + if ((strcmp(attr->name, attrname) == 0) && (attr->setmethod)) { + oldarg = objv[i]; + objv[i] = inst->thisptr; + Tcl_IncrRefCount(inst->thisptr); + rcode = (*attr->setmethod)(clientData,interp,3, &objv[i-1]); + objv[i] = oldarg; + Tcl_DecrRefCount(inst->thisptr); + if (rcode != TCL_OK) return rcode; + numconf += 2; + } + attr++; + } + i+=2; + } + } + } + if (strcmp(method,"configure") == 0) { + if (numconf >= objc) { + return TCL_OK; + } else { + Tcl_SetResult(interp,(char *) "Invalid attribute name.", TCL_STATIC); + return TCL_ERROR; + } + } + if (strcmp(method,"cget") == 0) { + Tcl_SetResult(interp,(char *) "Invalid attribute name.", TCL_STATIC); + return TCL_ERROR; + } + Tcl_SetResult(interp, (char *) "Invalid method. Must be one of: configure cget -acquire -disown -delete", TCL_STATIC); + cls = inst->classptr; + bi = 0; + while (cls) { + meth = cls->methods; + while (meth && meth->name) { + char *cr = (char *) Tcl_GetStringResult(interp); + int meth_len = strlen(meth->name); + char* where = strchr(cr,':'); + while(where) { + where = strstr(where, meth->name); + if(where) { + if(where[-1] == ' ' && (where[meth_len] == ' ' || where[meth_len]==0)) { + break; + } else { + where++; + } + } + } + + if (!where) + Tcl_AppendElement(interp, (char *) meth->name); + meth++; + } + cls = inst->classptr->bases[bi++]; + } + return TCL_ERROR; +} + +/* This function takes the current result and turns it into an object command */ +SWIGRUNTIME Tcl_Obj * +SWIG_Tcl_NewInstanceObj(Tcl_Interp *interp, void *thisvalue, swig_type_info *type, int flags) { + Tcl_Obj *robj = SWIG_NewPointerObj(thisvalue, type,0); + /* Check to see if this pointer belongs to a class or not */ + if ((type->clientdata) && (interp)) { + Tcl_CmdInfo ci; + char *name; + name = Tcl_GetStringFromObj(robj,NULL); + if (!Tcl_GetCommandInfo(interp,name, &ci) || (flags)) { + swig_instance *newinst = (swig_instance *) malloc(sizeof(swig_instance)); + newinst->thisptr = Tcl_DuplicateObj(robj); + Tcl_IncrRefCount(newinst->thisptr); + newinst->thisvalue = thisvalue; + newinst->classptr = (swig_class *) type->clientdata; + newinst->destroy = flags; + newinst->cmdtok = Tcl_CreateObjCommand(interp, Tcl_GetStringFromObj(robj,NULL), (swig_wrapper_func) SWIG_MethodCommand, (ClientData) newinst, (swig_delete_func) SWIG_ObjectDelete); + if (flags) { + SWIG_Acquire(thisvalue); + } + } + } + return robj; +} + +/* Function to create objects */ +SWIGRUNTIME int +SWIG_Tcl_ObjectConstructor(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + Tcl_Obj *newObj = 0; + void *thisvalue = 0; + swig_instance *newinst = 0; + swig_class *classptr = (swig_class *) clientData; + swig_wrapper cons = 0; + char *name = 0; + int firstarg = 0; + int thisarg = 0; + int destroy = 1; + + if (!classptr) { + Tcl_SetResult(interp, (char *) "swig: internal runtime error. No class object defined.", TCL_STATIC); + return TCL_ERROR; + } + cons = classptr->constructor; + if (objc > 1) { + char *s = Tcl_GetStringFromObj(objv[1],NULL); + if (strcmp(s,"-this") == 0) { + thisarg = 2; + cons = 0; + } else if (strcmp(s,"-args") == 0) { + firstarg = 1; + } else if (objc == 2) { + firstarg = 1; + name = s; + } else if (objc >= 3) { + char *s1; + name = s; + s1 = Tcl_GetStringFromObj(objv[2],NULL); + if (strcmp(s1,"-this") == 0) { + thisarg = 3; + cons = 0; + } else { + firstarg = 1; + } + } + } + if (cons) { + int result; + result = (*cons)(0, interp, objc-firstarg, &objv[firstarg]); + if (result != TCL_OK) { + return result; + } + newObj = Tcl_DuplicateObj(Tcl_GetObjResult(interp)); + if (!name) name = Tcl_GetStringFromObj(newObj,NULL); + } else if (thisarg > 0) { + if (thisarg < objc) { + destroy = 0; + newObj = Tcl_DuplicateObj(objv[thisarg]); + if (!name) name = Tcl_GetStringFromObj(newObj,NULL); + } else { + Tcl_SetResult(interp, (char *) "wrong # args.", TCL_STATIC); + return TCL_ERROR; + } + } else { + Tcl_SetResult(interp, (char *) "No constructor available.", TCL_STATIC); + return TCL_ERROR; + } + if (SWIG_Tcl_ConvertPtr(interp,newObj, (void **) &thisvalue, *(classptr->type), 0) != SWIG_OK) { + Tcl_DecrRefCount(newObj); + return TCL_ERROR; + } + newinst = (swig_instance *) malloc(sizeof(swig_instance)); + newinst->thisptr = newObj; + Tcl_IncrRefCount(newObj); + newinst->thisvalue = thisvalue; + newinst->classptr = classptr; + newinst->destroy = destroy; + if (destroy) { + SWIG_Acquire(thisvalue); + } + newinst->cmdtok = Tcl_CreateObjCommand(interp,name, (swig_wrapper) SWIG_MethodCommand, (ClientData) newinst, (swig_delete_func) SWIG_ObjectDelete); + return TCL_OK; +} + +/* -----------------------------------------------------------------------------* + * Get arguments + * -----------------------------------------------------------------------------*/ +SWIGRUNTIME int +SWIG_Tcl_GetArgs(Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[], const char *fmt, ...) { + int argno = 0, opt = 0; + long tempi; + double tempd; + const char *c; + va_list ap; + void *vptr; + Tcl_Obj *obj = 0; + swig_type_info *ty; + + va_start(ap,fmt); + for (c = fmt; (*c && (*c != ':') && (*c != ';')); c++,argno++) { + if (*c == '|') { + opt = 1; + c++; + } + if (argno >= (objc-1)) { + if (!opt) { + Tcl_SetResult(interp, (char *) "Wrong number of arguments ", TCL_STATIC); + goto argerror; + } else { + va_end(ap); + return TCL_OK; + } + } + + vptr = va_arg(ap,void *); + if (vptr) { + if (isupper(*c)) { + obj = SWIG_Tcl_GetConstantObj(Tcl_GetStringFromObj(objv[argno+1],0)); + if (!obj) obj = objv[argno+1]; + } else { + obj = objv[argno+1]; + } + switch(*c) { + case 'i': case 'I': + case 'l': case 'L': + case 'h': case 'H': + case 'b': case 'B': + if (Tcl_GetLongFromObj(interp,obj,&tempi) != TCL_OK) goto argerror; + if ((*c == 'i') || (*c == 'I')) *((int *)vptr) = (int)tempi; + else if ((*c == 'l') || (*c == 'L')) *((long *)vptr) = (long)tempi; + else if ((*c == 'h') || (*c == 'H')) *((short*)vptr) = (short)tempi; + else if ((*c == 'b') || (*c == 'B')) *((unsigned char *)vptr) = (unsigned char)tempi; + break; + case 'f': case 'F': + case 'd': case 'D': + if (Tcl_GetDoubleFromObj(interp,obj,&tempd) != TCL_OK) goto argerror; + if ((*c == 'f') || (*c == 'F')) *((float *) vptr) = (float)tempd; + else if ((*c == 'd') || (*c == 'D')) *((double*) vptr) = tempd; + break; + case 's': case 'S': + if (*(c+1) == '#') { + int *vlptr = (int *) va_arg(ap, void *); + *((char **) vptr) = Tcl_GetStringFromObj(obj, vlptr); + c++; + } else { + *((char **)vptr) = Tcl_GetStringFromObj(obj,NULL); + } + break; + case 'c': case 'C': + *((char *)vptr) = *(Tcl_GetStringFromObj(obj,NULL)); + break; + case 'p': case 'P': + ty = (swig_type_info *) va_arg(ap, void *); + if (SWIG_Tcl_ConvertPtr(interp, obj, (void **) vptr, ty, 0) != SWIG_OK) goto argerror; + break; + case 'o': case 'O': + *((Tcl_Obj **)vptr) = objv[argno+1]; + break; + default: + break; + } + } + } + + if ((*c != ';') && ((objc-1) > argno)) { + Tcl_SetResult(interp, (char *) "Wrong # args.", TCL_STATIC); + goto argerror; + } + va_end(ap); + return TCL_OK; + + argerror: + { + char temp[32]; + sprintf(temp,"%d", argno+1); + c = strchr(fmt,':'); + if (!c) c = strchr(fmt,';'); + if (!c) c = (char *)""; + Tcl_AppendResult(interp,c," argument ", temp, NULL); + va_end(ap); + return TCL_ERROR; + } +} + +#ifdef __cplusplus +#if 0 +{ /* cc-mode */ +#endif +} +#endif + + + +#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0) + +#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else + + + +/* -------- TYPES TABLE (BEGIN) -------- */ + +#define SWIGTYPE_p_char swig_types[0] +#define SWIGTYPE_p_void swig_types[1] +static swig_type_info *swig_types[3]; +static swig_module_info swig_module = {swig_types, 2, 0, 0, 0, 0}; +#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name) +#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name) + +/* -------- TYPES TABLE (END) -------- */ + +#define SWIG_init Nxinter_Init +#define SWIG_name "nxinter" +#define SWIG_prefix "" +#define SWIG_version "0.0" + +#define SWIGVERSION 0x010331 +#define SWIG_VERSION SWIGVERSION + + +#define SWIG_as_voidptr(a) (void *)((const void *)(a)) +#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a)) + + + +#ifdef __cplusplus +extern "C" { +#endif +#ifdef MAC_TCL +#pragma export on +#endif +SWIGEXPORT int SWIG_init(Tcl_Interp *); +#ifdef MAC_TCL +#pragma export off +#endif +#ifdef __cplusplus +} +#endif + + + +#include "nxinterhelper.h" + + + +#include +#ifndef LLONG_MIN +# define LLONG_MIN LONG_LONG_MIN +#endif +#ifndef LLONG_MAX +# define LLONG_MAX LONG_LONG_MAX +#endif +#ifndef ULLONG_MAX +# define ULLONG_MAX ULONG_LONG_MAX +#endif + + +SWIGINTERNINLINE Tcl_Obj* +SWIG_From_long (long value) +{ + if (((long) INT_MIN <= value) && (value <= (long) INT_MAX)) { + return Tcl_NewIntObj((int)(value)); + } else { + return Tcl_NewLongObj(value); + } +} + + +SWIGINTERNINLINE Tcl_Obj * +SWIG_From_int (int value) +{ + return SWIG_From_long (value); +} + + +#include "nxdataset.h" + +#define MAXDIM 7 + +void *create_nxds(int rank, int type, int dim0, int dim1, int dim2, + int dim3, int dim4, int dim5,int dim6){ + int dim[MAXDIM],i; + + dim[0] = dim0; + dim[1] = dim1; + dim[2] = dim2; + dim[3] = dim3; + dim[4] = dim4; + dim[5] = dim5; + dim[6] = dim6; + + return createNXDataset(rank,type,dim); +} +void *create_text_nxds(char *name){ + return (void *)createTextNXDataset(name); +} + +void drop_nxds(void *ptr){ + dropNXDataset( (pNXDS) ptr); +} + +int get_nxds_rank(void *ptr){ + return getNXDatasetRank((pNXDS) ptr); +} + +int get_nxds_type(void *ptr){ + return getNXDatasetType((pNXDS) ptr); +} + +int get_nxds_dim(void *ptr, int which){ + return getNXDatasetDim((pNXDS) ptr, which); +} + +double get_nxds_value(void *ptr,int dim0, int dim1, int dim2, + int dim3, int dim4, int dim5,int dim6){ + int dim[MAXDIM]; + + dim[0] = dim0; + dim[1] = dim1; + dim[2] = dim2; + dim[3] = dim3; + dim[4] = dim4; + dim[5] = dim5; + dim[6] = dim6; + + return getNXDatasetValue((pNXDS)ptr,dim); +} + +char *get_nxds_text(void *ptr){ + return getNXDatasetText((pNXDS) ptr); +} + +int put_nxds_value(void *ptr, double value, int dim0, int dim1, int dim2, + int dim3, int dim4, int dim5,int dim6){ + int dim[MAXDIM]; + + dim[0] = dim0; + dim[1] = dim1; + dim[2] = dim2; + dim[3] = dim3; + dim[4] = dim4; + dim[5] = dim5; + dim[6] = dim6; + + return putNXDatasetValue((pNXDS)ptr,dim,value); +} + + + + +SWIGINTERN int +SWIG_AsVal_long SWIG_TCL_DECL_ARGS_2(Tcl_Obj *obj, long* val) +{ + long v; + if (Tcl_GetLongFromObj(0,obj, &v) == TCL_OK) { + if (val) *val = (long) v; + return SWIG_OK; + } + return SWIG_TypeError; +} + + +SWIGINTERN int +SWIG_AsVal_int SWIG_TCL_DECL_ARGS_2(Tcl_Obj * obj, int *val) +{ + long v; + int res = SWIG_AsVal_long SWIG_TCL_CALL_ARGS_2(obj, &v); + if (SWIG_IsOK(res)) { + if ((v < INT_MIN || v > INT_MAX)) { + return SWIG_OverflowError; + } else { + if (val) *val = (int)(v); + } + } + return res; +} + + +SWIGINTERN int +SWIG_AsCharPtrAndSize(Tcl_Obj *obj, char** cptr, size_t* psize, int *alloc) +{ + int len = 0; + char *cstr = Tcl_GetStringFromObj(obj, &len); + if (cstr) { + if (cptr) *cptr = cstr; + if (psize) *psize = len + 1; + if (alloc) *alloc = SWIG_OLDOBJ; + return SWIG_OK; + } + return SWIG_TypeError; +} + + + + + + #define SWIG_From_double Tcl_NewDoubleObj + + +SWIGINTERNINLINE Tcl_Obj * +SWIG_FromCharPtrAndSize(const char* carray, size_t size) +{ + return (size < INT_MAX) ? Tcl_NewStringObj(carray, (int)(size)) : NULL; +} + + +SWIGINTERNINLINE Tcl_Obj * +SWIG_FromCharPtr(const char *cptr) +{ + return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0)); +} + + +SWIGINTERN int +SWIG_AsVal_double SWIG_TCL_DECL_ARGS_2(Tcl_Obj *obj, double *val) +{ + double v; + if (Tcl_GetDoubleFromObj(0, obj, &v) == TCL_OK) { + if (val) *val = v; + return SWIG_OK; + } + return SWIG_TypeError; +} + + +SWIGINTERN int +SWIG_AsCharArray(Tcl_Obj * obj, char *val, size_t size) +{ + char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ; + int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc); + if (SWIG_IsOK(res)) { + if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize; + if (csize <= size) { + if (val) { + if (csize) memcpy(val, cptr, csize*sizeof(char)); + if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char)); + } + if (alloc == SWIG_NEWOBJ) { + free((char*)cptr); + res = SWIG_DelNewMask(res); + } + return res; + } + if (alloc == SWIG_NEWOBJ) free((char*)cptr); + } + return SWIG_TypeError; +} + + +SWIGINTERN int +SWIG_AsVal_char SWIG_TCL_DECL_ARGS_2(Tcl_Obj * obj, char *val) +{ + int res = SWIG_AsCharArray(obj, val, 1); + if (!SWIG_IsOK(res)) { + long v; + res = SWIG_AddCast(SWIG_AsVal_long SWIG_TCL_CALL_ARGS_2(obj, &v)); + if (SWIG_IsOK(res)) { + if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) { + if (val) *val = (char)(v); + } else { + res = SWIG_OverflowError; + } + } + } + return res; +} + + + +/* A TCL_AppInit() function that lets you build a new copy + * of tclsh. + * + * The macro SWIG_init contains the name of the initialization + * function in the wrapper file. + */ + +#ifndef SWIG_RcFileName +char *SWIG_RcFileName = "~/.myapprc"; +#endif + + +#ifdef MAC_TCL +extern int MacintoshInit _ANSI_ARGS_((void)); +#endif + +int Tcl_AppInit(Tcl_Interp *interp){ + + if (Tcl_Init(interp) == TCL_ERROR) + return TCL_ERROR; + + /* Now initialize our functions */ + + if (SWIG_init(interp) == TCL_ERROR) + return TCL_ERROR; +#if TCL_MAJOR_VERSION > 7 || TCL_MAJOR_VERSION == 7 && TCL_MINOR_VERSION >= 5 + Tcl_SetVar(interp, (char *) "tcl_rcFileName",SWIG_RcFileName,TCL_GLOBAL_ONLY); +#else + tcl_RcFileName = SWIG_RcFileName; +#endif +#ifdef SWIG_RcRsrcName + Tcl_SetVar(interp, (char *) "tcl_rcRsrcName",SWIG_RcRsrcName,TCL_GLOBAL); +#endif + + return TCL_OK; +} + + +#ifdef __cplusplus +extern "C" { +#endif +SWIGINTERN int +_wrap_create_nxds(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + int arg1 ; + int arg2 ; + int arg3 = (int) 0 ; + int arg4 = (int) 0 ; + int arg5 = (int) 0 ; + int arg6 = (int) 0 ; + int arg7 = (int) 0 ; + int arg8 = (int) 0 ; + int arg9 = (int) 0 ; + void *result = 0 ; + int val1 ; + int ecode1 = 0 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + int val6 ; + int ecode6 = 0 ; + int val7 ; + int ecode7 = 0 ; + int val8 ; + int ecode8 = 0 ; + int val9 ; + int ecode9 = 0 ; + + if (SWIG_GetArgs(interp, objc, objv,"oo|ooooooo:create_nxds rank type ?dim0? ?dim1? ?dim2? ?dim3? ?dim4? ?dim5? ?dim6? ",(void *)0,(void *)0,(void *)0,(void *)0,(void *)0,(void *)0,(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail; + ecode1 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[1], &val1); + if (!SWIG_IsOK(ecode1)) { + SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "create_nxds" "', argument " "1"" of type '" "int""'"); + } + arg1 = (int)(val1); + ecode2 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[2], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "create_nxds" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + if (objc > 3) { + ecode3 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[3], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "create_nxds" "', argument " "3"" of type '" "int""'"); + } + arg3 = (int)(val3); + } + if (objc > 4) { + ecode4 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[4], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "create_nxds" "', argument " "4"" of type '" "int""'"); + } + arg4 = (int)(val4); + } + if (objc > 5) { + ecode5 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[5], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "create_nxds" "', argument " "5"" of type '" "int""'"); + } + arg5 = (int)(val5); + } + if (objc > 6) { + ecode6 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[6], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "create_nxds" "', argument " "6"" of type '" "int""'"); + } + arg6 = (int)(val6); + } + if (objc > 7) { + ecode7 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[7], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "create_nxds" "', argument " "7"" of type '" "int""'"); + } + arg7 = (int)(val7); + } + if (objc > 8) { + ecode8 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[8], &val8); + if (!SWIG_IsOK(ecode8)) { + SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "create_nxds" "', argument " "8"" of type '" "int""'"); + } + arg8 = (int)(val8); + } + if (objc > 9) { + ecode9 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[9], &val9); + if (!SWIG_IsOK(ecode9)) { + SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "create_nxds" "', argument " "9"" of type '" "int""'"); + } + arg9 = (int)(val9); + } + result = (void *)create_nxds(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_void,0)); + return TCL_OK; +fail: + return TCL_ERROR; +} + + +SWIGINTERN int +_wrap_create_text_nxds(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + char *arg1 = (char *) 0 ; + void *result = 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + + if (SWIG_GetArgs(interp, objc, objv,"o:create_text_nxds name ",(void *)0) == TCL_ERROR) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(objv[1], &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "create_text_nxds" "', argument " "1"" of type '" "char *""'"); + } + arg1 = (char *)(buf1); + result = (void *)create_text_nxds(arg1); + Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_void,0)); + if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); + return TCL_OK; +fail: + if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); + return TCL_ERROR; +} + + +SWIGINTERN int +_wrap_drop_nxds(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + void *arg1 = (void *) 0 ; + int res1 ; + + if (SWIG_GetArgs(interp, objc, objv,"o:drop_nxds ptr ",(void *)0) == TCL_ERROR) SWIG_fail; + res1 = SWIG_ConvertPtr(objv[1],SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "drop_nxds" "', argument " "1"" of type '" "void *""'"); + } + drop_nxds(arg1); + + return TCL_OK; +fail: + return TCL_ERROR; +} + + +SWIGINTERN int +_wrap_get_nxds_rank(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + void *arg1 = (void *) 0 ; + int result; + int res1 ; + + if (SWIG_GetArgs(interp, objc, objv,"o:get_nxds_rank ptr ",(void *)0) == TCL_ERROR) SWIG_fail; + res1 = SWIG_ConvertPtr(objv[1],SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_nxds_rank" "', argument " "1"" of type '" "void *""'"); + } + result = (int)get_nxds_rank(arg1); + Tcl_SetObjResult(interp,SWIG_From_int((int)(result))); + return TCL_OK; +fail: + return TCL_ERROR; +} + + +SWIGINTERN int +_wrap_get_nxds_type(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + void *arg1 = (void *) 0 ; + int result; + int res1 ; + + if (SWIG_GetArgs(interp, objc, objv,"o:get_nxds_type ptr ",(void *)0) == TCL_ERROR) SWIG_fail; + res1 = SWIG_ConvertPtr(objv[1],SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_nxds_type" "', argument " "1"" of type '" "void *""'"); + } + result = (int)get_nxds_type(arg1); + Tcl_SetObjResult(interp,SWIG_From_int((int)(result))); + return TCL_OK; +fail: + return TCL_ERROR; +} + + +SWIGINTERN int +_wrap_get_nxds_dim(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + void *arg1 = (void *) 0 ; + int arg2 ; + int result; + int res1 ; + int val2 ; + int ecode2 = 0 ; + + if (SWIG_GetArgs(interp, objc, objv,"oo:get_nxds_dim ptr which ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail; + res1 = SWIG_ConvertPtr(objv[1],SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_nxds_dim" "', argument " "1"" of type '" "void *""'"); + } + ecode2 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[2], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "get_nxds_dim" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + result = (int)get_nxds_dim(arg1,arg2); + Tcl_SetObjResult(interp,SWIG_From_int((int)(result))); + return TCL_OK; +fail: + return TCL_ERROR; +} + + +SWIGINTERN int +_wrap_get_nxds_value(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + void *arg1 = (void *) 0 ; + int arg2 = (int) 0 ; + int arg3 = (int) 0 ; + int arg4 = (int) 0 ; + int arg5 = (int) 0 ; + int arg6 = (int) 0 ; + int arg7 = (int) 0 ; + int arg8 = (int) 0 ; + double result; + int res1 ; + int val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + int val6 ; + int ecode6 = 0 ; + int val7 ; + int ecode7 = 0 ; + int val8 ; + int ecode8 = 0 ; + + if (SWIG_GetArgs(interp, objc, objv,"o|ooooooo:get_nxds_value ptr ?dim0? ?dim1? ?dim2? ?dim3? ?dim4? ?dim5? ?dim6? ",(void *)0,(void *)0,(void *)0,(void *)0,(void *)0,(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail; + res1 = SWIG_ConvertPtr(objv[1],SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_nxds_value" "', argument " "1"" of type '" "void *""'"); + } + if (objc > 2) { + ecode2 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[2], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "get_nxds_value" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + } + if (objc > 3) { + ecode3 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[3], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "get_nxds_value" "', argument " "3"" of type '" "int""'"); + } + arg3 = (int)(val3); + } + if (objc > 4) { + ecode4 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[4], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "get_nxds_value" "', argument " "4"" of type '" "int""'"); + } + arg4 = (int)(val4); + } + if (objc > 5) { + ecode5 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[5], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "get_nxds_value" "', argument " "5"" of type '" "int""'"); + } + arg5 = (int)(val5); + } + if (objc > 6) { + ecode6 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[6], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "get_nxds_value" "', argument " "6"" of type '" "int""'"); + } + arg6 = (int)(val6); + } + if (objc > 7) { + ecode7 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[7], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "get_nxds_value" "', argument " "7"" of type '" "int""'"); + } + arg7 = (int)(val7); + } + if (objc > 8) { + ecode8 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[8], &val8); + if (!SWIG_IsOK(ecode8)) { + SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "get_nxds_value" "', argument " "8"" of type '" "int""'"); + } + arg8 = (int)(val8); + } + result = (double)get_nxds_value(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8); + Tcl_SetObjResult(interp,SWIG_From_double((double)(result))); + return TCL_OK; +fail: + return TCL_ERROR; +} + + +SWIGINTERN int +_wrap_get_nxds_text(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + void *arg1 = (void *) 0 ; + char *result = 0 ; + int res1 ; + + if (SWIG_GetArgs(interp, objc, objv,"o:get_nxds_text ptr ",(void *)0) == TCL_ERROR) SWIG_fail; + res1 = SWIG_ConvertPtr(objv[1],SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "get_nxds_text" "', argument " "1"" of type '" "void *""'"); + } + result = (char *)get_nxds_text(arg1); + Tcl_SetObjResult(interp,SWIG_FromCharPtr((const char *)result)); + return TCL_OK; +fail: + return TCL_ERROR; +} + + +SWIGINTERN int +_wrap_put_nxds_value(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + void *arg1 = (void *) 0 ; + double arg2 ; + int arg3 = (int) 0 ; + int arg4 = (int) 0 ; + int arg5 = (int) 0 ; + int arg6 = (int) 0 ; + int arg7 = (int) 0 ; + int arg8 = (int) 0 ; + int arg9 = (int) 0 ; + int result; + int res1 ; + double val2 ; + int ecode2 = 0 ; + int val3 ; + int ecode3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int val5 ; + int ecode5 = 0 ; + int val6 ; + int ecode6 = 0 ; + int val7 ; + int ecode7 = 0 ; + int val8 ; + int ecode8 = 0 ; + int val9 ; + int ecode9 = 0 ; + + if (SWIG_GetArgs(interp, objc, objv,"oo|ooooooo:put_nxds_value ptr value ?dim0? ?dim1? ?dim2? ?dim3? ?dim4? ?dim5? ?dim6? ",(void *)0,(void *)0,(void *)0,(void *)0,(void *)0,(void *)0,(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail; + res1 = SWIG_ConvertPtr(objv[1],SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "put_nxds_value" "', argument " "1"" of type '" "void *""'"); + } + ecode2 = SWIG_AsVal_double SWIG_TCL_CALL_ARGS_2(objv[2], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "put_nxds_value" "', argument " "2"" of type '" "double""'"); + } + arg2 = (double)(val2); + if (objc > 3) { + ecode3 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[3], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "put_nxds_value" "', argument " "3"" of type '" "int""'"); + } + arg3 = (int)(val3); + } + if (objc > 4) { + ecode4 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[4], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "put_nxds_value" "', argument " "4"" of type '" "int""'"); + } + arg4 = (int)(val4); + } + if (objc > 5) { + ecode5 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[5], &val5); + if (!SWIG_IsOK(ecode5)) { + SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "put_nxds_value" "', argument " "5"" of type '" "int""'"); + } + arg5 = (int)(val5); + } + if (objc > 6) { + ecode6 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[6], &val6); + if (!SWIG_IsOK(ecode6)) { + SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "put_nxds_value" "', argument " "6"" of type '" "int""'"); + } + arg6 = (int)(val6); + } + if (objc > 7) { + ecode7 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[7], &val7); + if (!SWIG_IsOK(ecode7)) { + SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "put_nxds_value" "', argument " "7"" of type '" "int""'"); + } + arg7 = (int)(val7); + } + if (objc > 8) { + ecode8 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[8], &val8); + if (!SWIG_IsOK(ecode8)) { + SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "put_nxds_value" "', argument " "8"" of type '" "int""'"); + } + arg8 = (int)(val8); + } + if (objc > 9) { + ecode9 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[9], &val9); + if (!SWIG_IsOK(ecode9)) { + SWIG_exception_fail(SWIG_ArgError(ecode9), "in method '" "put_nxds_value" "', argument " "9"" of type '" "int""'"); + } + arg9 = (int)(val9); + } + result = (int)put_nxds_value(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); + Tcl_SetObjResult(interp,SWIG_From_int((int)(result))); + return TCL_OK; +fail: + return TCL_ERROR; +} + + +SWIGINTERN int +_wrap_nx_getlasterror(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + char *result = 0 ; + + if (SWIG_GetArgs(interp, objc, objv,":nx_getlasterror ") == TCL_ERROR) SWIG_fail; + result = (char *)nx_getlasterror(); + Tcl_SetObjResult(interp,SWIG_FromCharPtr((const char *)result)); + return TCL_OK; +fail: + return TCL_ERROR; +} + + +SWIGINTERN int +_wrap_nx_open(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + char *arg1 = (char *) 0 ; + int arg2 ; + void *result = 0 ; + int res1 ; + char *buf1 = 0 ; + int alloc1 = 0 ; + int val2 ; + int ecode2 = 0 ; + + if (SWIG_GetArgs(interp, objc, objv,"oo:nx_open filename accessCode ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail; + res1 = SWIG_AsCharPtrAndSize(objv[1], &buf1, NULL, &alloc1); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nx_open" "', argument " "1"" of type '" "char *""'"); + } + arg1 = (char *)(buf1); + ecode2 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[2], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "nx_open" "', argument " "2"" of type '" "int""'"); + } + arg2 = (int)(val2); + result = (void *)nx_open(arg1,arg2); + Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_void,0)); + if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); + return TCL_OK; +fail: + if (alloc1 == SWIG_NEWOBJ) free((char*)buf1); + return TCL_ERROR; +} + + +SWIGINTERN int +_wrap_nx_flush(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + void *arg1 = (void *) 0 ; + void *result = 0 ; + int res1 ; + + if (SWIG_GetArgs(interp, objc, objv,"o:nx_flush handle ",(void *)0) == TCL_ERROR) SWIG_fail; + res1 = SWIG_ConvertPtr(objv[1],SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nx_flush" "', argument " "1"" of type '" "void *""'"); + } + result = (void *)nx_flush(arg1); + Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_void,0)); + return TCL_OK; +fail: + return TCL_ERROR; +} + + +SWIGINTERN int +_wrap_nx_close(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + void *arg1 = (void *) 0 ; + int res1 ; + + if (SWIG_GetArgs(interp, objc, objv,"o:nx_close handle ",(void *)0) == TCL_ERROR) SWIG_fail; + res1 = SWIG_ConvertPtr(objv[1],SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nx_close" "', argument " "1"" of type '" "void *""'"); + } + nx_close(arg1); + + return TCL_OK; +fail: + return TCL_ERROR; +} + + +SWIGINTERN int +_wrap_nx_makegroup(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + void *arg1 = (void *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + int result; + int res1 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + + if (SWIG_GetArgs(interp, objc, objv,"ooo:nx_makegroup handle name nxclass ",(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail; + res1 = SWIG_ConvertPtr(objv[1],SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nx_makegroup" "', argument " "1"" of type '" "void *""'"); + } + res2 = SWIG_AsCharPtrAndSize(objv[2], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "nx_makegroup" "', argument " "2"" of type '" "char *""'"); + } + arg2 = (char *)(buf2); + res3 = SWIG_AsCharPtrAndSize(objv[3], &buf3, NULL, &alloc3); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "nx_makegroup" "', argument " "3"" of type '" "char *""'"); + } + arg3 = (char *)(buf3); + result = (int)nx_makegroup(arg1,arg2,arg3); + Tcl_SetObjResult(interp,SWIG_From_int((int)(result))); + if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); + if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); + return TCL_OK; +fail: + if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); + if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); + return TCL_ERROR; +} + + +SWIGINTERN int +_wrap_nx_opengroup(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + void *arg1 = (void *) 0 ; + char *arg2 = (char *) 0 ; + char *arg3 = (char *) 0 ; + int result; + int res1 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + int res3 ; + char *buf3 = 0 ; + int alloc3 = 0 ; + + if (SWIG_GetArgs(interp, objc, objv,"ooo:nx_opengroup handle name nxclass ",(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail; + res1 = SWIG_ConvertPtr(objv[1],SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nx_opengroup" "', argument " "1"" of type '" "void *""'"); + } + res2 = SWIG_AsCharPtrAndSize(objv[2], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "nx_opengroup" "', argument " "2"" of type '" "char *""'"); + } + arg2 = (char *)(buf2); + res3 = SWIG_AsCharPtrAndSize(objv[3], &buf3, NULL, &alloc3); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "nx_opengroup" "', argument " "3"" of type '" "char *""'"); + } + arg3 = (char *)(buf3); + result = (int)nx_opengroup(arg1,arg2,arg3); + Tcl_SetObjResult(interp,SWIG_From_int((int)(result))); + if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); + if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); + return TCL_OK; +fail: + if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); + if (alloc3 == SWIG_NEWOBJ) free((char*)buf3); + return TCL_ERROR; +} + + +SWIGINTERN int +_wrap_nx_openpath(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + void *arg1 = (void *) 0 ; + char *arg2 = (char *) 0 ; + int result; + int res1 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + + if (SWIG_GetArgs(interp, objc, objv,"oo:nx_openpath handle path ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail; + res1 = SWIG_ConvertPtr(objv[1],SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nx_openpath" "', argument " "1"" of type '" "void *""'"); + } + res2 = SWIG_AsCharPtrAndSize(objv[2], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "nx_openpath" "', argument " "2"" of type '" "char *""'"); + } + arg2 = (char *)(buf2); + result = (int)nx_openpath(arg1,arg2); + Tcl_SetObjResult(interp,SWIG_From_int((int)(result))); + if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); + return TCL_OK; +fail: + if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); + return TCL_ERROR; +} + + +SWIGINTERN int +_wrap_nx_opengrouppath(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + void *arg1 = (void *) 0 ; + char *arg2 = (char *) 0 ; + int result; + int res1 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + + if (SWIG_GetArgs(interp, objc, objv,"oo:nx_opengrouppath handle path ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail; + res1 = SWIG_ConvertPtr(objv[1],SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nx_opengrouppath" "', argument " "1"" of type '" "void *""'"); + } + res2 = SWIG_AsCharPtrAndSize(objv[2], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "nx_opengrouppath" "', argument " "2"" of type '" "char *""'"); + } + arg2 = (char *)(buf2); + result = (int)nx_opengrouppath(arg1,arg2); + Tcl_SetObjResult(interp,SWIG_From_int((int)(result))); + if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); + return TCL_OK; +fail: + if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); + return TCL_ERROR; +} + + +SWIGINTERN int +_wrap_nx_closegroup(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + void *arg1 = (void *) 0 ; + int result; + int res1 ; + + if (SWIG_GetArgs(interp, objc, objv,"o:nx_closegroup handle ",(void *)0) == TCL_ERROR) SWIG_fail; + res1 = SWIG_ConvertPtr(objv[1],SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nx_closegroup" "', argument " "1"" of type '" "void *""'"); + } + result = (int)nx_closegroup(arg1); + Tcl_SetObjResult(interp,SWIG_From_int((int)(result))); + return TCL_OK; +fail: + return TCL_ERROR; +} + + +SWIGINTERN int +_wrap_nx_getnextentry(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + void *arg1 = (void *) 0 ; + char arg2 ; + char *result = 0 ; + int res1 ; + char val2 ; + int ecode2 = 0 ; + + if (SWIG_GetArgs(interp, objc, objv,"oo:nx_getnextentry handle separator ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail; + res1 = SWIG_ConvertPtr(objv[1],SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nx_getnextentry" "', argument " "1"" of type '" "void *""'"); + } + ecode2 = SWIG_AsVal_char SWIG_TCL_CALL_ARGS_2(objv[2], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "nx_getnextentry" "', argument " "2"" of type '" "char""'"); + } + arg2 = (char)(val2); + result = (char *)nx_getnextentry(arg1,arg2); + Tcl_SetObjResult(interp,SWIG_FromCharPtr((const char *)result)); + return TCL_OK; +fail: + return TCL_ERROR; +} + + +SWIGINTERN int +_wrap_nx_getgroupID(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + void *arg1 = (void *) 0 ; + void *result = 0 ; + int res1 ; + + if (SWIG_GetArgs(interp, objc, objv,"o:nx_getgroupID handle ",(void *)0) == TCL_ERROR) SWIG_fail; + res1 = SWIG_ConvertPtr(objv[1],SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nx_getgroupID" "', argument " "1"" of type '" "void *""'"); + } + result = (void *)nx_getgroupID(arg1); + Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_void,0)); + return TCL_OK; +fail: + return TCL_ERROR; +} + + +SWIGINTERN int +_wrap_nx_initgroupdir(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + void *arg1 = (void *) 0 ; + int result; + int res1 ; + + if (SWIG_GetArgs(interp, objc, objv,"o:nx_initgroupdir handle ",(void *)0) == TCL_ERROR) SWIG_fail; + res1 = SWIG_ConvertPtr(objv[1],SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nx_initgroupdir" "', argument " "1"" of type '" "void *""'"); + } + result = (int)nx_initgroupdir(arg1); + Tcl_SetObjResult(interp,SWIG_From_int((int)(result))); + return TCL_OK; +fail: + return TCL_ERROR; +} + + +SWIGINTERN int +_wrap_nx_makedata(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + void *arg1 = (void *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + int arg4 ; + void *arg5 = (void *) 0 ; + int result; + int res1 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + int val3 ; + int ecode3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int res5 ; + + if (SWIG_GetArgs(interp, objc, objv,"ooooo:nx_makedata handle name rank type dimPtr ",(void *)0,(void *)0,(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail; + res1 = SWIG_ConvertPtr(objv[1],SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nx_makedata" "', argument " "1"" of type '" "void *""'"); + } + res2 = SWIG_AsCharPtrAndSize(objv[2], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "nx_makedata" "', argument " "2"" of type '" "char *""'"); + } + arg2 = (char *)(buf2); + ecode3 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[3], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "nx_makedata" "', argument " "3"" of type '" "int""'"); + } + arg3 = (int)(val3); + ecode4 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[4], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "nx_makedata" "', argument " "4"" of type '" "int""'"); + } + arg4 = (int)(val4); + res5 = SWIG_ConvertPtr(objv[5],SWIG_as_voidptrptr(&arg5), 0, 0); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "nx_makedata" "', argument " "5"" of type '" "void *""'"); + } + result = (int)nx_makedata(arg1,arg2,arg3,arg4,arg5); + Tcl_SetObjResult(interp,SWIG_From_int((int)(result))); + if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); + return TCL_OK; +fail: + if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); + return TCL_ERROR; +} + + +SWIGINTERN int +_wrap_nx_compmakedata(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + void *arg1 = (void *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + int arg4 ; + void *arg5 = (void *) 0 ; + void *arg6 = (void *) 0 ; + int result; + int res1 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + int val3 ; + int ecode3 = 0 ; + int val4 ; + int ecode4 = 0 ; + int res5 ; + int res6 ; + + if (SWIG_GetArgs(interp, objc, objv,"oooooo:nx_compmakedata handle name rank type dimPtr bufPtr ",(void *)0,(void *)0,(void *)0,(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail; + res1 = SWIG_ConvertPtr(objv[1],SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nx_compmakedata" "', argument " "1"" of type '" "void *""'"); + } + res2 = SWIG_AsCharPtrAndSize(objv[2], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "nx_compmakedata" "', argument " "2"" of type '" "char *""'"); + } + arg2 = (char *)(buf2); + ecode3 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[3], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "nx_compmakedata" "', argument " "3"" of type '" "int""'"); + } + arg3 = (int)(val3); + ecode4 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[4], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "nx_compmakedata" "', argument " "4"" of type '" "int""'"); + } + arg4 = (int)(val4); + res5 = SWIG_ConvertPtr(objv[5],SWIG_as_voidptrptr(&arg5), 0, 0); + if (!SWIG_IsOK(res5)) { + SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "nx_compmakedata" "', argument " "5"" of type '" "void *""'"); + } + res6 = SWIG_ConvertPtr(objv[6],SWIG_as_voidptrptr(&arg6), 0, 0); + if (!SWIG_IsOK(res6)) { + SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "nx_compmakedata" "', argument " "6"" of type '" "void *""'"); + } + result = (int)nx_compmakedata(arg1,arg2,arg3,arg4,arg5,arg6); + Tcl_SetObjResult(interp,SWIG_From_int((int)(result))); + if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); + return TCL_OK; +fail: + if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); + return TCL_ERROR; +} + + +SWIGINTERN int +_wrap_nx_opendata(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + void *arg1 = (void *) 0 ; + char *arg2 = (char *) 0 ; + int result; + int res1 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + + if (SWIG_GetArgs(interp, objc, objv,"oo:nx_opendata handle name ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail; + res1 = SWIG_ConvertPtr(objv[1],SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nx_opendata" "', argument " "1"" of type '" "void *""'"); + } + res2 = SWIG_AsCharPtrAndSize(objv[2], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "nx_opendata" "', argument " "2"" of type '" "char *""'"); + } + arg2 = (char *)(buf2); + result = (int)nx_opendata(arg1,arg2); + Tcl_SetObjResult(interp,SWIG_From_int((int)(result))); + if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); + return TCL_OK; +fail: + if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); + return TCL_ERROR; +} + + +SWIGINTERN int +_wrap_nx_closedata(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + void *arg1 = (void *) 0 ; + int result; + int res1 ; + + if (SWIG_GetArgs(interp, objc, objv,"o:nx_closedata handle ",(void *)0) == TCL_ERROR) SWIG_fail; + res1 = SWIG_ConvertPtr(objv[1],SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nx_closedata" "', argument " "1"" of type '" "void *""'"); + } + result = (int)nx_closedata(arg1); + Tcl_SetObjResult(interp,SWIG_From_int((int)(result))); + return TCL_OK; +fail: + return TCL_ERROR; +} + + +SWIGINTERN int +_wrap_nx_putslab(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + void *arg1 = (void *) 0 ; + void *arg2 = (void *) 0 ; + void *arg3 = (void *) 0 ; + int result; + int res1 ; + int res2 ; + int res3 ; + + if (SWIG_GetArgs(interp, objc, objv,"ooo:nx_putslab handle dataset startDim ",(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail; + res1 = SWIG_ConvertPtr(objv[1],SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nx_putslab" "', argument " "1"" of type '" "void *""'"); + } + res2 = SWIG_ConvertPtr(objv[2],SWIG_as_voidptrptr(&arg2), 0, 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "nx_putslab" "', argument " "2"" of type '" "void *""'"); + } + res3 = SWIG_ConvertPtr(objv[3],SWIG_as_voidptrptr(&arg3), 0, 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "nx_putslab" "', argument " "3"" of type '" "void *""'"); + } + result = (int)nx_putslab(arg1,arg2,arg3); + Tcl_SetObjResult(interp,SWIG_From_int((int)(result))); + return TCL_OK; +fail: + return TCL_ERROR; +} + + +SWIGINTERN int +_wrap_nx_getslab(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + void *arg1 = (void *) 0 ; + void *arg2 = (void *) 0 ; + void *arg3 = (void *) 0 ; + void *result = 0 ; + int res1 ; + int res2 ; + int res3 ; + + if (SWIG_GetArgs(interp, objc, objv,"ooo:nx_getslab handle startdim size ",(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail; + res1 = SWIG_ConvertPtr(objv[1],SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nx_getslab" "', argument " "1"" of type '" "void *""'"); + } + res2 = SWIG_ConvertPtr(objv[2],SWIG_as_voidptrptr(&arg2), 0, 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "nx_getslab" "', argument " "2"" of type '" "void *""'"); + } + res3 = SWIG_ConvertPtr(objv[3],SWIG_as_voidptrptr(&arg3), 0, 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "nx_getslab" "', argument " "3"" of type '" "void *""'"); + } + result = (void *)nx_getslab(arg1,arg2,arg3); + Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_void,0)); + return TCL_OK; +fail: + return TCL_ERROR; +} + + +SWIGINTERN int +_wrap_nx_getds(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + void *arg1 = (void *) 0 ; + char *arg2 = (char *) 0 ; + void *result = 0 ; + int res1 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + + if (SWIG_GetArgs(interp, objc, objv,"oo:nx_getds handle name ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail; + res1 = SWIG_ConvertPtr(objv[1],SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nx_getds" "', argument " "1"" of type '" "void *""'"); + } + res2 = SWIG_AsCharPtrAndSize(objv[2], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "nx_getds" "', argument " "2"" of type '" "char *""'"); + } + arg2 = (char *)(buf2); + result = (void *)nx_getds(arg1,arg2); + Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_void,0)); + if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); + return TCL_OK; +fail: + if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); + return TCL_ERROR; +} + + +SWIGINTERN int +_wrap_nx_putds(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + void *arg1 = (void *) 0 ; + char *arg2 = (char *) 0 ; + void *arg3 = (void *) 0 ; + int result; + int res1 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + int res3 ; + + if (SWIG_GetArgs(interp, objc, objv,"ooo:nx_putds handle name dataset ",(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail; + res1 = SWIG_ConvertPtr(objv[1],SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nx_putds" "', argument " "1"" of type '" "void *""'"); + } + res2 = SWIG_AsCharPtrAndSize(objv[2], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "nx_putds" "', argument " "2"" of type '" "char *""'"); + } + arg2 = (char *)(buf2); + res3 = SWIG_ConvertPtr(objv[3],SWIG_as_voidptrptr(&arg3), 0, 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "nx_putds" "', argument " "3"" of type '" "void *""'"); + } + result = (int)nx_putds(arg1,arg2,arg3); + Tcl_SetObjResult(interp,SWIG_From_int((int)(result))); + if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); + return TCL_OK; +fail: + if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); + return TCL_ERROR; +} + + +SWIGINTERN int +_wrap_nx_getdata(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + void *arg1 = (void *) 0 ; + void *result = 0 ; + int res1 ; + + if (SWIG_GetArgs(interp, objc, objv,"o:nx_getdata handle ",(void *)0) == TCL_ERROR) SWIG_fail; + res1 = SWIG_ConvertPtr(objv[1],SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nx_getdata" "', argument " "1"" of type '" "void *""'"); + } + result = (void *)nx_getdata(arg1); + Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_void,0)); + return TCL_OK; +fail: + return TCL_ERROR; +} + + +SWIGINTERN int +_wrap_nx_putdata(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + void *arg1 = (void *) 0 ; + void *arg2 = (void *) 0 ; + int result; + int res1 ; + int res2 ; + + if (SWIG_GetArgs(interp, objc, objv,"oo:nx_putdata handle dataset ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail; + res1 = SWIG_ConvertPtr(objv[1],SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nx_putdata" "', argument " "1"" of type '" "void *""'"); + } + res2 = SWIG_ConvertPtr(objv[2],SWIG_as_voidptrptr(&arg2), 0, 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "nx_putdata" "', argument " "2"" of type '" "void *""'"); + } + result = (int)nx_putdata(arg1,arg2); + Tcl_SetObjResult(interp,SWIG_From_int((int)(result))); + return TCL_OK; +fail: + return TCL_ERROR; +} + + +SWIGINTERN int +_wrap_nx_getinfo(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + void *arg1 = (void *) 0 ; + void *result = 0 ; + int res1 ; + + if (SWIG_GetArgs(interp, objc, objv,"o:nx_getinfo handle ",(void *)0) == TCL_ERROR) SWIG_fail; + res1 = SWIG_ConvertPtr(objv[1],SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nx_getinfo" "', argument " "1"" of type '" "void *""'"); + } + result = (void *)nx_getinfo(arg1); + Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_void,0)); + return TCL_OK; +fail: + return TCL_ERROR; +} + + +SWIGINTERN int +_wrap_nx_getdataID(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + void *arg1 = (void *) 0 ; + void *result = 0 ; + int res1 ; + + if (SWIG_GetArgs(interp, objc, objv,"o:nx_getdataID handle ",(void *)0) == TCL_ERROR) SWIG_fail; + res1 = SWIG_ConvertPtr(objv[1],SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nx_getdataID" "', argument " "1"" of type '" "void *""'"); + } + result = (void *)nx_getdataID(arg1); + Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_void,0)); + return TCL_OK; +fail: + return TCL_ERROR; +} + + +SWIGINTERN int +_wrap_nx_getnextattr(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + void *arg1 = (void *) 0 ; + char arg2 ; + char *result = 0 ; + int res1 ; + char val2 ; + int ecode2 = 0 ; + + if (SWIG_GetArgs(interp, objc, objv,"oo:nx_getnextattr handle separator ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail; + res1 = SWIG_ConvertPtr(objv[1],SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nx_getnextattr" "', argument " "1"" of type '" "void *""'"); + } + ecode2 = SWIG_AsVal_char SWIG_TCL_CALL_ARGS_2(objv[2], &val2); + if (!SWIG_IsOK(ecode2)) { + SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "nx_getnextattr" "', argument " "2"" of type '" "char""'"); + } + arg2 = (char)(val2); + result = (char *)nx_getnextattr(arg1,arg2); + Tcl_SetObjResult(interp,SWIG_FromCharPtr((const char *)result)); + return TCL_OK; +fail: + return TCL_ERROR; +} + + +SWIGINTERN int +_wrap_nx_putattr(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + void *arg1 = (void *) 0 ; + char *arg2 = (char *) 0 ; + void *arg3 = (void *) 0 ; + int result; + int res1 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + int res3 ; + + if (SWIG_GetArgs(interp, objc, objv,"ooo:nx_putattr handle name ds ",(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail; + res1 = SWIG_ConvertPtr(objv[1],SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nx_putattr" "', argument " "1"" of type '" "void *""'"); + } + res2 = SWIG_AsCharPtrAndSize(objv[2], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "nx_putattr" "', argument " "2"" of type '" "char *""'"); + } + arg2 = (char *)(buf2); + res3 = SWIG_ConvertPtr(objv[3],SWIG_as_voidptrptr(&arg3), 0, 0); + if (!SWIG_IsOK(res3)) { + SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "nx_putattr" "', argument " "3"" of type '" "void *""'"); + } + result = (int)nx_putattr(arg1,arg2,arg3); + Tcl_SetObjResult(interp,SWIG_From_int((int)(result))); + if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); + return TCL_OK; +fail: + if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); + return TCL_ERROR; +} + + +SWIGINTERN int +_wrap_nx_getattr(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + void *arg1 = (void *) 0 ; + char *arg2 = (char *) 0 ; + int arg3 ; + int arg4 ; + void *result = 0 ; + int res1 ; + int res2 ; + char *buf2 = 0 ; + int alloc2 = 0 ; + int val3 ; + int ecode3 = 0 ; + int val4 ; + int ecode4 = 0 ; + + if (SWIG_GetArgs(interp, objc, objv,"oooo:nx_getattr handle name type length ",(void *)0,(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail; + res1 = SWIG_ConvertPtr(objv[1],SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nx_getattr" "', argument " "1"" of type '" "void *""'"); + } + res2 = SWIG_AsCharPtrAndSize(objv[2], &buf2, NULL, &alloc2); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "nx_getattr" "', argument " "2"" of type '" "char *""'"); + } + arg2 = (char *)(buf2); + ecode3 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[3], &val3); + if (!SWIG_IsOK(ecode3)) { + SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "nx_getattr" "', argument " "3"" of type '" "int""'"); + } + arg3 = (int)(val3); + ecode4 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[4], &val4); + if (!SWIG_IsOK(ecode4)) { + SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "nx_getattr" "', argument " "4"" of type '" "int""'"); + } + arg4 = (int)(val4); + result = (void *)nx_getattr(arg1,arg2,arg3,arg4); + Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_void,0)); + if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); + return TCL_OK; +fail: + if (alloc2 == SWIG_NEWOBJ) free((char*)buf2); + return TCL_ERROR; +} + + +SWIGINTERN int +_wrap_nx_makelink(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + void *arg1 = (void *) 0 ; + void *arg2 = (void *) 0 ; + int result; + int res1 ; + int res2 ; + + if (SWIG_GetArgs(interp, objc, objv,"oo:nx_makelink handle link ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail; + res1 = SWIG_ConvertPtr(objv[1],SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nx_makelink" "', argument " "1"" of type '" "void *""'"); + } + res2 = SWIG_ConvertPtr(objv[2],SWIG_as_voidptrptr(&arg2), 0, 0); + if (!SWIG_IsOK(res2)) { + SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "nx_makelink" "', argument " "2"" of type '" "void *""'"); + } + result = (int)nx_makelink(arg1,arg2); + Tcl_SetObjResult(interp,SWIG_From_int((int)(result))); + return TCL_OK; +fail: + return TCL_ERROR; +} + + +SWIGINTERN int +_wrap_nx_opensourcegroup(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) { + void *arg1 = (void *) 0 ; + int result; + int res1 ; + + if (SWIG_GetArgs(interp, objc, objv,"o:nx_opensourcegroup handle ",(void *)0) == TCL_ERROR) SWIG_fail; + res1 = SWIG_ConvertPtr(objv[1],SWIG_as_voidptrptr(&arg1), 0, 0); + if (!SWIG_IsOK(res1)) { + SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "nx_opensourcegroup" "', argument " "1"" of type '" "void *""'"); + } + result = (int)nx_opensourcegroup(arg1); + Tcl_SetObjResult(interp,SWIG_From_int((int)(result))); + return TCL_OK; +fail: + return TCL_ERROR; +} + + + +static swig_command_info swig_commands[] = { + { SWIG_prefix "create_nxds", (swig_wrapper_func) _wrap_create_nxds, NULL}, + { SWIG_prefix "create_text_nxds", (swig_wrapper_func) _wrap_create_text_nxds, NULL}, + { SWIG_prefix "drop_nxds", (swig_wrapper_func) _wrap_drop_nxds, NULL}, + { SWIG_prefix "get_nxds_rank", (swig_wrapper_func) _wrap_get_nxds_rank, NULL}, + { SWIG_prefix "get_nxds_type", (swig_wrapper_func) _wrap_get_nxds_type, NULL}, + { SWIG_prefix "get_nxds_dim", (swig_wrapper_func) _wrap_get_nxds_dim, NULL}, + { SWIG_prefix "get_nxds_value", (swig_wrapper_func) _wrap_get_nxds_value, NULL}, + { SWIG_prefix "get_nxds_text", (swig_wrapper_func) _wrap_get_nxds_text, NULL}, + { SWIG_prefix "put_nxds_value", (swig_wrapper_func) _wrap_put_nxds_value, NULL}, + { SWIG_prefix "nx_getlasterror", (swig_wrapper_func) _wrap_nx_getlasterror, NULL}, + { SWIG_prefix "nx_open", (swig_wrapper_func) _wrap_nx_open, NULL}, + { SWIG_prefix "nx_flush", (swig_wrapper_func) _wrap_nx_flush, NULL}, + { SWIG_prefix "nx_close", (swig_wrapper_func) _wrap_nx_close, NULL}, + { SWIG_prefix "nx_makegroup", (swig_wrapper_func) _wrap_nx_makegroup, NULL}, + { SWIG_prefix "nx_opengroup", (swig_wrapper_func) _wrap_nx_opengroup, NULL}, + { SWIG_prefix "nx_openpath", (swig_wrapper_func) _wrap_nx_openpath, NULL}, + { SWIG_prefix "nx_opengrouppath", (swig_wrapper_func) _wrap_nx_opengrouppath, NULL}, + { SWIG_prefix "nx_closegroup", (swig_wrapper_func) _wrap_nx_closegroup, NULL}, + { SWIG_prefix "nx_getnextentry", (swig_wrapper_func) _wrap_nx_getnextentry, NULL}, + { SWIG_prefix "nx_getgroupID", (swig_wrapper_func) _wrap_nx_getgroupID, NULL}, + { SWIG_prefix "nx_initgroupdir", (swig_wrapper_func) _wrap_nx_initgroupdir, NULL}, + { SWIG_prefix "nx_makedata", (swig_wrapper_func) _wrap_nx_makedata, NULL}, + { SWIG_prefix "nx_compmakedata", (swig_wrapper_func) _wrap_nx_compmakedata, NULL}, + { SWIG_prefix "nx_opendata", (swig_wrapper_func) _wrap_nx_opendata, NULL}, + { SWIG_prefix "nx_closedata", (swig_wrapper_func) _wrap_nx_closedata, NULL}, + { SWIG_prefix "nx_putslab", (swig_wrapper_func) _wrap_nx_putslab, NULL}, + { SWIG_prefix "nx_getslab", (swig_wrapper_func) _wrap_nx_getslab, NULL}, + { SWIG_prefix "nx_getds", (swig_wrapper_func) _wrap_nx_getds, NULL}, + { SWIG_prefix "nx_putds", (swig_wrapper_func) _wrap_nx_putds, NULL}, + { SWIG_prefix "nx_getdata", (swig_wrapper_func) _wrap_nx_getdata, NULL}, + { SWIG_prefix "nx_putdata", (swig_wrapper_func) _wrap_nx_putdata, NULL}, + { SWIG_prefix "nx_getinfo", (swig_wrapper_func) _wrap_nx_getinfo, NULL}, + { SWIG_prefix "nx_getdataID", (swig_wrapper_func) _wrap_nx_getdataID, NULL}, + { SWIG_prefix "nx_getnextattr", (swig_wrapper_func) _wrap_nx_getnextattr, NULL}, + { SWIG_prefix "nx_putattr", (swig_wrapper_func) _wrap_nx_putattr, NULL}, + { SWIG_prefix "nx_getattr", (swig_wrapper_func) _wrap_nx_getattr, NULL}, + { SWIG_prefix "nx_makelink", (swig_wrapper_func) _wrap_nx_makelink, NULL}, + { SWIG_prefix "nx_opensourcegroup", (swig_wrapper_func) _wrap_nx_opensourcegroup, NULL}, + {0, 0, 0} +}; + +static swig_var_info swig_variables[] = { + {0,0,0,0} +}; + +static swig_const_info swig_constants[] = { + {0,0,0,0,0,0} +}; + +/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */ + +static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0}; +static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0}; + +static swig_type_info *swig_type_initial[] = { + &_swigt__p_char, + &_swigt__p_void, +}; + +static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}}; +static swig_cast_info _swigc__p_void[] = { {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}}; + +static swig_cast_info *swig_cast_initial[] = { + _swigc__p_char, + _swigc__p_void, +}; + + +/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */ + +#ifdef __cplusplus +} +#endif +/* ----------------------------------------------------------------------------- + * Type initialization: + * This problem is tough by the requirement that no dynamic + * memory is used. Also, since swig_type_info structures store pointers to + * swig_cast_info structures and swig_cast_info structures store pointers back + * to swig_type_info structures, we need some lookup code at initialization. + * The idea is that swig generates all the structures that are needed. + * The runtime then collects these partially filled structures. + * The SWIG_InitializeModule function takes these initial arrays out of + * swig_module, and does all the lookup, filling in the swig_module.types + * array with the correct data and linking the correct swig_cast_info + * structures together. + * + * The generated swig_type_info structures are assigned staticly to an initial + * array. We just loop through that array, and handle each type individually. + * First we lookup if this type has been already loaded, and if so, use the + * loaded structure instead of the generated one. Then we have to fill in the + * cast linked list. The cast data is initially stored in something like a + * two-dimensional array. Each row corresponds to a type (there are the same + * number of rows as there are in the swig_type_initial array). Each entry in + * a column is one of the swig_cast_info structures for that type. + * The cast_initial array is actually an array of arrays, because each row has + * a variable number of columns. So to actually build the cast linked list, + * we find the array of casts associated with the type, and loop through it + * adding the casts to the list. The one last trick we need to do is making + * sure the type pointer in the swig_cast_info struct is correct. + * + * First off, we lookup the cast->type name to see if it is already loaded. + * There are three cases to handle: + * 1) If the cast->type has already been loaded AND the type we are adding + * casting info to has not been loaded (it is in this module), THEN we + * replace the cast->type pointer with the type pointer that has already + * been loaded. + * 2) If BOTH types (the one we are adding casting info to, and the + * cast->type) are loaded, THEN the cast info has already been loaded by + * the previous module so we just ignore it. + * 3) Finally, if cast->type has not already been loaded, then we add that + * swig_cast_info to the linked list (because the cast->type) pointer will + * be correct. + * ----------------------------------------------------------------------------- */ + +#ifdef __cplusplus +extern "C" { +#if 0 +} /* c-mode */ +#endif +#endif + +#if 0 +#define SWIGRUNTIME_DEBUG +#endif + + +SWIGRUNTIME void +SWIG_InitializeModule(void *clientdata) { + size_t i; + swig_module_info *module_head, *iter; + int found; + + clientdata = clientdata; + + /* check to see if the circular list has been setup, if not, set it up */ + if (swig_module.next==0) { + /* Initialize the swig_module */ + swig_module.type_initial = swig_type_initial; + swig_module.cast_initial = swig_cast_initial; + swig_module.next = &swig_module; + } + + /* Try and load any already created modules */ + module_head = SWIG_GetModule(clientdata); + if (!module_head) { + /* This is the first module loaded for this interpreter */ + /* so set the swig module into the interpreter */ + SWIG_SetModule(clientdata, &swig_module); + module_head = &swig_module; + } else { + /* the interpreter has loaded a SWIG module, but has it loaded this one? */ + found=0; + iter=module_head; + do { + if (iter==&swig_module) { + found=1; + break; + } + iter=iter->next; + } while (iter!= module_head); + + /* if the is found in the list, then all is done and we may leave */ + if (found) return; + /* otherwise we must add out module into the list */ + swig_module.next = module_head->next; + module_head->next = &swig_module; + } + + /* Now work on filling in swig_module.types */ +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: size %d\n", swig_module.size); +#endif + for (i = 0; i < swig_module.size; ++i) { + swig_type_info *type = 0; + swig_type_info *ret; + swig_cast_info *cast; + +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); +#endif + + /* if there is another module already loaded */ + if (swig_module.next != &swig_module) { + type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name); + } + if (type) { + /* Overwrite clientdata field */ +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: found type %s\n", type->name); +#endif + if (swig_module.type_initial[i]->clientdata) { + type->clientdata = swig_module.type_initial[i]->clientdata; +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name); +#endif + } + } else { + type = swig_module.type_initial[i]; + } + + /* Insert casting types */ + cast = swig_module.cast_initial[i]; + while (cast->type) { + /* Don't need to add information already in the list */ + ret = 0; +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: look cast %s\n", cast->type->name); +#endif + if (swig_module.next != &swig_module) { + ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name); +#ifdef SWIGRUNTIME_DEBUG + if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name); +#endif + } + if (ret) { + if (type == swig_module.type_initial[i]) { +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: skip old type %s\n", ret->name); +#endif + cast->type = ret; + ret = 0; + } else { + /* Check for casting already in the list */ + swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type); +#ifdef SWIGRUNTIME_DEBUG + if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name); +#endif + if (!ocast) ret = 0; + } + } + + if (!ret) { +#ifdef SWIGRUNTIME_DEBUG + printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name); +#endif + if (type->cast) { + type->cast->prev = cast; + cast->next = type->cast; + } + type->cast = cast; + } + cast++; + } + /* Set entry in modules->types array equal to the type */ + swig_module.types[i] = type; + } + swig_module.types[i] = 0; + +#ifdef SWIGRUNTIME_DEBUG + printf("**** SWIG_InitializeModule: Cast List ******\n"); + for (i = 0; i < swig_module.size; ++i) { + int j = 0; + swig_cast_info *cast = swig_module.cast_initial[i]; + printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name); + while (cast->type) { + printf("SWIG_InitializeModule: cast type %s\n", cast->type->name); + cast++; + ++j; + } + printf("---- Total casts: %d\n",j); + } + printf("**** SWIG_InitializeModule: Cast List ******\n"); +#endif +} + +/* This function will propagate the clientdata field of type to +* any new swig_type_info structures that have been added into the list +* of equivalent types. It is like calling +* SWIG_TypeClientData(type, clientdata) a second time. +*/ +SWIGRUNTIME void +SWIG_PropagateClientData(void) { + size_t i; + swig_cast_info *equiv; + static int init_run = 0; + + if (init_run) return; + init_run = 1; + + for (i = 0; i < swig_module.size; i++) { + if (swig_module.types[i]->clientdata) { + equiv = swig_module.types[i]->cast; + while (equiv) { + if (!equiv->converter) { + if (equiv->type && !equiv->type->clientdata) + SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata); + } + equiv = equiv->next; + } + } + } +} + +#ifdef __cplusplus +#if 0 +{ + /* c-mode */ +#endif +} +#endif + + +#ifdef __cplusplus +extern "C" { +#endif + + /* ----------------------------------------------------------------------------- + * constants/methods manipulation + * ----------------------------------------------------------------------------- */ + + /* Install Constants */ + + SWIGINTERN void + SWIG_Tcl_InstallConstants(Tcl_Interp *interp, swig_const_info constants[]) { + int i; + Tcl_Obj *obj; + + if (!swigconstTableinit) { + Tcl_InitHashTable(&swigconstTable, TCL_STRING_KEYS); + swigconstTableinit = 1; + } + for (i = 0; constants[i].type; i++) { + switch(constants[i].type) { + case SWIG_TCL_POINTER: + obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0); + break; + case SWIG_TCL_BINARY: + obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype)); + break; + default: + obj = 0; + break; + } + if (obj) { + SWIG_Tcl_SetConstantObj(interp, constants[i].name, obj); + } + } + } + +#ifdef __cplusplus +} +#endif + +/* -----------------------------------------------------------------------------* + * Partial Init method + * -----------------------------------------------------------------------------*/ + +SWIGEXPORT int SWIG_init(Tcl_Interp *interp) { + int i; + if (interp == 0) return TCL_ERROR; +#ifdef USE_TCL_STUBS + if (Tcl_InitStubs(interp, (char*)"8.1", 0) == NULL) { + return TCL_ERROR; + } +#endif + Tcl_PkgProvide(interp, (char*)SWIG_name, (char*)SWIG_version); + +#ifdef SWIG_namespace + Tcl_Eval(interp, "namespace eval " SWIG_namespace " { }"); +#endif + + SWIG_InitializeModule((void *) interp); + SWIG_PropagateClientData(); + + for (i = 0; swig_commands[i].name; i++) { + Tcl_CreateObjCommand(interp, (char *) swig_commands[i].name, (swig_wrapper_func) swig_commands[i].wrapper, + swig_commands[i].clientdata, NULL); + } + for (i = 0; swig_variables[i].name; i++) { + Tcl_SetVar(interp, (char *) swig_variables[i].name, (char *) "", TCL_GLOBAL_ONLY); + Tcl_TraceVar(interp, (char *) swig_variables[i].name, TCL_TRACE_READS | TCL_GLOBAL_ONLY, + (Tcl_VarTraceProc *) swig_variables[i].get, (ClientData) swig_variables[i].addr); + Tcl_TraceVar(interp, (char *) swig_variables[i].name, TCL_TRACE_WRITES | TCL_GLOBAL_ONLY, + (Tcl_VarTraceProc *) swig_variables[i].set, (ClientData) swig_variables[i].addr); + } + + SWIG_Tcl_InstallConstants(interp, swig_constants); + + + SWIG_Tcl_SetConstantObj(interp, "NXACC_READ", SWIG_From_int((int)(1))); + SWIG_Tcl_SetConstantObj(interp, "NXACC_RDWR", SWIG_From_int((int)(2))); + SWIG_Tcl_SetConstantObj(interp, "NXACC_CREATE", SWIG_From_int((int)(3))); + SWIG_Tcl_SetConstantObj(interp, "NXACC_CREATE4", SWIG_From_int((int)(4))); + SWIG_Tcl_SetConstantObj(interp, "NXACC_CREATE5", SWIG_From_int((int)(5))); + SWIG_Tcl_SetConstantObj(interp, "NX_FLOAT32", SWIG_From_int((int)(5))); + SWIG_Tcl_SetConstantObj(interp, "NX_FLOAT64", SWIG_From_int((int)(6))); + SWIG_Tcl_SetConstantObj(interp, "NX_INT8", SWIG_From_int((int)(20))); + SWIG_Tcl_SetConstantObj(interp, "NX_UINT8", SWIG_From_int((int)(21))); + SWIG_Tcl_SetConstantObj(interp, "NX_BOOLEAN", SWIG_From_int((int)(21))); + SWIG_Tcl_SetConstantObj(interp, "NX_INT16", SWIG_From_int((int)(22))); + SWIG_Tcl_SetConstantObj(interp, "NX_UINT16", SWIG_From_int((int)(23))); + SWIG_Tcl_SetConstantObj(interp, "NX_INT32", SWIG_From_int((int)(24))); + SWIG_Tcl_SetConstantObj(interp, "NX_UINT32", SWIG_From_int((int)(25))); + SWIG_Tcl_SetConstantObj(interp, "NX_CHAR", SWIG_From_int((int)(4))); + return TCL_OK; +} +SWIGEXPORT int Nxinter_SafeInit(Tcl_Interp *interp) { + return SWIG_init(interp); +} + diff --git a/nxinterhelper.c b/nxinterhelper.c new file mode 100644 index 00000000..723e0adf --- /dev/null +++ b/nxinterhelper.c @@ -0,0 +1,561 @@ +/* + This is a library of support functions and data structures which can be + used in order to create interfaces between the NeXus-API and scripting + languages or data analysis systems with a native code interface. + + copyright: GPL + + Mark Koennecke, October 2002 + Mark Koennecke, November 2002 +*/ +#include +#include +#include +#include +#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; + } +} + + + diff --git a/nxinterhelper.h b/nxinterhelper.h new file mode 100644 index 00000000..7c2e280c --- /dev/null +++ b/nxinterhelper.h @@ -0,0 +1,68 @@ +/* + This is a library of support functions and data structures which can be + used in order to create interfaces between the NeXus-API and scripting + languages or data analysis systems with a native code interface. + + copyright: GPL + + Mark Koennecke, October 2002 +*/ + +#ifndef NXINTERHELPER +#define NXINTERHELPER + +#include + +/*------------- 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 + + + + + + diff --git a/ofac.c b/ofac.c index 9f83d051..9c48f7d8 100644 --- a/ofac.c +++ b/ofac.c @@ -126,6 +126,7 @@ #include "asyncprotocol.h" #include "sicsobj.h" #include "hdbqueue.h" +#include "genericcontroller.h" /*----------------------- Server options creation -------------------------*/ static int IFServerOption(SConnection *pCon, SicsInterp *pSics, void *pData, int argc, char *argv[]) @@ -231,8 +232,6 @@ AddCommand(pInter,"status", UserStatus,NULL,NULL); AddCommand(pInter,"ResetServer",ResetStatus,NULL,NULL); AddCommand(pInter,"Dir",ListObjects,NULL,NULL); - AddCommand(pInter,"Backup",BackupStatus,NULL,NULL); - AddCommand(pInter,"Restore",RestoreStatus,NULL,NULL); AddCommand(pInter,"SetInt", SetSICSInterrupt,NULL,NULL); AddCommand(pInter,"GetInt",GetSICSInterrupt,NULL,NULL); AddCommand(pInter,"SICSType",SICSType,NULL,NULL); @@ -345,6 +344,8 @@ AddCommand(pInter,"MakeAsyncQueue",AsyncQueueFactory,NULL,NULL); AddCommand(pInter,"MakeSicsObj",InstallSICSOBJ,NULL,NULL); AddCommand(pInter,"MakeHdbQueue",MakeHDBQueue,NULL,NULL); + AddCommand(pInter,"MakeGenController",GenControllerFactory,NULL,NULL); + AddCommand(pInter,"genconfigure",GenControllerConfigure,NULL,NULL); /* install site specific commands @@ -417,7 +418,8 @@ RemoveCommand(pSics,"MakeAsyncQueue"); RemoveCommand(pSics,"MakeAsyncProtocol"); RemoveCommand(pSics,"MakeSicsObject"); - RemoveCommand(pSics,"MakeHdbQueue"); + RemoveCommand(pSics,"MakeGenController"); + RemoveCommand(pSics,"genconfigure"); /* remove site specific installation commands */ @@ -459,6 +461,7 @@ } MakeExeManager(pCon,pSics,NULL,1, NULL); InitIniCommands(pSics,pServ->pTasker); + InstallBckRestore(pCon,pSics); pCon->iFiles = 0; diff --git a/polldriv.c b/polldriv.c index fcd23df9..5a852307 100644 --- a/polldriv.c +++ b/polldriv.c @@ -47,12 +47,10 @@ static int pollHdb(struct __POLLDRIV *self, SConnection *pCon){ /*-----------------------------------------------------------------------*/ static pPollDriv makeHdbDriver(SConnection *pCon, char *objectIdentifier, int argc, char *argv[]){ - pHdb root = NULL, node = NULL; + pHdb node = NULL; pPollDriv pNew = NULL; - root = GetHipadabaRoot(); - 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; diff --git a/polldriv.tc b/polldriv.tc index 2337eda8..42b82fcb 100644 --- a/polldriv.tc +++ b/polldriv.tc @@ -43,12 +43,10 @@ static int pollHdb(struct __POLLDRIV *self, SConnection *pCon){ /*-----------------------------------------------------------------------*/ static pPollDriv makeHdbDriver(SConnection *pCon, char *objectIdentifier, int argc, char *argv[]){ - pHdb root = NULL, node = NULL; + pHdb node = NULL; pPollDriv pNew = NULL; - root = GetHipadabaRoot(); - 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; diff --git a/selvar.c b/selvar.c index 492dec11..a8533910 100644 --- a/selvar.c +++ b/selvar.c @@ -163,6 +163,7 @@ static int CheckVal(void *pSelf, SConnection *pCon ) { pSelVar self = NULL; + int status; self = (pSelVar)pSelf; assert(self); @@ -173,7 +174,12 @@ self->pCon = pCon; InvokeCallBack(self->pCall, WLCHANGE, self); - return MonoCheck(self->pSel,pCon); + status = MonoCheck(self->pSel,pCon); + if(status != HWBusy) + { + InvokeCallBack(self->pCall, WLCHANGE, self); + } + return status; } /*------------------------------------------------------------------------*/ static int HaltSelVar(void *pSelf) diff --git a/sicshdbadapter.c b/sicshdbadapter.c index 76be73cc..e05afbd9 100644 --- a/sicshdbadapter.c +++ b/sicshdbadapter.c @@ -315,6 +315,7 @@ static pHdb MakeHMDataNode(pHistMem pHM, char *name){ if(node == NULL){ return NULL; } + node->value.doNotFree = 1; pCall = MakeHipadabaCallback(HMDataGetCallback,pHM,NULL,-1,-1); if(pCall == NULL){ return NULL; diff --git a/sicshipadaba.c b/sicshipadaba.c index 3798bfb4..fa127c95 100644 --- a/sicshipadaba.c +++ b/sicshipadaba.c @@ -27,7 +27,7 @@ #include #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); diff --git a/sicshipadaba.h b/sicshipadaba.h index 85c1e010..5e6e34b8 100644 --- a/sicshipadaba.h +++ b/sicshipadaba.h @@ -280,6 +280,14 @@ int SICSHdbSetPar(void *obj, SConnection *pCon, */ int isSICSHdbRO(pHdb node); /*============= common SICS Interactions ===================================*/ +/** + * locate a SICS Hdb node, thereby honouring the /sics/object/par syntax + * @param pSics, the SICS interpreter + * @param pCon A connection to report errors too + * @param path The path to locate + * @return The demanded node or NULL in case of failure + */ +pHdb locateSICSNode(SicsInterp *pSics, SConnection *pCon, char *path); /** * Install a SICS automatic notification callback on the node. This is * a default callback using the current connection with its current @@ -352,6 +360,13 @@ pDynString formatValue(hdbValue v); * @return 0 on failure, 1 on success */ int readHdbValue(hdbValue *v, char *data, char *error, int errlen); +/** + * convert from test to a Hipadaba type + * @param text The type text + * @return The converted Hipadaba type + */ +int convertHdbType(char *text); + /*================= SICS Interpreter Interface ===========================*/ /** * InstallHipadaba installs the Hipadaba commands into the SICS interpreter. diff --git a/sicsobj.c b/sicsobj.c index c862548d..b0f5db56 100644 --- a/sicsobj.c +++ b/sicsobj.c @@ -6,10 +6,15 @@ * Mark Koennecke, July 2007 */ #include +#include #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); diff --git a/sicsobj.h b/sicsobj.h index d848eed3..66889c8b 100644 --- a/sicsobj.h +++ b/sicsobj.h @@ -23,7 +23,7 @@ typedef struct { }SICSOBJ, *pSICSOBJ; /*-----------------------------------------------------------------------*/ typedef int (*SICSOBJFunc)(pSICSOBJ self, SConnection *pCon, - pHdb par[], int nPar); + pHdb commandNode, pHdb par[], int nPar); /*======================= Live & Death =================================*/ pSICSOBJ MakeSICSOBJ(char *name, char *class); void KillSICSOBJ(void *data); diff --git a/sicsstat.tcl b/sicsstat.tcl index 4dbf048e..c4461394 100644 --- a/sicsstat.tcl +++ b/sicsstat.tcl @@ -1,7 +1,60 @@ exe batchpath ./ exe syspath ./ +sample +sample setAccess 2 +title +title setAccess 2 +user +user setAccess 2 +email unknown +email setAccess 2 +address unknown +address setAccess 2 +fax unknown +fax setAccess 2 +phone unknown +phone setAccess 2 +# Motor som +som sign 1.000000 +som SoftZero 0.000000 +som SoftLowerLim -180.000000 +som SoftUpperLim 180.000000 +som Fixed -1.000000 +som InterruptMode 0.000000 +som precision 0.010000 +som ignorefault 0.000000 +som AccessCode 2.000000 +som failafter 3.000000 +som maxretry 3.000000 +som movecount 10.000000 +# Motor stt +stt sign 1.000000 +stt SoftZero 0.000000 +stt SoftLowerLim 0.000000 +stt SoftUpperLim 120.000000 +stt Fixed -1.000000 +stt InterruptMode 0.000000 +stt precision 0.010000 +stt ignorefault 0.000000 +stt AccessCode 2.000000 +stt failafter 3.000000 +stt maxretry 3.000000 +stt movecount 10.000000 +# Motor dth +dth sign 1.000000 +dth SoftZero 0.000000 +dth SoftLowerLim 0.000000 +dth SoftUpperLim 200.000000 +dth Fixed -1.000000 +dth InterruptMode 0.000000 +dth precision 0.010000 +dth ignorefault 0.000000 +dth AccessCode 2.000000 +dth failafter 3.000000 +dth maxretry 3.000000 +dth movecount 10.000000 # Counter counter -counter SetPreset 3.000000 +counter SetPreset 1000.000000 counter SetMode Timer hm CountMode timer hm preset 3.000000 diff --git a/statemon.c b/statemon.c index ad2fdedd..8141e5bf 100644 --- a/statemon.c +++ b/statemon.c @@ -320,7 +320,21 @@ int StateMonAction(SConnection *pCon, SicsInterp *pSics, void *pData, SCRegister(pCon,pSics, self->pCall,lID); SCSendOK(pCon); return 1; - } + } else if(strcmp(argv[1],"start") == 0) { + if(argc > 2){ + InvokeCallBack(self->pCall,STSTART,argv[2]); + SCSendOK(pCon); + return 1; + } + return 0; + } else if(strcmp(argv[1],"stop") == 0) { + if(argc > 2){ + InvokeCallBack(self->pCall,STEND,argv[2]); + SCSendOK(pCon); + return 1; + } + return 0; + } SCWrite(pCon,"ERROR: keyword not recognized",eError); return 0; diff --git a/status.c b/status.c index 95286395..3b64f045 100644 --- a/status.c +++ b/status.c @@ -9,6 +9,9 @@ Updated in order to prevent status floods Mark Koennecke, July 2004 + + Reworked restore to keep parameters from uninitialized devices + Mark Koennecke, November 2007 Copyright: @@ -50,6 +53,9 @@ #include "interrupt.h" #include "devexec.h" #include "sicshipadaba.h" +#include "lld_str.h" +#include "lld.h" +#include "exebuf.h" #undef VALUECHANGE #define VALUECHANGE 2 @@ -397,28 +403,116 @@ static int motorSave = 0; SCSendOK(pCon); return 1; } +/*---------------------------------------------------------------------*/ +static int restoreOccurred = 0; +int hasRestored(){ + return restoreOccurred; +} +/*---------------------------------------------------------------------------*/ +typedef struct { + pObjectDescriptor pDes; + int errList; +}RestoreObj, *pRestoreObj; +/*---------------------------------------------------------------------------*/ +static void killRestore(void *data){ + pRestoreObj self = (pRestoreObj)data; + if(self == NULL){ + return; + } + if(self->errList >= 0){ + LLDdeleteBlob(self->errList); + } + if(self->pDes != NULL){ + DeleteDescriptor(self->pDes); + } + free(self); +} +/*--------------------------------------------------------------------------*/ +static int SaveRestore(void *obj, char *name, FILE *fd){ + int status; + char buffer[1024]; + + pRestoreObj self = (pRestoreObj)obj; + if(self == NULL){ + return 0; + } + status = LLDnodePtr2First(self->errList); + while(status == 1){ + LLDstringData(self->errList,buffer); + fprintf(fd,"%s\n", buffer); + status = LLDnodePtr2Next(self->errList); + } + + return 1; +} +/*---------------------------------------------------------------------------*/ +int InstallBckRestore(SConnection *pCon, SicsInterp *pSics){ + pRestoreObj pNew = NULL; + + pNew = malloc(sizeof(RestoreObj)); + if(pNew == NULL){ + SCWrite(pCon,"ERROR: no memory to create restore object! This is SERIOUS!!!", + eError); + return 0; + } + pNew->pDes = CreateDescriptor("BckRestore"); + pNew->errList = LLDstringCreate(); + if(pNew->pDes == NULL || pNew->errList < 0){ + SCWrite(pCon,"ERROR: no memory to create restore object! This is SERIOUS!!!", + eError); + return 0; + } + pNew->pDes->SaveStatus = SaveRestore; + AddCommand(pSics,"Backup",BackupStatus,NULL,NULL); + AddCommand(pSics,"Restore",RestoreStatus,killRestore,pNew); + + return 1; +} +/*-----------------------------------------------------------------------*/ +static int listRestoreErr(pRestoreObj self, SConnection *pCon){ + char buffer[1024]; + int status; + pDynString data = NULL; + + SCStartBuffering(pCon); + status = LLDnodePtr2First(self->errList); + while(status == 1){ + LLDstringData(self->errList,buffer); + SCWrite(pCon,buffer,eValue); + status = LLDnodePtr2Next(self->errList); + } + data = SCEndBuffering(pCon); + if(data != NULL){ + SCWrite(pCon,GetCharArray(data),eValue); + } + return 1; +} /*-----------------------------------------------------------------------*/ int RestoreStatus(SConnection *pCon, SicsInterp *pSics, void *pData, int argc, char *argv[]) - { + { char pBueffel[512]; int iRights; int iRet; char *pFile = NULL; writeFunc oldWrite; + pExeBuf buffi = NULL; + pRestoreObj self = (pRestoreObj)pData; assert(pSics); assert(pCon); + assert(self != NULL); + if(argc < 2) { pFile = IFindOption(pSICSOptions,"statusfile"); if(pFile) { - sprintf(pBueffel,"FileEval %s",pFile); + sprintf(pBueffel,"%s",pFile); } else - { + { SCWrite(pCon,"ERROR: No filename given for backup, Aborted.", eError); return 0; @@ -426,16 +520,35 @@ static int motorSave = 0; } else { - sprintf(pBueffel,"FileEval %s",argv[1]); + if(strcmp(argv[1],"listerr") == 0){ + return listRestoreErr(self,pCon); + } else { + sprintf(pBueffel,"%s",argv[1]); + } } + buffi = exeBufCreate("restore"); + if(buffi == NULL){ + SCWrite(pCon,"ERROR: failed to allocate buffer for restore",eError); + return 0; + } + iRet = exeBufLoad(buffi,pBueffel); + if(iRet != 1){ + exeBufDelete(buffi); + SCWrite(pCon,"ERROR: failed open status file",eError); + return 0; + } + LLDdeleteBlob(self->errList); + self->errList = LLDstringCreate(); iRights = SCGetRights(pCon); pCon->iUserRights = usInternal; oldWrite = SCGetWriteFunc(pCon); SCSetWriteFunc(pCon,SCNotWrite); - iRet = InterpExecute(pSics,pCon,pBueffel); + iRet = exeBufProcessErrList(buffi,pSics,pCon,self->errList); + restoreOccurred = 1; SCSetWriteFunc(pCon,oldWrite); pCon->iUserRights = iRights; + exeBufDelete(buffi); /* if we do not override parameterChange here, the backup file would be overwritten after each restore... Not the right thing @@ -445,4 +558,3 @@ static int motorSave = 0; SCSendOK(pCon); return iRet; } - diff --git a/status.h b/status.h index 1d9dca09..9d00020e 100644 --- a/status.h +++ b/status.h @@ -50,11 +50,13 @@ int ResetStatus(SConnection *pCon, SicsInterp *pSics, void *pData, int argc, char *argv[]); + int InstallBckRestore(SConnection *pCon, SicsInterp *pSics); int BackupStatus(SConnection *pCon, SicsInterp *pSics, void *pData, int argc, char *argv[]); + int RestoreStatus(SConnection *pCon, SicsInterp *pSics, void *pData, int argc, char *argv[]); - + int hasRestored(); #endif diff --git a/task.c b/task.c index 235917bc..74ff28b4 100644 --- a/task.c +++ b/task.c @@ -243,7 +243,8 @@ IncrTaskPointer(self); while(self->iStop == 0) { - if((self->pCurrent != pEnd) && (self->pCurrent->iStatus == READY)) + if((self->pCurrent != pEnd) && (self->pCurrent->iStatus == READY) + && self->pCurrent != NULL) /* omit ourselves! */ { iRet = self->pCurrent->pRun(self->pCurrent->pData); diff --git a/tasub.c b/tasub.c index 0b49b0c2..7822128d 100644 --- a/tasub.c +++ b/tasub.c @@ -1158,7 +1158,7 @@ static int calcUBFromCell(ptasUB self, SConnection *pCon){ return 0; } if(mat_det(UB) < .000001){ - SCWrite(pCon,"ERROR: invalid UB matrix, check reflections",eError); + SCWrite(pCon,"ERROR: invalid UB matrix, check cell",eError); return 0; } if(self->machine.UB != NULL){ diff --git a/tclintimpl.c b/tclintimpl.c index ec3b16f5..3b340f25 100644 --- a/tclintimpl.c +++ b/tclintimpl.c @@ -136,13 +136,21 @@ int TclIntAction(SConnection *pCon, SicsInterp *pSics, void *pData, pTclInt self = NULL; char pBuffer[1024]; char *cmd; + float val; self = (pTclInt)pData; assert(self); if(argc < 2){ - sprintf(pBuffer,"ERROR: %s expects at least one argument!", argv[0]); - 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]); diff --git a/val.lis b/val.lis index 0acf2643..7b04a358 100644 --- a/val.lis +++ b/val.lis @@ -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/ \ No newline at end of file +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.