linse/sics
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
b3b843023037dc643315be768d2c5750468b2a4f
sics/nxio.c
koennecke 91d4af0541 - Adapted indenation to new agreed upon system 
- Added support for second generation scriptcontext based counter
2009-02-13 09:00:03 +00:00

675 lines
16 KiB
C
Raw Blame History

/**
* This file contains functions necessary to perform XML-I/O for
* NeXus with the mxml-library.
*
* Most notably it contains the callback function for reading and
* writing data
*
* Copyright (C) 2004 Mark Koennecke
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* For further information, see <http://www.neutron.anl.gov/NeXus/>
*/
#include <mxml.h>
#include <assert.h>
#include "napi.h"
#include "nxio.h"
#include "nxdataset.h"
#include "napiconfig.h"
/* fix for mxml-2.3 */
#ifndef MXML_WRAP
#define MXML_WRAP 79
#endif
/* #define TESTMAIN 1 */
/*=================== type code handling ================================= */
typedef struct {
char name[30];
char format[30];
int nx_type;
} type_code;
#define NTYPECODE 11
static type_code typecode[NTYPECODE];
/*-----------------------------------------------------------------------*/
void initializeNumberFormats()
{
type_code myCode;
strcpy(myCode.name, "NX_FLOAT32");
strcpy(myCode.format, "%12.4f");
myCode.nx_type = NX_FLOAT32;
typecode[0] = myCode;
strcpy(myCode.name, "NX_FLOAT64");
strcpy(myCode.format, "%16.5f");
myCode.nx_type = NX_FLOAT64;
typecode[1] = myCode;
strcpy(myCode.name, "NX_INT8");
strcpy(myCode.format, "%5d");
myCode.nx_type = NX_INT8;
typecode[2] = myCode;
strcpy(myCode.name, "NX_UINT8");
strcpy(myCode.format, "%5d");
myCode.nx_type = NX_UINT8;
typecode[3] = myCode;
strcpy(myCode.name, "NX_INT16");
strcpy(myCode.format, "%8d");
myCode.nx_type = NX_INT16;
typecode[4] = myCode;
strcpy(myCode.name, "NX_UINT16");
strcpy(myCode.format, "%8d");
myCode.nx_type = NX_UINT16;
typecode[5] = myCode;
strcpy(myCode.name, "NX_INT32");
strcpy(myCode.format, "%12d");
myCode.nx_type = NX_INT32;
typecode[6] = myCode;
strcpy(myCode.name, "NX_UINT32");
strcpy(myCode.format, "%12d");
myCode.nx_type = NX_UINT32;
typecode[7] = myCode;
strcpy(myCode.name, "NX_INT64");
strcpy(myCode.format, "%24" PRINTF_INT64);
myCode.nx_type = NX_INT64;
typecode[8] = myCode;
strcpy(myCode.name, "NX_UINT64");
strcpy(myCode.format, "%24" PRINTF_UINT64);
myCode.nx_type = NX_UINT64;
typecode[9] = myCode;
strcpy(myCode.name, "NX_CHAR");
strcpy(myCode.format, "%c");
myCode.nx_type = NX_CHAR;
typecode[10] = myCode;
}
/*----------------------------------------------------------------------*/
void setNumberFormat(int nx_type, char *format)
{
int i;
for (i = 0; i < NTYPECODE; i++) {
if (typecode[i].nx_type == nx_type) {
strncpy(typecode[i].format, format, 29);
}
}
}
/*------------------------------------------------------------------*/
static void getNumberFormat(int nx_type, char format[30])
{
int i;
for (i = 0; i < NTYPECODE; i++) {
if (typecode[i].nx_type == nx_type) {
strncpy(format, typecode[i].format, 29);
}
}
}
/*----------------------------------------------------------------*/
void getNumberText(int nx_type, char *typestring, int typeLen)
{
int i;
for (i = 0; i < NTYPECODE; i++) {
if (typecode[i].nx_type == nx_type) {
strncpy(typestring, typecode[i].name, typeLen);
}
}
}
/*
* 'mxml_add_char()' - Add a character to a buffer, expanding as needed.
* copied here from mxml-file.c to achieve compatibility with mxml-2.1
* standard
*/
static int /* O - 0 on success, -1 on error */ myxml_add_char(int ch, /* I - Character to add */
char **bufptr, /* IO - Current position in buffer */
char **buffer, /* IO - Current buffer */
int
*bufsize)
{ /* IO - Current buffer size */
char *newbuffer; /* New buffer value */
if (*bufptr >= (*buffer + *bufsize - 4)) {
/*
* Increase the size of the buffer...
*/
if (*bufsize < 1024) {
(*bufsize) *= 2;
} else {
(*bufsize) *= 3;
(*bufsize) /= 2;
}
newbuffer = (char *) malloc(*bufsize * sizeof(char));
if (!newbuffer) {
free(*buffer);
mxml_error("Unable to expand string buffer to %d bytes!", *bufsize);
return (-1);
}
memset(newbuffer, 0, *bufsize * sizeof(char));
memcpy(newbuffer, *buffer, *bufptr - *buffer);
free(*buffer);
*bufptr = newbuffer + (*bufptr - *buffer);
*buffer = newbuffer;
}
if (ch < 128) {
/*
* Single byte ASCII...
*/
*(*bufptr)++ = ch;
} else if (ch < 2048) {
/*
* Two-byte UTF-8...
*/
*(*bufptr)++ = 0xc0 | (ch >> 6);
*(*bufptr)++ = 0x80 | (ch & 0x3f);
} else if (ch < 65536) {
/*
* Three-byte UTF-8...
*/
*(*bufptr)++ = 0xe0 | (ch >> 12);
*(*bufptr)++ = 0x80 | ((ch >> 6) & 0x3f);
*(*bufptr)++ = 0x80 | (ch & 0x3f);
} else {
/*
* Four-byte UTF-8...
*/
*(*bufptr)++ = 0xf0 | (ch >> 18);
*(*bufptr)++ = 0x80 | ((ch >> 12) & 0x3f);
*(*bufptr)++ = 0x80 | ((ch >> 6) & 0x3f);
*(*bufptr)++ = 0x80 | (ch & 0x3f);
}
return (0);
}
/*------------------------------------------------------------------*/
extern char *stptok(char *s, char *tok, size_t toklen, char *brk);
/*=====================================================================
actual stuff for implementing the callback functions
=====================================================================*/
void analyzeDim(const char *typeString, int *rank, int *iDim, int *type)
{
char dimString[132];
char dim[20];
char *dimStart, *dimEnd;
int myRank;
if (strchr(typeString, (int) '[') == NULL) {
switch (*type) {
case NX_INT8:
case NX_UINT8:
case NX_INT16:
case NX_UINT16:
case NX_INT32:
case NX_UINT32:
case NX_INT64:
case NX_UINT64:
case NX_FLOAT32:
case NX_FLOAT64:
iDim[0] = 1;
break;
case NX_CHAR:
iDim[0] = -1;
break;
}
} else {
/*
we have to determine rank and the dims.
Start by extracting the dimension string.
*/
dimStart = strchr(typeString, (int) '[') + 1;
dimEnd = strchr(typeString, (int) ']');
if (!dimStart || !dimEnd) {
mxml_error("ERROR: malformed dimension string in %s", typeString);
return;
}
if ((dimEnd - dimStart) > 131) {
mxml_error("ERROR: run away dimension definition in %s", typeString);
return;
}
memset(dimString, 0, 132);
memcpy(dimString, dimStart, (dimEnd - dimStart) * sizeof(char));
dimStart = stptok(dimString, dim, 19, ",");
myRank = 0;
while (dimStart != NULL) {
iDim[myRank] = atoi(dim);
dimStart = stptok(dimStart, dim, 19, ",");
myRank++;
}
*rank = myRank;
}
}
/*--------------------------------------------------------------------*/
int translateTypeCode(char *code)
{
int i, result = -1;
for (i = 0; i < NTYPECODE; i++) {
if (strstr(code, typecode[i].name) != NULL) {
result = typecode[i].nx_type;
break;
}
}
return result;
}
/*---------------------------------------------------------------------*/
static void analyzeDataType(mxml_node_t * parent, int *rank, int *type,
int *iDim)
{
const char *typeString;
mxml_type_t myType;
int i, nx_type = -1;
*rank = 1;
*type = NX_CHAR;
iDim[0] = -1;
/*
get the type attribute. No attribute means: plain text
*/
typeString = mxmlElementGetAttr(parent, TYPENAME);
if (typeString == NULL) {
return;
}
nx_type = translateTypeCode((char *) typeString);
/*
assign type
*/
if (nx_type == -1) {
mxml_error
("ERROR: %s is an invalid NeXus type, I try to continue but may fail",
typeString);
*type = NX_CHAR;
return;
}
*type = nx_type;
analyzeDim(typeString, rank, iDim, type);
}
/*-------------------------------------------------------------------*/
void destroyDataset(void *data)
{
if (data != NULL) {
dropNXDataset((pNXDS) data);
}
}
/*-------------------------------------------------------------------*/
static char *getNextNumber(char *pStart, char pNumber[80])
{
int charCount = 0;
pNumber[0] = '\0';
/* advance to first digit */
while (isspace(*pStart) && *pStart != '\0') {
pStart++;
}
if (*pStart == '\0') {
return NULL;
}
/* copy */
while (!isspace(*pStart) && *pStart != '\0' && charCount < 78) {
pNumber[charCount] = *pStart;
pStart++;
charCount++;
}
pNumber[charCount] = '\0';
return pStart;
}
/*--------------------------------------------------------------------*/
mxml_type_t nexusTypeCallback(mxml_node_t * parent)
{
const char *typeString;
if (strstr(parent->value.element.name, "?xml") != NULL ||
strstr(parent->value.element.name, "NX") != NULL) {
return MXML_ELEMENT;
} else {
typeString = mxmlElementGetAttr(parent, TYPENAME);
if (typeString == NULL) {
/*
MXML_TEXT seems more appropriate here. But mxml hacks text into
single words which is not what NeXus wants.
*/
return MXML_OPAQUE;
} else {
if (strstr(typeString, "NX_CHAR") != NULL) {
return MXML_OPAQUE;
} else {
return MXML_CUSTOM;
}
}
}
}
/*----------------------------------------------------------------------*/
int nexusLoadCallback(mxml_node_t * node, const char *buffer)
{
mxml_node_t *parent = NULL;
int rank, type, iDim[NX_MAXRANK];
char pNumber[80], *pStart;
long address, maxAddress;
pNXDS dataset = NULL;
int i;
parent = node->parent;
analyzeDataType(parent, &rank, &type, iDim);
if (iDim[0] == -1) {
iDim[0] = strlen(buffer);
node->value.custom.data = strdup(buffer);
node->value.custom.destroy = free;
return 0;
} else {
node->value.custom.data = createNXDataset(rank, type, iDim);
dataset = (pNXDS) node->value.custom.data;
if (dataset == NULL) {
mxml_error("Failed to allocate custom dataset");
return 1;
}
node->value.custom.destroy = destroyDataset;
}
/*
load data
*/
pStart = (char *) buffer;
maxAddress = getNXDatasetLength(dataset);
address = 0;
while ((pStart = getNextNumber(pStart, pNumber)) != NULL &&
address < maxAddress) {
putNXDatasetValueAt(dataset, address, atof(pNumber));
address++;
}
return 0;
}
/*---------------------------------------------------------------------*/
static void stringIntoBuffer(char **buffer, char **bufPtr, int *bufSize,
char *string)
{
int i;
for (i = 0; i < strlen(string); i++) {
myxml_add_char(string[i], bufPtr, buffer, bufSize);
}
}
/*--------------------------------------------------------------------*/
static void formatNumber(double value, char *txt, int txtLen,
char *format, int type)
{
switch (type) {
case NX_INT8:
case NX_UINT8:
case NX_INT16:
case NX_UINT16:
case NX_INT32:
case NX_UINT32:
snprintf(txt, txtLen, format, (int) value);
break;
case NX_INT64:
snprintf(txt, txtLen, format, (int64_t) value);
break;
case NX_UINT64:
snprintf(txt, txtLen, format, (uint64_t) value);
break;
case NX_FLOAT32:
case NX_FLOAT64:
snprintf(txt, txtLen, format, value);
break;
default:
/*assert(0); something is very wrong here */
printf("Problem\n");
break;
}
}
/*--------------------------------------------------------------------*/
static int countDepth(mxml_node_t * node)
{
int count = 0;
mxml_node_t *cur;
cur = node;
while (cur != NULL) {
count++;
cur = cur->parent;
}
count--;
return count;
}
/*---------------------------------------------------------------------*/
char *nexusWriteCallback(mxml_node_t * node)
{
int type, col;
char pNumber[80], indent[80], format[30];
char *buffer, *bufPtr;
pNXDS dataset;
int bufsize, i, length, currentLen;
/*
allocate output buffer
*/
buffer = (char *) malloc(1024 * sizeof(char));
if (buffer == NULL) {
mxml_error("Unable to allocate buffer");
return NULL;
}
memset(buffer, 0, 1024);
bufPtr = buffer;
bufsize = 1024;
dataset = (pNXDS) node->value.custom.data;
/*
prepare indentation level
*/
col = countDepth(node) * 2;
memset(indent, 0, 80);
for (i = 0; i < col; i++) {
indent[i] = ' ';
}
/*
get dataset info
*/
type = getNXDatasetType(dataset);
length = getNXDatasetLength(dataset);
if (dataset->format != NULL) {
strcpy(format, dataset->format);
} else {
getNumberFormat(type, format);
}
/*
actually get the data out
*/
currentLen = col;
myxml_add_char('\n', &bufPtr, &buffer, &bufsize);
stringIntoBuffer(&buffer, &bufPtr, &bufsize, indent);
for (i = 0; i < length; i++) {
formatNumber(getNXDatasetValueAt(dataset, i), pNumber, 79, format,
type);
if (currentLen + strlen(pNumber) > MXML_WRAP) {
/*
wrap line
*/
myxml_add_char('\n', &bufPtr, &buffer, &bufsize);
stringIntoBuffer(&buffer, &bufPtr, &bufsize, indent);
currentLen = col;
}
stringIntoBuffer(&buffer, &bufPtr, &bufsize, pNumber);
myxml_add_char(' ', &bufPtr, &buffer, &bufsize);
currentLen += strlen(pNumber) + 1;
}
myxml_add_char('\0', &bufPtr, &buffer, &bufsize);
return (char *) buffer;
}
/*------------------------------------------------------------------*/
int isDataNode(mxml_node_t * node)
{
if (mxmlElementGetAttr(node, "name") != NULL) {
return 0;
}
if (strcmp(node->value.element.name, "NXroot") == 0) {
return 0;
}
if (strcmp(node->value.element.name, "NAPIlink") == 0) {
return 0;
}
return 1;
}
/*--------------------------------------------------------------------*/
static int isTextData(mxml_node_t * node)
{
const char *attr = NULL;
int rank, type = 0, iDim[NX_MAXRANK];
if (!isDataNode(node)) {
return 0;
}
/*
test datasets
*/
attr = mxmlElementGetAttr(node, TYPENAME);
if (attr == NULL) {
return 1;
}
analyzeDim(attr, &rank, iDim, &type);
if (type == NX_CHAR) {
return 1;
} else {
return 0;
}
}
/*---------------------------------------------------------------------*/
/*
* note: not reentrant or thead safe; returns pointer to static storage
*/
const char *NXwhitespaceCallback(mxml_node_t * node, int where)
{
static char *indent = NULL;
int len;
if (strstr(node->value.element.name, "?xml") != NULL) {
return NULL;
}
if (isTextData(node)) {
if (where == MXML_WS_BEFORE_OPEN) {
len = countDepth(node) * 2 + 2;
if (indent != NULL) {
free(indent);
indent = NULL;
}
indent = (char *) malloc(len * sizeof(char));
if (indent != NULL) {
memset(indent, ' ', len);
indent[0] = '\n';
indent[len - 1] = '\0';
return (const char *) indent;
}
}
return NULL;
}
if (where == MXML_WS_BEFORE_OPEN || where == MXML_WS_BEFORE_CLOSE) {
len = countDepth(node) * 2 + 2;
if (indent != NULL) {
free(indent);
indent = NULL;
}
indent = (char *) malloc(len * sizeof(char));
if (indent != NULL) {
memset(indent, ' ', len);
indent[0] = '\n';
indent[len - 1] = '\0';
return (const char *) indent;
}
}
return NULL;
}
/*-----------------------------------------------------------------------*/
#ifdef TESTMAIN
#include <stdio.h>
int main(int argc, char *argv[])
{
mxml_node_t *root = NULL;
FILE *f;
mxmlSetCustomHandlers(nexusLoadCallback, nexusWriteCallback);
initializeNumberFormats();
/*
read test
*/
f = fopen("dmc.xml", "r");
root = mxmlLoadFile(NULL, f, nexusTypeCallback);
fclose(f);
/*
write test
*/
setNumberFormat(NX_INT32, "%8d");
setNumberFormat(NX_FLOAT32, "%8.2f");
f = fopen("dmc2.xml", "w");
mxmlSaveFile(root, f, NXwhitespaceCallback);
fclose(f);
}
#endif
Reference in New Issue View Git Blame Copy Permalink