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

- Fixes to make SL6 work

Browse Source 
- New NeXus libraries
- Added new raw binary transfer mode for mass data
- Added a check script option to configurable virtual motor


SKIPPED:
	psi/dumprot.c
	psi/make_gen
	psi/psi.c
	psi/rebin.c
	psi/sanslirebin.c
This commit is contained in:
koennecke
2012-03-29 08:41:05 +00:00
parent 14f257c2ab
commit 9eca96b064
56 changed files with 8881 additions and 6327 deletions
Download Patch File Download Diff File Expand all files Collapse all files

109
nxdict.c
View File

@ -47,8 +47,7 @@
/*--------------------------------------------------------------------------
Things defined in napi.c for error reporting
---------------------------------------------------------------------------*/
extern void *NXpData;
extern void (*NXIReportError) (void *pData, char *pBuffer);
static void *NXpData = NULL;
/*--------------------------------------------------------------------------*/
/* #define DEFDEBUG 1 */
/* define DEFDEBUG when you wish to print your definition strings before
@ -95,7 +94,7 @@ static char *NXDIReadFile(FILE * fd)
/* check for existence of the NXDICT string in the file */
if (strncmp(pNew, "##NXDICT-1.0", 12) != 0) {
NXIReportError(NXpData, "ERROR: This is NO NXdict file");
NXReportError("ERROR: This is NO NXdict file");
free(pNew);
return NULL;
}
@ -256,11 +255,11 @@ NXstatus NXDinitfromfile(char *filename, NXdict * pData)
/* allocate a new NXdict structure */
if (iVerbosity == NXalot) {
NXIReportError(NXpData, "Allocating new NXdict structure ");
NXReportError("Allocating new NXdict structure ");
}
pNew = (NXdict) malloc(sizeof(sNXdict));
if (!pNew) {
NXIReportError(NXpData, "Insufficient memory for creation of NXdict");
NXReportError("Insufficient memory for creation of NXdict");
return NX_ERROR;
}
@ -268,7 +267,7 @@ NXstatus NXDinitfromfile(char *filename, NXdict * pData)
pNew->iID = NXDMAGIC;
pNew->pDictionary = CreateStringDict();
if (!pNew->pDictionary) {
NXIReportError(NXpData, "Insufficient memory for creation of NXdict");
NXReportError("Insufficient memory for creation of NXdict");
free(pNew);
return NX_ERROR;
}
@ -278,7 +277,7 @@ NXstatus NXDinitfromfile(char *filename, NXdict * pData)
/* is there a file name argument */
if (filename == NULL) {
if (iVerbosity == NXalot) {
NXIReportError(NXpData, "NXDinitfrom file finished without data");
NXReportError("NXDinitfrom file finished without data");
}
*pData = pNew;
return NX_OK;
@ -288,8 +287,8 @@ NXstatus NXDinitfromfile(char *filename, NXdict * pData)
fd = fopen(filename, "rb");
if (!fd) {
sprintf(pError, "ERROR: file %s NOT found ", filename);
NXIReportError(NXpData, pError);
NXIReportError(NXpData, "NXDinitfrom file finished without data");
NXReportError(pError);
NXReportError("NXDinitfrom file finished without data");
*pData = pNew;
return NX_ERROR;
}
@ -297,27 +296,27 @@ NXstatus NXDinitfromfile(char *filename, NXdict * pData)
/* read the file contents */
if (iVerbosity == NXalot) {
NXIReportError(NXpData, "NXDinitfrom: reading file");
NXReportError("NXDinitfrom: reading file");
}
pBuffer = NXDIReadFile(fd);
fclose(fd); /* we are done with it then */
if (!pBuffer) {
sprintf(pError, "ERROR: reading file %s or no memory", filename);
NXIReportError(NXpData, pError);
NXIReportError(NXpData, "NXDinitfrom file finished without data");
NXReportError(pError);
NXReportError("NXDinitfrom file finished without data");
*pData = pNew;
return NX_ERROR;
}
/* parse it */
if (iVerbosity == NXalot) {
NXIReportError(NXpData, "NXDinitfrom: parsing dictionary definitions");
NXReportError("NXDinitfrom: parsing dictionary definitions");
}
NXDIParse(pBuffer, pNew->pDictionary);
if (iVerbosity == NXalot) {
NXIReportError(NXpData, "NXDinitfrom: performed successfully");
NXReportError("NXDinitfrom: performed successfully");
}
free(pBuffer);
*pData = pNew;
@ -350,12 +349,12 @@ NXstatus NXDclose(NXdict handle, char *filename)
if (filename) { /* we must write a file */
if (iVerbosity == NXalot) {
sprintf(pValue, "Writing file %s", filename);
NXIReportError(NXpData, pValue);
NXReportError(pValue);
}
fd = fopen(filename, "w");
if (!fd) {
sprintf(pValue, "ERROR: opening file %s for write", filename);
NXIReportError(NXpData, pValue);
NXReportError(pValue);
return NX_ERROR;
}
@ -371,7 +370,7 @@ NXstatus NXDclose(NXdict handle, char *filename)
fclose(fd);
if (iVerbosity == NXalot) {
sprintf(pValue, "File %s written", filename);
NXIReportError(NXpData, pValue);
NXReportError(pValue);
}
}
@ -445,7 +444,7 @@ pDynString NXDItextreplace(NXdict handle, char *pDefString)
/* create a dynamic string */
pReplaced = CreateDynString(strlen(pDefString), 512);
if (!pReplaced) {
NXIReportError(NXpData, "ERROR: out of memory in NXDtextreplace");
NXReportError("ERROR: out of memory in NXDtextreplace");
return NULL;
}
@ -479,8 +478,7 @@ pDynString NXDItextreplace(NXdict handle, char *pDefString)
pBueffel[iPos] = *pPtr;
iPos++;
if (iPos >= 1024) {
NXIReportError(NXpData,
"ERROR: buffer overrun in NXDItextreplace");
NXReportError("ERROR: buffer overrun in NXDItextreplace");
DeleteDynString(pReplaced);
return NULL;
}
@ -737,7 +735,7 @@ int NXDIParsePath(NXhandle hfil, ParDat * pParse)
if (pParse->iToken != DWORD) {
sprintf(pError, "ERROR: parse error at %s, expected vGroup name",
pParse->pToken);
NXIReportError(NXpData, pError);
NXReportError(pError);
return NX_ERROR;
}
strcpy(pName, pParse->pToken);
@ -747,7 +745,7 @@ int NXDIParsePath(NXhandle hfil, ParDat * pParse)
if (pParse->iToken != DKOMMA) {
sprintf(pError, "ERROR: parse error at %s, expected komma",
pParse->pToken);
NXIReportError(NXpData, pError);
NXReportError(pError);
return NX_ERROR;
}
@ -756,18 +754,18 @@ int NXDIParsePath(NXhandle hfil, ParDat * pParse)
if (pParse->iToken != DWORD) {
sprintf(pError, "ERROR: parse error at %s, expected vGroup class",
pParse->pToken);
NXIReportError(NXpData, pError);
NXReportError(pError);
return NX_ERROR;
}
strcpy(pClass, pParse->pToken);
/* done reading, ACTION, first install dummy error handler */
ErrFunc = NXIReportError;
NXMSetError(NXpData, DummyError);
NXMSetError(NXpData,DummyError);
/* try opening vGroup */
iRet = NXopengroup(hfil, pName, pClass);
NXMSetError(NXpData, ErrFunc);
NXMSetError(NXpData,ErrFunc);
if (iRet == NX_OK) {
pParse->iDepth++;
return NX_OK;
@ -789,7 +787,7 @@ int NXDIParsePath(NXhandle hfil, ParDat * pParse)
} else {
/* this is an error */
sprintf(pError, "ERROR: vGroup %s, %s NOT found", pName, pClass);
NXIReportError(NXpData, pError);
NXReportError(pError);
return NX_ERROR;
}
}
@ -809,7 +807,7 @@ static int NXDIParseAttr(ParDat * pParse, int iList)
NXDIDefToken(pParse);
if (pParse->iToken != DOPEN) {
sprintf(pError, "ERROR: expected {, got %s", pParse->pToken);
NXIReportError(NXpData, pError);
NXReportError(pError);
return NX_ERROR;
}
@ -818,7 +816,7 @@ static int NXDIParseAttr(ParDat * pParse, int iList)
if (pParse->iToken != DWORD) {
sprintf(pError, "ERROR: expected attribute name, got %s",
pParse->pToken);
NXIReportError(NXpData, pError);
NXReportError(pError);
return NX_ERROR;
}
strcpy(sAtt.name, pParse->pToken);
@ -827,7 +825,7 @@ static int NXDIParseAttr(ParDat * pParse, int iList)
NXDIDefToken(pParse);
if (pParse->iToken != DKOMMA) {
sprintf(pError, "ERROR: expected , , got %s", pParse->pToken);
NXIReportError(NXpData, pError);
NXReportError(pError);
return NX_ERROR;
}
@ -836,7 +834,7 @@ static int NXDIParseAttr(ParDat * pParse, int iList)
if (pParse->iToken != DWORD) {
sprintf(pError, "ERROR: expected attribute value, got %s",
pParse->pToken);
NXIReportError(NXpData, pError);
NXReportError(pError);
return NX_ERROR;
}
strcpy(sAtt.value, pParse->pToken);
@ -845,7 +843,7 @@ static int NXDIParseAttr(ParDat * pParse, int iList)
NXDIDefToken(pParse);
if (pParse->iToken != DCLOSE) {
sprintf(pError, "ERROR: expected }, got %s", pParse->pToken);
NXIReportError(NXpData, pError);
NXReportError(pError);
return NX_ERROR;
}
@ -868,7 +866,7 @@ static int NXDIParseDim(ParDat * pParse, int *iDim)
NXDIDefToken(pParse);
if (pParse->iToken != DOPEN) {
sprintf(pError, "ERROR: expected {, got %s", pParse->pToken);
NXIReportError(NXpData, pError);
NXReportError(pError);
return NX_ERROR;
}
@ -878,7 +876,7 @@ static int NXDIParseDim(ParDat * pParse, int *iDim)
NXDIDefToken(pParse);
if (pParse->iToken != DWORD) {
sprintf(pError, "ERROR: expected number, got %s", pParse->pToken);
NXIReportError(NXpData, pError);
NXReportError(pError);
return NX_ERROR;
}
iDim[i] = atoi(pParse->pToken);
@ -887,7 +885,7 @@ static int NXDIParseDim(ParDat * pParse, int *iDim)
NXDIDefToken(pParse);
if ((pParse->iToken != DKOMMA) && (pParse->iToken != DCLOSE)) {
sprintf(pError, "ERROR: expected , or }, got %s", pParse->pToken);
NXIReportError(NXpData, pError);
NXReportError( pError);
return NX_ERROR;
}
if (pParse->iToken == DCLOSE) {
@ -930,7 +928,7 @@ static int NXDIParseType(ParDat * pParse, int *iType)
NXDIDefToken(pParse);
if (pParse->iToken != DWORD) {
sprintf(pError, "ERROR: expected data type, got %s", pParse->pToken);
NXIReportError(NXpData, pError);
NXReportError(pError);
return NX_ERROR;
}
@ -947,7 +945,7 @@ static int NXDIParseType(ParDat * pParse, int *iType)
*/
sprintf(pError, "ERROR: %s not recognized as valid data type",
pParse->pToken);
NXIReportError(NXpData, pError);
NXReportError(pError);
return NX_ERROR;
}
@ -972,7 +970,7 @@ static int NXDIParseSDS(NXhandle hfil, ParDat * pParse)
if (pParse->iToken != DWORD) {
sprintf(pError, "ERROR: parsing, expected name, got %s",
pParse->pToken);
NXIReportError(NXpData, pError);
NXReportError(pError);
return NX_ERROR;
}
strcpy(pName, pParse->pToken);
@ -980,7 +978,7 @@ static int NXDIParseSDS(NXhandle hfil, ParDat * pParse)
/* create the attribute list */
iList = LLDcreate(sizeof(AttItem));
if (iList < 0) {
NXIReportError(NXpData, "ERROR: cannot create list in NXDIParseSDS");
NXReportError("ERROR: cannot create list in NXDIParseSDS");
return NX_ERROR;
}
@ -991,7 +989,7 @@ static int NXDIParseSDS(NXhandle hfil, ParDat * pParse)
NXDIDefToken(pParse); /* advance */
if (pParse->iToken != DWORD) {
sprintf(pError, "ERROR: expected int, got %s", pParse->pToken);
NXIReportError(NXpData, pError);
NXReportError(pError);
LLDdelete(iList);
return NX_ERROR;
}
@ -1039,7 +1037,7 @@ static int NXDIParseSDS(NXhandle hfil, ParDat * pParse)
break;
default:
sprintf(pError, "ERROR: cannot identify token %s", pParse->pToken);
NXIReportError(NXpData, pError);
NXReportError(pError);
LLDdelete(iList);
return NX_ERROR;
@ -1107,7 +1105,7 @@ static int NXDIParseSDS(NXhandle hfil, ParDat * pParse)
} else {
/* this is an error */
sprintf(pError, "ERROR: SDS %s NOT found", pName);
NXIReportError(NXpData, pError);
NXReportError(pError);
LLDdelete(iList);
return NX_ERROR;
}
@ -1125,7 +1123,7 @@ static int NXDIParseLink(NXhandle hfil, NXdict pDict, ParDat * pParse)
NXDIDefToken(pParse);
if (pParse->iToken != DCLOSE) {
sprintf(pError, "ERROR: expected alias , got %s", pParse->pToken);
NXIReportError(NXpData, pError);
NXReportError(pError);
return NX_ERROR;
}
@ -1181,7 +1179,7 @@ int NXDIDefParse(NXhandle hFil, NXdict pDict, ParDat * pParse)
sprintf(pError,
"ERROR: Definition String parse error: %s not permitted here",
pParse->pToken);
NXIReportError(NXpData, pError);
NXReportError(pError);
return NX_ERROR;
break;
}
@ -1240,7 +1238,7 @@ NXstatus NXDopenalias(NXhandle hfil, NXdict dict, char *pAlias)
iRet = NXDget(pDict, pAlias, pDefinition, 2047);
if (iRet != NX_OK) {
sprintf(pDefinition, "ERROR: alias %s not recognized", pAlias);
NXIReportError(NXpData, pDefinition);
NXReportError(pDefinition);
return NX_ERROR;
}
@ -1281,7 +1279,7 @@ NXstatus NXDputdef(NXhandle hFil, NXdict dict, char *pDef, void *pData)
/* only SDS can be written */
if (pParse.iTerminal != TERMSDS) {
NXIReportError(NXpData, "ERROR: can only write to an SDS!");
NXReportError("ERROR: can only write to an SDS!");
iStat = NX_ERROR;
} else {
/* the SDS should be open by now, write it */
@ -1312,7 +1310,7 @@ NXstatus NXDputalias(NXhandle hFil, NXdict dict, char *pAlias, void *pData)
iRet = NXDget(pDict, pAlias, pDefinition, 2047);
if (iRet != NX_OK) {
sprintf(pDefinition, "ERROR: alias %s not recognized", pAlias);
NXIReportError(NXpData, pDefinition);
NXReportError( pDefinition);
return NX_ERROR;
}
@ -1354,7 +1352,7 @@ NXstatus NXDgetdef(NXhandle hFil, NXdict dict, char *pDef, void *pData)
/* only SDS can be written */
if (pParse.iTerminal != TERMSDS) {
NXIReportError(NXpData, "ERROR: can only write to an SDS!");
NXReportError("ERROR: can only write to an SDS!");
iStat = NX_ERROR;
} else {
/* the SDS should be open by now, read it */
@ -1385,7 +1383,7 @@ NXstatus NXDgetalias(NXhandle hFil, NXdict dict, char *pAlias, void *pData)
iRet = NXDget(pDict, pAlias, pDefinition, 2047);
if (iRet != NX_OK) {
sprintf(pDefinition, "ERROR: alias %s not recognized", pAlias);
NXIReportError(NXpData, pDefinition);
NXReportError(pDefinition);
return NX_ERROR;
}
@ -1429,7 +1427,7 @@ NXstatus NXDinfodef(NXhandle hFil, NXdict dict, char *pDef, int *rank,
/* only SDS can be written */
if (pParse.iTerminal != TERMSDS) {
NXIReportError(NXpData, "ERROR: can only write to an SDS!");
NXReportError("ERROR: can only write to an SDS!");
iStat = NX_ERROR;
} else {
/* the SDS should be open by now, read it */
@ -1462,7 +1460,7 @@ NXstatus NXDinfoalias(NXhandle hFil, NXdict dict, char *pAlias, int *rank,
iRet = NXDget(pDict, pAlias, pDefinition, 2047);
if (iRet != NX_OK) {
sprintf(pDefinition, "ERROR: alias %s not recognized", pAlias);
NXIReportError(NXpData, pDefinition);
NXReportError(pDefinition);
return NX_ERROR;
}
@ -1540,7 +1538,7 @@ NXstatus NXDdeflink(NXhandle hFil, NXdict dict,
}
/* check it being a vGroup! */
if (pParseT.iTerminal != TERMVG) {
NXIReportError(NXpData, "ERROR: can link only into a vGroup");
NXReportError("ERROR: can link only into a vGroup");
NXDIUnwind(hFil, pParseT.iDepth);
return NX_ERROR;
}
@ -1570,7 +1568,7 @@ NXstatus NXDaliaslink(NXhandle hFil, NXdict dict,
iRet = NXDget(pDict, pTarget, pTargetDef, 2047);
if (iRet != NX_OK) {
sprintf(pTargetDef, "ERROR: alias %s not recognized", pTarget);
NXIReportError(NXpData, pTargetDef);
NXReportError(pTargetDef);
return NX_ERROR;
}
@ -1578,7 +1576,7 @@ NXstatus NXDaliaslink(NXhandle hFil, NXdict dict,
iRet = NXDget(pDict, pVictim, pVictimDef, 2047);
if (iRet != NX_OK) {
sprintf(pTargetDef, "ERROR: alias %s not recognized", pTarget);
NXIReportError(NXpData, pTargetDef);
NXReportError(pTargetDef);
return NX_ERROR;
}
@ -1800,8 +1798,7 @@ NXstatus NXUallocSDS(NXhandle hFil, void **pData)
lLength *= sizeof(int);
break;
default:
NXIReportError(NXpData,
"ERROR: Internal: number type not recoginized");
NXReportError("ERROR: Internal: number type not recoginized");
return NX_ERROR;
}
@ -1809,7 +1806,7 @@ NXstatus NXUallocSDS(NXhandle hFil, void **pData)
*pData = NULL;
*pData = malloc(lLength);
if (*pData == NULL) {
NXIReportError(NXpData, "ERROR: memory exhausted in NXUallocSDS");
NXReportError("ERROR: memory exhausted in NXUallocSDS");
return NX_ERROR;
}
memset(*pData, 0, lLength);