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

- Dokumentation updates

Browse Source 
- Fixed bad file generated through nuweb
- fixed problems in synchronize.c
- New file writing scheme implemented
- Changes to hkl
This commit is contained in:
cvs
2003-12-23 15:54:50 +00:00
parent 3ce5573ea7
commit fcfb569518
5 changed files with 461 additions and 276 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
conman.c
View File

@ -958,6 +958,15 @@ void SCSetWriteFunc(SConnection *self, writeFunc x)
return 0; return 0;
} }
/*
do nothing if no data
*/
if(pName == NULL || pData == NULL)
{
SCWrite(self,"ERROR: no data to write in SCWriteZiped",eError);
return 0;
}
/* initialize the compression stuff */ /* initialize the compression stuff */
compStream.zalloc = (alloc_func)NULL; compStream.zalloc = (alloc_func)NULL;
compStream.zfree = (free_func)NULL; compStream.zfree = (free_func)NULL;

228
danu.c
View File

@ -5,6 +5,11 @@
Mark Koennecke, Juli 1997 Mark Koennecke, Juli 1997
Added callbacks, stepping to next thousand
Mark Koennecke, December 2003
Copyright: Copyright:
Labor fuer Neutronenstreuung Labor fuer Neutronenstreuung
@ -38,18 +43,87 @@
#include <string.h> #include <string.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include <math.h>
#include <time.h> #include <time.h>
#include <assert.h> #include <assert.h>
#include "fortify.h" #include "fortify.h"
#include "conman.h" #include "sics.h"
#include "obdes.h"
#include "danu.h" #include "danu.h"
/* ------------------ the data structure ----------------------------------*/ /* ------------------ the data structure ----------------------------------*/
typedef struct __DataNumber { typedef struct __DataNumber {
pObjectDescriptor pDes; pObjectDescriptor pDes;
pICallBack pCall;
char *pFileName; char *pFileName;
} DataNumber; } DataNumber;
/*----------------------------------------------------------------------*/
static int readDataNumber(pDataNumber self)
{
FILE *fd = NULL;
int iNum = 0;
/* open file */
fd = fopen(self->pFileName,"r");
if(!fd)
{
return -1;
}
/* get and increment number */
fscanf(fd,"%d",&iNum);
fclose(fd);
return iNum;
}
/*-----------------------------------------------------------------------*/
static int writeDataNumber(pDataNumber self, int iNum)
{
FILE *fd = NULL;
/* reopen for rewriting */
fd = fopen(self->pFileName,"w");
if(fd == NULL)
{
return -1;
}
/* write file and leave */
fprintf(fd," %d \n",iNum);
fprintf(fd,"NEVER, EVER modify or delete this file\n");
fprintf(fd,
"You'll risk eternal damnation and a reincarnation as a cockroach!|n");
fclose(fd);
return 1;
}
/*------------------- The CallBack function for interest ------------------*/
static int InterestCallback(int iEvent, void *pEvent, void *pUser)
{
pDataNumber self = NULL;
SConnection *pCon = NULL;
char pBueffel[132];
int iNum;
if(iEvent != VALUECHANGE)
{
return 1;
}
assert(pEvent);
assert(pUser);
pCon = (SConnection *)pUser;
self = (pDataNumber)pEvent;
/*
read number
*/
iNum = readDataNumber(self);
if(iNum > 0)
{
snprintf(pBueffel,131,"sicsdatanumber = %d", iNum);
SCWrite(pCon,pBueffel,eValue);
}
return 1;
}
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
pDataNumber CreateDataNumber(char *pFileName) pDataNumber CreateDataNumber(char *pFileName)
{ {
@ -64,7 +138,8 @@
memset(pNew,0,sizeof(DataNumber)); memset(pNew,0,sizeof(DataNumber));
pNew->pDes = CreateDescriptor("DataNumber"); pNew->pDes = CreateDescriptor("DataNumber");
if(!pNew->pDes) pNew->pCall = CreateCallBackInterface();
if(!pNew->pDes || !pNew->pCall)
{ {
free(pNew); free(pNew);
return NULL; return NULL;
@ -95,6 +170,11 @@
{ {
DeleteDescriptor(self->pDes); DeleteDescriptor(self->pDes);
} }
if(self->pCall)
{
DeleteCallBackInterface(self->pCall);
self->pCall = NULL;
}
if(self->pFileName) if(self->pFileName)
{ {
free(self->pFileName); free(self->pFileName);
@ -109,71 +189,82 @@
time_t iTime; time_t iTime;
struct tm *psTime; struct tm *psTime;
/* open file */
fd = fopen(self->pFileName,"r"); iNum = readDataNumber(self);
if(!fd) if(iNum < 0)
{ {
return -1; return iNum;
} }
iNum++;
/* get and increment number */
fscanf(fd,"%d",&iNum);
iNum++;
fclose(fd);
/* reopen for rewriting */
fd = fopen(self->pFileName,"w");
if(fd == NULL)
{
return -1;
}
/* write file and leave */
fprintf(fd," %d \n",iNum);
fprintf(fd,"NEVER, EVER modify or delete this file\n");
fprintf(fd,"You'll risk eternal damnation and a reincarnation as a cockroach!|n");
fclose(fd);
/* get year */ /* get year */
iTime = time(NULL); iTime = time(NULL);
psTime = localtime(&iTime); psTime = localtime(&iTime);
*iYear = psTime->tm_year + 1900; *iYear = psTime->tm_year + 1900;
if(writeDataNumber(self,iNum) < 0)
{
return -1;
}
InvokeCallBack(self->pCall, VALUECHANGE, self);
return iNum; return iNum;
} }
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
int DecrementDataNumber(pDataNumber self) int DecrementDataNumber(pDataNumber self)
{ {
FILE *fd = NULL; FILE *fd = NULL;
int iNum; int iNum, currentThousand;
/* open file */ iNum = readDataNumber(self);
fd = fopen(self->pFileName,"r"); if(iNum < 0)
if(!fd)
{ {
return -1; return iNum;
} }
/*
/* get and decrement number */ decrement DataNumber with restrictions:
fscanf(fd,"%d",&iNum); - not at all lower 0
- do not understep a thousand boundary
*/
currentThousand = (int)floor(iNum/1000.);
iNum--; iNum--;
if(iNum < 0) if((int)floor(iNum/1000.) < currentThousand)
iNum = 0; {
fclose(fd); iNum++;
}
/* reopen for rewriting */ if(writeDataNumber(self,iNum) < 0)
fd = fopen(self->pFileName,"w"); {
return -1;
/* write file and leave */ }
fprintf(fd," %d \n",iNum);
fprintf(fd,"NEVER, EVER modify or delete this file\n");
fprintf(fd,"You'll risk eternal damnation and a reincarnation as a cockroach!|n");
fclose(fd);
return iNum; return iNum;
} }
/*------------------------------------------------------------------------*/
int NewThousand(pDataNumber self)
{
int iNum, currentThousand;
iNum = readDataNumber(self);
if(iNum < 0)
{
return iNum;
}
/* set to next thousand number */
currentThousand = (int)floor(iNum/1000.);
iNum = (currentThousand + 1)*1000;
if(writeDataNumber(self,iNum) < 0)
{
return -1;
}
return iNum;
}
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
int DNWrapper(SConnection *pCon, SicsInterp *pSics, void *pData, int DNWrapper(SConnection *pCon, SicsInterp *pSics, void *pData,
int argc, char *argv[]) int argc, char *argv[])
@ -182,6 +273,7 @@
FILE *fd = NULL; FILE *fd = NULL;
int iNum, iYear; int iNum, iYear;
char pBueffel[512]; char pBueffel[512];
long lID;
self = (pDataNumber)pData; self = (pDataNumber)pData;
assert(self); assert(self);
@ -190,18 +282,16 @@
argtolower(argc,argv); argtolower(argc,argv);
if(argc < 2) /* value request */ if(argc < 2) /* value request */
{ {
fd = fopen(self->pFileName,"r"); iNum = readDataNumber(self);
if(!fd) if(iNum < 0)
{ {
sprintf(pBueffel,"ERROR: cannot open file %s",self->pFileName); sprintf(pBueffel,"ERROR: cannot open file %s",self->pFileName);
SCWrite(pCon,pBueffel,eError); SCWrite(pCon,pBueffel,eError);
return 0; return 0;
} }
fscanf(fd,"%d",&iNum); sprintf(pBueffel,"%s = %d",argv[0],iNum);
fclose(fd); SCWrite(pCon,pBueffel,eValue);
sprintf(pBueffel,"%s = %d",argv[0],iNum); return 1;
SCWrite(pCon,pBueffel,eValue);
return 1;
} }
if(strcmp(argv[1],"incr") == 0) if(strcmp(argv[1],"incr") == 0)
@ -219,6 +309,38 @@
return 0; return 0;
} }
} }
if(strcmp(argv[1],"nextthousand") == 0)
{
if(!SCMatchRights(pCon,usMugger))
{
return 0;
}
iNum = NewThousand(self);
if(iNum > 0)
{
SCSendOK(pCon);
return 1;
}
else
{
sprintf(pBueffel,"ERROR: cannot increment %s",argv[0]);
SCWrite(pCon,pBueffel,eError);
return 0;
}
}
if(strcmp(argv[1],"interest") == 0)
{
lID = RegisterCallback(self->pCall, VALUECHANGE, InterestCallback,
pCon, NULL);
SCRegister(pCon,pSics, self->pCall,lID);
SCSendOK(pCon);
return 1;
}
if(strcmp(argv[1],"uninterest") == 0)
{
RemoveCallback2(self->pCall,pCon);
SCSendOK(pCon);
}
sprintf(pBueffel,"ERROR: unknown command %s supplied to %s", sprintf(pBueffel,"ERROR: unknown command %s supplied to %s",
argv[1], argv[0]); argv[1], argv[0]);

385
nxdict.c
View File

@ -1,5 +1,6 @@
#line 2264 "nxdict.w"
/*--------------------------------------------------------------------------- /*---------------------------------------------------------------------------
Nexus Dictionary API implementation file. Nexus Dictionary API implementation file.
@ -20,8 +21,17 @@
August, 1997 August, 1997
Version: 1.0 Version: 1.0
Version 1.1
Updated to use the combined HDF4 HDF5 API. New keyword -chunk which
defines the chunk buffer size for a SDS.
Mark Koennecke, August 2001
-----------------------------------------------------------------------------*/ -----------------------------------------------------------------------------*/
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include <assert.h> #include <assert.h>
@ -41,14 +51,13 @@
extern void *NXpData; extern void *NXpData;
extern void (*NXIReportError)(void *pData, char *pBuffer); extern void (*NXIReportError)(void *pData, char *pBuffer);
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
#define DEFDEBUG 1 /* #define DEFDEBUG 1 */
/* define DEFDEBUG when you wish to print your definition strings before /* define DEFDEBUG when you wish to print your definition strings before
action. This can help a lot to resolve mysteries when working with action. This can help a lot to resolve mysteries when working with
dictionaries. dictionaries.
*/ */
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
#line 362 "nxdict.w"
typedef struct __NXdict typedef struct __NXdict
{ {
@ -58,7 +67,6 @@
/*------------------ verbosity level -------------------------------------*/ /*------------------ verbosity level -------------------------------------*/
static int iVerbosity = 0 ; static int iVerbosity = 0 ;
#line 2311 "nxdict.w"
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
static char *NXDIReadFile(FILE *fd) static char *NXDIReadFile(FILE *fd)
@ -100,7 +108,6 @@
} }
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
#line 490 "nxdict.w"
#define FWORD 1 #define FWORD 1
#define FHASH 2 #define FHASH 2
@ -173,11 +180,9 @@
} }
#line 2351 "nxdict.w"
/*------------------------------------------------------------------------*/ /*------------------------------------------------------------------------*/
#line 566 "nxdict.w"
#define AMODE 0 #define AMODE 0
#define DMODE 1 #define DMODE 1
@ -266,7 +271,6 @@
} }
} }
#line 2353 "nxdict.w"
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
NXstatus NXDinitfromfile(char *filename, NXdict *pData) NXstatus NXDinitfromfile(char *filename, NXdict *pData)
@ -277,7 +281,6 @@
char pError[512]; char pError[512];
#line 383 "nxdict.w"
/* allocate a new NXdict structure */ /* allocate a new NXdict structure */
if(iVerbosity == NXalot) if(iVerbosity == NXalot)
@ -302,10 +305,6 @@
} }
#line 2362 "nxdict.w"
#line 410 "nxdict.w"
/* is there a file name argument */ /* is there a file name argument */
if(filename == NULL) if(filename == NULL)
@ -318,10 +317,6 @@
return NX_OK; return NX_OK;
} }
#line 2363 "nxdict.w"
#line 424 "nxdict.w"
fd = fopen(filename,"rb"); fd = fopen(filename,"rb");
if(!fd) if(!fd)
@ -334,12 +329,6 @@
} }
#line 2364 "nxdict.w"
#line 444 "nxdict.w"
/* read the file contents */ /* read the file contents */
if(iVerbosity == NXalot) if(iVerbosity == NXalot)
{ {
@ -363,8 +352,6 @@
} }
NXDIParse(pBuffer, pNew->pDictionary); NXDIParse(pBuffer, pNew->pDictionary);
#line 2365 "nxdict.w"
if(iVerbosity == NXalot) if(iVerbosity == NXalot)
{ {
@ -376,8 +363,6 @@
} }
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
#line 660 "nxdict.w"
NXdict NXDIAssert(NXdict handle) NXdict NXDIAssert(NXdict handle)
{ {
NXdict self = NULL; NXdict self = NULL;
@ -387,12 +372,9 @@
return self; return self;
} }
#line 2376 "nxdict.w"
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
#line 671 "nxdict.w"
NXstatus NXDclose(NXdict handle, char *filename) NXstatus NXDclose(NXdict handle, char *filename)
{ {
NXdict self; NXdict self;
@ -441,12 +423,8 @@
return NX_OK; return NX_OK;
} }
#line 2378 "nxdict.w"
/*------------------------------------------------------------------------*/ /*------------------------------------------------------------------------*/
#line 724 "nxdict.w"
NXstatus NXDadd(NXdict handle, char *alias, char *pDef) NXstatus NXDadd(NXdict handle, char *alias, char *pDef)
{ {
NXdict self; NXdict self;
@ -491,14 +469,7 @@
} }
return NX_OK; return NX_OK;
} }
#line 2380 "nxdict.w"
/*-----------------------------------------------------------------------*/ /*-----------------------------------------------------------------------*/
#line 776 "nxdict.w"
#define NORMAL 1 #define NORMAL 1
#define ALIAS 2 #define ALIAS 2
pDynString NXDItextreplace(NXdict handle, char *pDefString) pDynString NXDItextreplace(NXdict handle, char *pDefString)
@ -595,23 +566,12 @@
return NX_OK; return NX_OK;
} }
#line 2382 "nxdict.w"
/*------------------- The Defintion String Parser -----------------------*/ /*------------------- The Defintion String Parser -----------------------*/
/*------- Data structures */ /*------- Data structures */
#line 886 "nxdict.w"
typedef struct { typedef struct {
char pText[20]; char pText[20];
int iCode; int iCode;
} TokDat; } TokDat;
#line 2385 "nxdict.w"
#line 896 "nxdict.w"
#define TERMSDS 100 #define TERMSDS 100
#define TERMVG 200 #define TERMVG 200
#define TERMLINK 300 #define TERMLINK 300
@ -625,32 +585,15 @@
int iTerminal; int iTerminal;
} ParDat; } ParDat;
#line 2386 "nxdict.w"
#line 1101 "nxdict.w"
static void DummyError(void *pData, char *pError) static void DummyError(void *pData, char *pError)
{ {
return; return;
} }
#line 2387 "nxdict.w"
#line 1215 "nxdict.w"
typedef struct { typedef struct {
char name[256]; char name[256];
char value[256]; char value[256];
}AttItem; }AttItem;
#line 2388 "nxdict.w"
/*------------------------------------------------------------------------*/
#line 918 "nxdict.w"
/*---------------- Token name defines ---------------------------*/ /*---------------- Token name defines ---------------------------*/
#define DSLASH 0 #define DSLASH 0
#define DKOMMA 1 #define DKOMMA 1
@ -665,10 +608,14 @@
#define DCLOSE 11 #define DCLOSE 11
#define DATTR 12 #define DATTR 12
#define DEND 13 #define DEND 13
#define DLZW 14
#define DHUF 15
#define DRLE 16
#define CHUNK 17
/*----------------- Keywords ----------------------------------------*/ /*----------------- Keywords ----------------------------------------*/
static TokDat TokenList[8] = { static TokDat TokenList[12] = {
{"SDS",DSDS}, {"SDS",DSDS},
{"NXLINK",DLINK}, {"NXLINK",DLINK},
{"NXVGROUP",DGROUP}, {"NXVGROUP",DGROUP},
@ -676,7 +623,11 @@
{"-type",DTYPE}, {"-type",DTYPE},
{"-rank",DRANK}, {"-rank",DRANK},
{"-attr",DATTR}, {"-attr",DATTR},
{"",0} }; {"-chunk",CHUNK},
{"-LZW",DLZW},
{"-HUF",DHUF},
{"-RLE",DRLE},
{NULL,0} };
/*-----------------------------------------------------------------------*/ /*-----------------------------------------------------------------------*/
static void NXDIDefToken(ParDat *sStat) static void NXDIDefToken(ParDat *sStat)
@ -744,7 +695,7 @@
sStat->pToken[i] = '\0'; sStat->pToken[i] = '\0';
/*--------- try to find word in Tokenlist */ /*--------- try to find word in Tokenlist */
for(i = 0; i < 7; i++) for(i = 0; i < 10; i++)
{ {
if(strcmp(sStat->pToken,TokenList[i].pText) == 0) if(strcmp(sStat->pToken,TokenList[i].pText) == 0)
{ {
@ -759,12 +710,8 @@
} }
#line 2390 "nxdict.w"
/*------------------------------------------------------------------------*/ /*------------------------------------------------------------------------*/
#line 1114 "nxdict.w"
int NXDIParsePath(NXhandle hfil, ParDat *pParse) int NXDIParsePath(NXhandle hfil, ParDat *pParse)
{ {
int iRet, iToken; int iRet, iToken;
@ -855,12 +802,8 @@
return NX_ERROR; return NX_ERROR;
} }
#line 2392 "nxdict.w"
/*------------------------------------------------------------------------*/ /*------------------------------------------------------------------------*/
#line 1481 "nxdict.w"
static int NXDIParseAttr(ParDat *pParse, int iList) static int NXDIParseAttr(ParDat *pParse, int iList)
{ {
char pError[256]; char pError[256];
@ -919,12 +862,7 @@
return NX_OK; return NX_OK;
} }
#line 2394 "nxdict.w"
/*------------------------------------------------------------------------*/ /*------------------------------------------------------------------------*/
#line 1428 "nxdict.w"
static int NXDIParseDim(ParDat *pParse, int *iDim) static int NXDIParseDim(ParDat *pParse, int *iDim)
{ {
char pError[256]; char pError[256];
@ -972,13 +910,7 @@
} }
return NX_OK; return NX_OK;
} }
#line 2396 "nxdict.w"
/*------------------------------------------------------------------------*/ /*------------------------------------------------------------------------*/
#line 1379 "nxdict.w"
static TokDat tDatType[] = { static TokDat tDatType[] = {
{"DFNT_FLOAT32",DFNT_FLOAT32}, {"DFNT_FLOAT32",DFNT_FLOAT32},
{"DFNT_FLOAT64",DFNT_FLOAT64}, {"DFNT_FLOAT64",DFNT_FLOAT64},
@ -988,7 +920,8 @@
{"DFNT_UINT16",DFNT_UINT16}, {"DFNT_UINT16",DFNT_UINT16},
{"DFNT_INT32",DFNT_INT32}, {"DFNT_INT32",DFNT_INT32},
{"DFNT_UINT32",DFNT_UINT32}, {"DFNT_UINT32",DFNT_UINT32},
{"",0} }; {"DFNT_CHAR",DFNT_CHAR},
{NULL,-122} };
@ -1023,19 +956,15 @@
return NX_ERROR; return NX_ERROR;
} }
#line 2398 "nxdict.w"
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
#line 1223 "nxdict.w"
static int NXDIParseSDS(NXhandle hfil, ParDat *pParse) static int NXDIParseSDS(NXhandle hfil, ParDat *pParse)
{ {
int iType = DFNT_FLOAT32; int iType = DFNT_FLOAT32;
int iRank = 1; int iRank = 1;
int32 iDim[MAX_VAR_DIMS]; int iCompress = NX_COMP_NONE;
int iList; int32 iDim[MAX_VAR_DIMS], iChunk[MAX_VAR_DIMS];
int iRet, iStat; int iList, iChunkDefined = 0 ;
int iRet, iStat, i;
char pError[256]; char pError[256];
char pName[MAX_NC_NAME]; char pName[MAX_NC_NAME];
void (*ErrFunc)(void *pData, char *pErr); void (*ErrFunc)(void *pData, char *pErr);
@ -1079,8 +1008,17 @@
} }
iRank = atoi(pParse->pToken); iRank = atoi(pParse->pToken);
break; break;
case CHUNK: /* chunk size for compression */
iRet = NXDIParseDim(pParse, iChunk);
if(iRet == NX_ERROR)
{
LLDdelete(iList);
return iRet;
}
iChunkDefined = 1;
break;
case DDIM: case DDIM:
iRet = NXDIParseDim (pParse, (int *) iDim); iRet = NXDIParseDim(pParse, iDim);
if(iRet == NX_ERROR) if(iRet == NX_ERROR)
{ {
LLDdelete(iList); LLDdelete(iList);
@ -1103,6 +1041,15 @@
return iRet; return iRet;
} }
break; break;
case DLZW:
iCompress = NX_COMP_LZW;
break;
case DRLE:
iCompress = NX_COMP_RLE;
break;
case DHUF:
iCompress = NX_COMP_HUF;
break;
case DEND: case DEND:
break; break;
default: default:
@ -1116,7 +1063,18 @@
NXDIDefToken(pParse); NXDIDefToken(pParse);
} }
/* whew! got all information for doing the SDS */ /* whew! got all information for doing the SDS
However, if the chunk sizes for compression have not
been set, default them to the dimensions of the data set
*/
if(iChunkDefined == 0)
{
for(i = 0; i < iRank; i++)
{
iChunk[i] = iDim[i];
}
}
/* first install dummy error handler, try open it, then /* first install dummy error handler, try open it, then
deinstall again and create if allowed deinstall again and create if allowed
*/ */
@ -1136,7 +1094,8 @@
/* we need to create it, if we may */ /* we need to create it, if we may */
if(pParse->iMayCreate) if(pParse->iMayCreate)
{ {
iRet = NXmakedata (hfil, pName, iType, iRank, (int *) iDim); iRet = NXcompmakedata(hfil,pName,iType, iRank,iDim,
iCompress,iChunk);
if(iRet != NX_OK) if(iRet != NX_OK)
{ {
/* a comment on this one has already been written! */ /* a comment on this one has already been written! */
@ -1150,6 +1109,7 @@
LLDdelete(iList); LLDdelete(iList);
return iRet; return iRet;
} }
/* put attributes in */ /* put attributes in */
iRet = LLDnodePtr2First(iList); iRet = LLDnodePtr2First(iList);
while(iRet != 0) while(iRet != 0)
@ -1179,13 +1139,7 @@
} }
return NX_OK; return NX_OK;
} }
#line 2400 "nxdict.w"
/*------------------------------------------------------------------------*/ /*------------------------------------------------------------------------*/
#line 1544 "nxdict.w"
static int NXDIParseLink(NXhandle hfil, NXdict pDict,ParDat *pParse) static int NXDIParseLink(NXhandle hfil, NXdict pDict,ParDat *pParse)
{ {
char pError[256]; char pError[256];
@ -1214,14 +1168,8 @@
return NXDopenalias(hfil, pDict, pParse->pToken); return NXDopenalias(hfil, pDict, pParse->pToken);
} }
#line 2402 "nxdict.w"
/*------------------------------------------------------------------------*/ /*------------------------------------------------------------------------*/
int NXDIDefParse(NXhandle hFil, NXdict pDict, ParDat *pParse)
#line 1034 "nxdict.w"
static int NXDIDefParse(NXhandle hFil, NXdict pDict, ParDat *pParse)
{ {
int iRet; int iRet;
char pError[256]; char pError[256];
@ -1271,14 +1219,8 @@
} }
return NX_OK; return NX_OK;
} }
#line 2404 "nxdict.w"
/*----------------------------------------------------------------------*/ /*----------------------------------------------------------------------*/
NXstatus NXDIUnwind(NXhandle hFil, int iDepth)
#line 1576 "nxdict.w"
static NXstatus NXDIUnwind(NXhandle hFil, int iDepth)
{ {
int i, iRet; int i, iRet;
@ -1292,13 +1234,7 @@
} }
return NX_OK; return NX_OK;
} }
#line 2406 "nxdict.w"
/*-------------------- The Data Transfer Functions ----------------------*/ /*-------------------- The Data Transfer Functions ----------------------*/
#line 1597 "nxdict.w"
NXstatus NXDopendef(NXhandle hfil, NXdict dict, char *pDef) NXstatus NXDopendef(NXhandle hfil, NXdict dict, char *pDef)
{ {
NXdict pDict; NXdict pDict;
@ -1332,24 +1268,18 @@
/* do not rewind on links */ /* do not rewind on links */
return iRet; return iRet;
} }
#line 2408 "nxdict.w"
/*------------------------------------------------------------------------*/ /*------------------------------------------------------------------------*/
#line 1637 "nxdict.w"
NXstatus NXDopenalias(NXhandle hfil, NXdict dict, char *pAlias) NXstatus NXDopenalias(NXhandle hfil, NXdict dict, char *pAlias)
{ {
NXdict pDict; NXdict pDict;
int iRet; int iRet;
char pDefinition[1024]; char pDefinition[2048];
pDynString pReplaced = NULL; pDynString pReplaced = NULL;
pDict = NXDIAssert(dict); pDict = NXDIAssert(dict);
/* get Definition String */ /* get Definition String */
iRet = NXDget(pDict,pAlias,pDefinition,1023); iRet = NXDget(pDict,pAlias,pDefinition,2047);
if(iRet != NX_OK) if(iRet != NX_OK)
{ {
sprintf(pDefinition,"ERROR: alias %s not recognized",pAlias); sprintf(pDefinition,"ERROR: alias %s not recognized",pAlias);
@ -1369,13 +1299,7 @@
DeleteDynString(pReplaced); DeleteDynString(pReplaced);
return iRet; return iRet;
} }
#line 2410 "nxdict.w"
/*------------------------------------------------------------------------*/ /*------------------------------------------------------------------------*/
#line 1674 "nxdict.w"
NXstatus NXDputdef(NXhandle hFil, NXdict dict, char *pDef, void *pData) NXstatus NXDputdef(NXhandle hFil, NXdict dict, char *pDef, void *pData)
{ {
NXdict pDict; NXdict pDict;
@ -1422,24 +1346,18 @@
} }
return iStat; return iStat;
} }
#line 2412 "nxdict.w"
/*------------------------------------------------------------------------*/ /*------------------------------------------------------------------------*/
#line 1725 "nxdict.w"
NXstatus NXDputalias(NXhandle hFil, NXdict dict, char *pAlias, void *pData) NXstatus NXDputalias(NXhandle hFil, NXdict dict, char *pAlias, void *pData)
{ {
NXdict pDict; NXdict pDict;
int iRet; int iRet;
char pDefinition[1024]; char pDefinition[2048];
pDynString pReplaced = NULL; pDynString pReplaced = NULL;
pDict = NXDIAssert(dict); pDict = NXDIAssert(dict);
/* get Definition String */ /* get Definition String */
iRet = NXDget(pDict,pAlias,pDefinition,1023); iRet = NXDget(pDict,pAlias,pDefinition,2047);
if(iRet != NX_OK) if(iRet != NX_OK)
{ {
sprintf(pDefinition,"ERROR: alias %s not recognized",pAlias); sprintf(pDefinition,"ERROR: alias %s not recognized",pAlias);
@ -1459,13 +1377,7 @@
DeleteDynString(pReplaced); DeleteDynString(pReplaced);
return iRet; return iRet;
} }
#line 2414 "nxdict.w"
/*------------------------------------------------------------------------*/ /*------------------------------------------------------------------------*/
#line 1760 "nxdict.w"
NXstatus NXDgetdef(NXhandle hFil, NXdict dict, char *pDef, void *pData) NXstatus NXDgetdef(NXhandle hFil, NXdict dict, char *pDef, void *pData)
{ {
NXdict pDict; NXdict pDict;
@ -1514,23 +1426,18 @@
return iStat; return iStat;
} }
#line 2416 "nxdict.w"
/*------------------------------------------------------------------------*/ /*------------------------------------------------------------------------*/
#line 1812 "nxdict.w"
NXstatus NXDgetalias(NXhandle hFil, NXdict dict, char *pAlias, void *pData) NXstatus NXDgetalias(NXhandle hFil, NXdict dict, char *pAlias, void *pData)
{ {
NXdict pDict; NXdict pDict;
int iRet; int iRet;
char pDefinition[1024]; char pDefinition[2048];
pDynString pReplaced = NULL; pDynString pReplaced = NULL;
pDict = NXDIAssert(dict); pDict = NXDIAssert(dict);
/* get Definition String */ /* get Definition String */
iRet = NXDget(pDict,pAlias,pDefinition,1023); iRet = NXDget(pDict,pAlias,pDefinition,2047);
if(iRet != NX_OK) if(iRet != NX_OK)
{ {
sprintf(pDefinition,"ERROR: alias %s not recognized",pAlias); sprintf(pDefinition,"ERROR: alias %s not recognized",pAlias);
@ -1550,13 +1457,92 @@
DeleteDynString(pReplaced); DeleteDynString(pReplaced);
return iRet; return iRet;
} }
/*------------------------------------------------------------------------*/
#line 2418 "nxdict.w" NXstatus NXDinfodef(NXhandle hFil, NXdict dict, char *pDef, int *rank,
int dimension[], int *iType)
{
NXdict pDict;
ParDat pParse;
int iRet, i, iStat;
pDict = NXDIAssert(dict);
/* parse and act on definition string */
pParse.iMayCreate = 0;
pParse.pPtr = pDef;
pParse.iDepth = 0;
#ifdef DEFDEBUG
printf("Getting: %s\n",pDef);
#endif
iRet = NXDIDefParse(hFil,pDict,&pParse);
if(iRet == NX_ERROR)
{
/* unwind and throw up */
NXDIUnwind(hFil,pParse.iDepth);
return NX_ERROR;
}
/* only SDS can be written */
if(pParse.iTerminal != TERMSDS)
{
NXIReportError(NXpData,
"ERROR: can only write to an SDS!");
iStat = NX_ERROR;
}
else
{
/* the SDS should be open by now, read it */
iStat = NXgetinfo(hFil, rank,dimension, iType);
iRet = NXclosedata(hFil);
}
/* rewind the hierarchy */
iRet = NXDIUnwind(hFil,pParse.iDepth);
if(iRet != NX_OK)
{
return NX_ERROR;
}
return iStat;
}
/*------------------------------------------------------------------------*/ /*------------------------------------------------------------------------*/
#line 1849 "nxdict.w" NXstatus NXDinfoalias(NXhandle hFil, NXdict dict, char *pAlias, int *rank,
int dimension[], int *iType)
{
NXdict pDict;
int iRet;
char pDefinition[2048];
pDynString pReplaced = NULL;
pDict = NXDIAssert(dict);
/* get Definition String */
iRet = NXDget(pDict,pAlias,pDefinition,2047);
if(iRet != NX_OK)
{
sprintf(pDefinition,"ERROR: alias %s not recognized",pAlias);
NXIReportError(NXpData,pDefinition);
return NX_ERROR;
}
/* do text replacement */
pReplaced = NXDItextreplace(dict,pDefinition);
if(!pReplaced)
{
return NX_ERROR;
}
/* call NXDgetdef */
iRet = NXDinfodef(hFil,dict,GetCharArray(pReplaced),rank,dimension,iType);
DeleteDynString(pReplaced);
return iRet;
}
/*------------------------------------------------------------------------*/
NXstatus NXDdeflink(NXhandle hFil, NXdict dict, NXstatus NXDdeflink(NXhandle hFil, NXdict dict,
char *pTarget, char *pVictim) char *pTarget, char *pVictim)
{ {
@ -1645,7 +1631,7 @@
NXstatus NXDaliaslink(NXhandle hFil, NXdict dict, NXstatus NXDaliaslink(NXhandle hFil, NXdict dict,
char *pTarget, char *pVictim) char *pTarget, char *pVictim)
{ {
char pTargetDef[1024], pVictimDef[1024]; char pTargetDef[2048], pVictimDef[2048];
int iRet; int iRet;
NXdict pDict; NXdict pDict;
pDynString pRep1 = NULL, pRep2 = NULL; pDynString pRep1 = NULL, pRep2 = NULL;
@ -1653,7 +1639,7 @@
pDict = NXDIAssert(dict); pDict = NXDIAssert(dict);
/* get Target Definition String */ /* get Target Definition String */
iRet = NXDget(pDict,pTarget,pTargetDef,1023); iRet = NXDget(pDict,pTarget,pTargetDef,2047);
if(iRet != NX_OK) if(iRet != NX_OK)
{ {
sprintf(pTargetDef,"ERROR: alias %s not recognized",pTarget); sprintf(pTargetDef,"ERROR: alias %s not recognized",pTarget);
@ -1662,7 +1648,7 @@
} }
/* get Victim definition string */ /* get Victim definition string */
iRet = NXDget(pDict,pVictim,pVictimDef,1023); iRet = NXDget(pDict,pVictim,pVictimDef,2047);
if(iRet != NX_OK) if(iRet != NX_OK)
{ {
sprintf(pTargetDef,"ERROR: alias %s not recognized",pTarget); sprintf(pTargetDef,"ERROR: alias %s not recognized",pTarget);
@ -1688,14 +1674,6 @@
DeleteDynString(pRep2); DeleteDynString(pRep2);
return iRet; return iRet;
} }
#line 2420 "nxdict.w"
/*-----------------------------------------------------------------------*/
#line 1986 "nxdict.w"
/*-------------------------------------------------------------------------*/ /*-------------------------------------------------------------------------*/
static void SNXFormatTime(char *pBuffer, int iBufLen) static void SNXFormatTime(char *pBuffer, int iBufLen)
{ {
@ -1706,7 +1684,7 @@
iDate = time(NULL); iDate = time(NULL);
psTime = localtime(&iDate); psTime = localtime(&iDate);
memset(pBuffer,0,iBufLen); memset(pBuffer,0,iBufLen);
strftime(pBuffer,iBufLen,"%Y-%d-%m %H:%M:%S",psTime); strftime(pBuffer,iBufLen,"%Y-%m-%d %H:%M:%S",psTime);
} }
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
NXstatus NXUwriteglobals(NXhandle pFile, NXstatus NXUwriteglobals(NXhandle pFile,
@ -1721,26 +1699,28 @@
char pBueffel[512]; char pBueffel[512];
int iStat; int iStat;
/* store global attributes */ /* store global attributes, now done by NXopen
iStat = NXputattr(pFile,"file_name",filename, iStat = NXputattr(pFile,"file_name",filename,
strlen(filename)+1,DFNT_INT8); strlen(filename)+1,NX_CHAR);
if(iStat == NX_ERROR) if(iStat == NX_ERROR)
{ {
return NX_ERROR; return NX_ERROR;
} }
*/
/* write creation time */ /* write creation time, now done by NXopen
SNXFormatTime(pBueffel,512); SNXFormatTime(pBueffel,512);
iStat = NXputattr(pFile,"file_time",pBueffel, iStat = NXputattr(pFile,"file_time",pBueffel,
strlen(pBueffel)+1,DFNT_INT8); strlen(pBueffel)+1,NX_CHAR);
if(iStat == NX_ERROR) if(iStat == NX_ERROR)
{ {
return NX_ERROR; return NX_ERROR;
} }
*/
/* instrument name */ /* instrument name */
iStat = NXputattr(pFile,"instrument",instrument, iStat = NXputattr(pFile,"instrument",instrument,
strlen(instrument)+1,DFNT_INT8); strlen(instrument)+1,NX_CHAR);
if(iStat == NX_ERROR) if(iStat == NX_ERROR)
{ {
return iStat; return iStat;
@ -1748,7 +1728,7 @@
/* owner */ /* owner */
iStat = NXputattr(pFile,"owner",owner, iStat = NXputattr(pFile,"owner",owner,
strlen(owner)+1,DFNT_INT8); strlen(owner)+1,NX_CHAR);
if(iStat == NX_ERROR) if(iStat == NX_ERROR)
{ {
return iStat; return iStat;
@ -1756,7 +1736,7 @@
/* Adress */ /* Adress */
iStat = NXputattr(pFile,"owner_adress",adress, iStat = NXputattr(pFile,"owner_adress",adress,
strlen(adress)+1,DFNT_INT8); strlen(adress)+1,NX_CHAR);
if(iStat == NX_ERROR) if(iStat == NX_ERROR)
{ {
return iStat; return iStat;
@ -1764,7 +1744,7 @@
/* phone */ /* phone */
iStat = NXputattr(pFile,"owner_telephone_number",phone, iStat = NXputattr(pFile,"owner_telephone_number",phone,
strlen(phone)+1,DFNT_INT8); strlen(phone)+1,NX_CHAR);
if(iStat == NX_ERROR) if(iStat == NX_ERROR)
{ {
return iStat; return iStat;
@ -1772,7 +1752,7 @@
/* fax */ /* fax */
iStat = NXputattr(pFile,"owner_fax_number",fax, iStat = NXputattr(pFile,"owner_fax_number",fax,
strlen(fax)+1,DFNT_INT8); strlen(fax)+1,NX_CHAR);
if(iStat == NX_ERROR) if(iStat == NX_ERROR)
{ {
return iStat; return iStat;
@ -1780,20 +1760,14 @@
/* email */ /* email */
iStat = NXputattr(pFile,"owner_email",email, iStat = NXputattr(pFile,"owner_email",email,
strlen(email)+1,DFNT_INT8); strlen(email)+1,NX_CHAR);
if(iStat == NX_ERROR) if(iStat == NX_ERROR)
{ {
return iStat; return iStat;
} }
return NX_OK; return NX_OK;
} }
#line 2422 "nxdict.w"
/*-----------------------------------------------------------------------*/ /*-----------------------------------------------------------------------*/
#line 2082 "nxdict.w"
NXstatus NXUentergroup(NXhandle hFil, char *name, char *class) NXstatus NXUentergroup(NXhandle hFil, char *name, char *class)
{ {
void (*ErrFunc)(void *pData, char *pErr); void (*ErrFunc)(void *pData, char *pErr);
@ -1828,13 +1802,7 @@
} }
return NX_OK; return NX_OK;
} }
#line 2424 "nxdict.w"
/*-----------------------------------------------------------------------*/ /*-----------------------------------------------------------------------*/
#line 2119 "nxdict.w"
NXstatus NXUenterdata(NXhandle hFil, char *label, int datatype, NXstatus NXUenterdata(NXhandle hFil, char *label, int datatype,
int rank, int dim[], char *pUnits) int rank, int dim[], char *pUnits)
{ {
@ -1877,13 +1845,7 @@
} }
return NX_OK; return NX_OK;
} }
#line 2426 "nxdict.w"
/*-----------------------------------------------------------------------*/ /*-----------------------------------------------------------------------*/
#line 2165 "nxdict.w"
NXstatus NXUallocSDS(NXhandle hFil, void **pData) NXstatus NXUallocSDS(NXhandle hFil, void **pData)
{ {
int iDIM[MAX_VAR_DIMS]; int iDIM[MAX_VAR_DIMS];
@ -1913,6 +1875,8 @@
lLength *= sizeof(float64); lLength *= sizeof(float64);
break; break;
case DFNT_INT8: case DFNT_INT8:
case DFNT_CHAR:
case DFNT_UCHAR8:
lLength *= sizeof(int8); lLength *= sizeof(int8);
break; break;
case DFNT_UINT8: case DFNT_UINT8:
@ -1943,15 +1907,10 @@
NXIReportError(NXpData,"ERROR: memory exhausted in NXUallocSDS"); NXIReportError(NXpData,"ERROR: memory exhausted in NXUallocSDS");
return NX_ERROR; return NX_ERROR;
} }
memset(*pData,0,lLength);
return NX_OK; return NX_OK;
} }
#line 2428 "nxdict.w"
/*----------------------------------------------------------------------*/ /*----------------------------------------------------------------------*/
#line 2229 "nxdict.w"
NXstatus NXUfreeSDS(void **pData) NXstatus NXUfreeSDS(void **pData)
{ {
free(*pData); free(*pData);
@ -1959,5 +1918,3 @@
return NX_OK; return NX_OK;
} }
#line 2430 "nxdict.w"

99
nxscript.c
View File

@ -12,13 +12,19 @@
#include <assert.h> #include <assert.h>
#include <errno.h> #include <errno.h>
#include <tcl.h> #include <tcl.h>
#include <math.h>
#include <unistd.h> #include <unistd.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <dirent.h>
#include "fortify.h" #include "fortify.h"
#include "sics.h" #include "sics.h"
#include "splitter.h" #include "splitter.h"
#include "HistMem.h" #include "HistMem.h"
#include "motor.h" #include "motor.h"
#include "counter.h" #include "counter.h"
#include "sicsvar.h"
#include "danu.h"
#include "udpquieck.h" #include "udpquieck.h"
#include "nxdict.h" #include "nxdict.h"
#include "nxscript.h" #include "nxscript.h"
@ -28,6 +34,85 @@ typedef struct {
NXhandle fileHandle; NXhandle fileHandle;
NXdict dictHandle; NXdict dictHandle;
} NXScript, *pNXScript; } NXScript, *pNXScript;
/*------------------------------------------------------------------------*/
char *makeFilename(SicsInterp *pSics, SConnection *pCon) {
pSicsVariable pPath = NULL, pPref = NULL, pEnd = NULL;
char *pRes = NULL;
int iLen, iNum, iYear, thousand;
char pNumText[10], pBueffel[256];
CommandList *pCom = NULL;
DIR *dir = NULL;
/* Try, get all the Variables */
pPath = FindVariable(pSics,"sicsdatapath");
pPref = FindVariable(pSics,"sicsdataprefix");
pCom = FindCommand(pSics,"sicsdatanumber");
pEnd = FindVariable(pSics,"sicsdatapostfix");
if( (!pPath) || (!pPref) || (!pCom) || (!pEnd) ){
SCWrite(pCon,
"ERROR: cannot read variables for automatic data file name creation",
eError);
SCWrite(pCon,
"ERROR: This is a VERY, VERY, VERY serious installation problem",
eError);
SCWrite(pCon,"ERROR: your data will be dumped into emergency.hdf",eError);
return NULL;
}
/* find length */
iLen = strlen(pPath->text) + 4; /* extra 4 for dir number */
iLen += strlen(pPref->text);
iLen += 8; /* for number + year */
iLen += strlen(pEnd->text);
iLen += 10; /* safety margin */
/* allocate memory */
pRes = (char *)malloc(iLen*sizeof(char));
if(!pRes){
SCWrite(pCon,"ERROR: no memory in makeFilename",eError);
return NULL;
}
memset(pRes,0,iLen);
/* increment the data file number */
iNum = IncrementDataNumber(pCom->pData,&iYear);
if(iNum < 0){
SCWrite(pCon,"ERROR: cannot increment data number!",eError);
SCWrite(pCon,"ERROR: your data will be dumped to emergency.hdf",eError);
free(pRes);
return NULL;
}
strcpy(pRes,pPath->text);
thousand = (int)floor(iNum/1000.);
snprintf(pNumText,9,"%3.3d",thousand);
strcat(pRes,pNumText);
/*
check for existence of directory and create if neccessary
*/
dir = opendir(pRes);
if(dir == NULL){
mkdir(pRes,S_IRWXU | S_IRGRP | S_IXGRP);
snprintf(pBueffel,255,"Creating dir: %s", pRes);
SCWrite(pCon,pBueffel,eWarning);
} else {
closedir(dir);
}
/*
build the rest of the filename
*/
strcat(pRes,"/");
strcat(pRes,pPref->text);
sprintf(pNumText,"%5.5d",iNum);
strcat(pRes,pNumText);
sprintf(pNumText,"%4.4d",iYear);
strcat(pRes,pNumText);
strcat(pRes,pEnd->text);
return pRes;
}
/*======================== Action =======================================*/ /*======================== Action =======================================*/
static int handleFileOperations(SConnection *pCon, pNXScript self, static int handleFileOperations(SConnection *pCon, pNXScript self,
int argc, char *argv[]){ int argc, char *argv[]){
@ -742,7 +827,7 @@ static void makeLink(SConnection *pCon, SicsInterp *pSics,
int NXScriptAction(SConnection *pCon, SicsInterp *pSics, void *pData, int NXScriptAction(SConnection *pCon, SicsInterp *pSics, void *pData,
int argc, char *argv[]){ int argc, char *argv[]){
pNXScript self = (pNXScript)pData; pNXScript self = (pNXScript)pData;
char *pFile = NULL;
/* /*
preliminary checks preliminary checks
*/ */
@ -756,6 +841,18 @@ int NXScriptAction(SConnection *pCon, SicsInterp *pSics, void *pData,
} }
strtolower(argv[1]); strtolower(argv[1]);
if(strcmp(argv[1],"makefilename") == 0){
pFile = makeFilename(pSics,pCon);
if(pFile != NULL){
SCWrite(pCon,pFile,eValue);
free(pFile);
return 1;
} else {
SCWrite(pCon,"ERROR: failed to create filename",eError);
return 0;
}
}
if(handleFileOperations(pCon,self,argc,argv)){ if(handleFileOperations(pCon,self,argc,argv)){
return 1; return 1;
} }

2
synchronize.c
View File

@ -57,7 +57,7 @@ static void syncLogin(void)
} }
pBueffel[0] = '\0'; pBueffel[0] = '\0';
for(i = 0; i < 10; i++) for(i = 0; i < 60; i++)
{ {
memset(pRead,0,80); memset(pRead,0,80);
test = NETRead(connection,pRead,70,10*1000); test = NETRead(connection,pRead,70,10*1000);