/* Frees all memory associated with the heap and its data */
airHeap *airHeapNuke(airHeap *h) {
if (h!=NULL) {
airArrayNuke(h->key_a);
if (h->data_a!=NULL) airArrayNuke(h->data_a);
airArrayNuke(h->idx_a);
airArrayNuke(h->invidx_a);
free(h);
}
return NULL;
}
echoScene *
echoSceneNix(echoScene *scene) {
if (scene) {
airArrayNuke(scene->catArr);
airArrayNuke(scene->rendArr);
airArrayNuke(scene->lightArr);
airArrayNuke(scene->nrrdArr);
/* don't touch envmap nrrd */
airFree(scene);
}
return NULL;
}
void
airMopDone(airArray *arr, int error)
{
airMop *mops;
int i;
/*
printf("airMopDone(%p): hello, %s\n", (void*)arr, error ? "error" : "okay");
*/
if (arr)
{
mops = (airMop *)arr->data;
for (i=arr->len-1; i>=0; i--)
{
if (mops[i].ptr
&& (airMopAlways == mops[i].when
|| (airMopOnError == mops[i].when && error)
|| (airMopOnOkay == mops[i].when && !error)))
{
mops[i].mop(mops[i].ptr);
}
}
airArrayNuke(arr);
/*
printf("airMopDone(%p): done!\n", (void*)arr);
*/
}
return;
}
int
tkwbReadFileToString(char **strP, int *hitEOF, FILE *file, char *stop) {
char **all, line[AIR_STRLEN_HUGE];
airArray *allArr;
unsigned int allLen;
unsigned int lineLen, lineIdx, totalLen;
_tkwbU uu;
uu.pc = &all;
allArr = airArrayNew(uu.v, &allLen, sizeof(char*), tkwbArrayIncr);
airArrayPointerCB(allArr, airNull, airFree);
lineLen = airOneLine(file, line, AIR_STRLEN_HUGE);
totalLen = 0;
while (lineLen && (!( airStrlen(stop) && !strcmp(line, stop) )) ) {
lineIdx = airArrayLenIncr(allArr, 1); /* HEY error checking */
all[lineIdx] = (char *)calloc(strlen(line) + strlen("\n") + 1,
sizeof(char));
sprintf(all[lineIdx], "%s\n", line);
totalLen += strlen(line) + 1;
lineLen = airOneLine(file, line, AIR_STRLEN_HUGE);
}
if (hitEOF) {
*hitEOF = !lineLen;
}
*strP = (char*)calloc(totalLen+1, sizeof(char));
strcpy(*strP, "");
for (lineIdx=0; lineIdx<allLen; lineIdx++) {
strcat(*strP, all[lineIdx]);
}
airArrayNuke(allArr);
return 0;
}
char *
_nrrdGetQuotedString(char **hP, int useBiff) {
char me[]="_nrrdGetQuotedString", err[BIFF_STRLEN], *h, *buff, *ret;
airArray *buffArr;
int pos;
_chpu uu;
h = *hP;
/* skip past space */
/* printf("!%s: h |%s|\n", me, h);*/
h += strspn(h, _nrrdFieldSep);
/* printf("!%s: h |%s|\n", me, h);*/
/* make sure we have something */
if (!*h) {
sprintf(err, "%s: hit end of string before seeing opening \"", me);
biffMaybeAdd(NRRD, err, useBiff); return NULL;
}
/* make sure we have a starting quote */
if ('"' != *h) {
sprintf(err, "%s: didn't start with \"", me);
biffMaybeAdd(NRRD, err, useBiff); return NULL;
}
h++;
/* parse string until end quote */
buff = NULL;
uu.c = &buff;
buffArr = airArrayNew(uu.v, NULL, sizeof(char), 2);
if (!buffArr) {
sprintf(err, "%s: couldn't create airArray", me);
biffMaybeAdd(NRRD, err, useBiff); return NULL;
}
pos = airArrayLenIncr(buffArr, 1); /* pos should get 0 */
while (h[pos]) {
/* printf("!%s: h+%d |%s|\n", me, pos, h+pos); */
if ('\"' == h[pos]) {
break;
}
if ('\\' == h[pos] && '\"' == h[pos+1]) {
h += 1;
}
buff[pos] = h[pos];
pos = airArrayLenIncr(buffArr, 1);
}
if ('\"' != h[pos]) {
sprintf(err, "%s: didn't see ending \" soon enough", me);
biffMaybeAdd(NRRD, err, useBiff); return NULL;
}
h += pos + 1;
buff[pos] = 0;
ret = airStrdup(buff);
airArrayNuke(buffArr);
*hP = h;
return ret;
}
void
_biffNuke(void) {
if (_biffAA) {
/* setting to NULL is needed to put biff back in initial state
so that next calls to biff re-trigger _biffInit() */
_biffAA = airArrayNuke(_biffAA);
}
return;
}
/*
** _biffNukeEntry()
**
** deletes given entry, and all info contained therein
*/
void
_biffNukeEntry(_biffEntry *ent) {
if (ent) {
airArrayLenSet(ent->AA, 0);
airArrayNuke(ent->AA);
free(ent);
}
return;
}
void
_bmsgFinish(void) {
if (_bmsgArr) {
/* setting _bmsgArr to NULL is needed to put biff back in initial state
so that next calls to biff re-trigger _bmsgStart() */
_bmsgArr = airArrayNuke(_bmsgArr);
}
return;
}
biffMsg *
biffMsgNix(biffMsg *msg) {
if (msg && msg != biffMsgNoop) {
airFree(msg->key);
airArrayLenSet(msg->errArr, 0); /* frees all msg->err[i] */
airArrayNuke(msg->errArr);
airFree(msg);
}
return NULL;
}
/*
** bins own the points they contain- so this frees them
*/
void
_pullBinDone(pullBin *bin) {
unsigned int idx;
for (idx=0; idx<bin->pointNum; idx++) {
bin->point[idx] = pullPointNix(bin->point[idx]);
}
bin->pointArr = airArrayNuke(bin->pointArr);
bin->neighBin = (pullBin **)airFree(bin->neighBin);
return;
}
NrrdIoState *
nrrdIoStateNix(NrrdIoState *nio) {
nio->path = (char *)airFree(nio->path);
nio->base = (char *)airFree(nio->base);
nio->line = (char *)airFree(nio->line);
nio->dataFNFormat = (char *)airFree(nio->dataFNFormat);
nio->dataFNArr = airArrayNuke(nio->dataFNArr);
/* the NrrdIoState never owned nio->oldData; we don't free it */
airFree(nio); /* no NULL assignment, else compile warnings */
return NULL;
}
/*
** nio->byteSkip < 0 functionality contributed by Katharina Quintus
*/
static int
_nrrdEncodingGzip_read(FILE *file, void *_data, size_t elNum,
Nrrd *nrrd, NrrdIoState *nio) {
static const char me[]="_nrrdEncodingGzip_read";
#if TEEM_ZLIB
size_t sizeData, sizeRed;
int error;
long int bi;
unsigned int didread, sizeChunk, maxChunk;
char *data;
gzFile gzfin;
airPtrPtrUnion appu;
sizeData = nrrdElementSize(nrrd)*elNum;
/* Create the gzFile for reading in the gzipped data. */
if ((gzfin = _nrrdGzOpen(file, "rb")) == Z_NULL) {
/* there was a problem */
biffAddf(NRRD, "%s: error opening gzFile", me);
return 1;
}
/* keeps track of how many bytes have been successfully read in */
sizeRed = 0;
/* zlib can only handle data sizes up to UINT_MAX ==> if there's more than
UINT_MAX bytes to read in, we read in in chunks. However, we wrap a value
_nrrdZlibMaxChunk around UINT_MAX for testing purposes. Given how
sizeChunk is used below, we also cap chunk size at _nrrdZlibMaxChunk/2 to
prevent overflow. */
maxChunk = _nrrdZlibMaxChunk/2;
sizeChunk = AIR_CAST(unsigned int, AIR_MIN(sizeData, maxChunk));
if (nio->byteSkip < 0) {
/* We don't know the size of the size to skip before the data, so
decompress the data first into a temporary memory buffer. Then
the byteskipping is then just memcpy-ing the appropriate region
of memory from "buff" into the given "_data" pointer */
char *buff;
airArray *buffArr;
long backwards;
/* setting the airArray increment to twice the chunk size means that for
headers that are small compared to the data, the airArray never
actually has to reallocate. The unit is 1 because we are managing
the reading in terms of bytes (sizeof(char)==1 by definition) */
buff = NULL;
appu.c = &buff;
buffArr = airArrayNew(appu.v, NULL, 1, 2*sizeChunk);
airArrayLenSet(buffArr, sizeChunk);
if (!( buffArr && buffArr->data )) {
biffAddf(NRRD, "%s: couldn't initialize airArray\n", me);
return 1;
}
/* we keep reading in chunks as long as there hasn't been an error,
and we haven't hit EOF (EOF signified by read == 0). Unlike the
code below (for positive byteskip), we are obligated to read until
the bitter end, and can't update sizeChunk to encompass only the
required data. */
while (!(error = _nrrdGzRead(gzfin, buff + sizeRed,
sizeChunk, &didread))
&& didread > 0) {
sizeRed += didread;
if (didread >= sizeChunk) {
/* we were able to read as much data as we requested, maybe there is
more, so we need to make our temp buffer bigger */
unsigned int newlen = buffArr->len + sizeChunk;
if (newlen < buffArr->len) {
biffAddf(NRRD, "%s: array size will exceed uint capacity", me);
return 1;
}
airArrayLenSet(buffArr, newlen);
if (!buffArr->data) {
biffAddf(NRRD, "%s: couldn't re-allocate data buffer", me);
return 1;
}
}
}
if (error) {
biffAddf(NRRD, "%s: error reading from gzFile", me);
return 1;
}
/* backwards is (positive) number of bytes AFTER data that we ignore */
backwards = -nio->byteSkip - 1;
if (sizeRed < sizeData + AIR_CAST(size_t, backwards)) {
char stmp1[AIR_STRLEN_SMALL], stmp2[AIR_STRLEN_SMALL];
biffAddf(NRRD, "%s: expected %s bytes but received only %s", me,
airSprintSize_t(stmp1, sizeData + AIR_CAST(size_t, backwards)),
airSprintSize_t(stmp2, sizeRed));
return 1;
}
/* also handles nio->byteSkip == -N-1 signifying extra N bytes at end */
memcpy(_data, buff + sizeRed - sizeData - backwards, sizeData);
airArrayNuke(buffArr);
} else {
/* no negative byteskip: after byteskipping, we can read directly
into given data buffer */
if (nio->byteSkip > 0) {
for (bi=0; bi<nio->byteSkip; bi++) {
unsigned char b;
/* Check to see if a single byte was able to be read. */
if (_nrrdGzRead(gzfin, &b, 1, &didread) != 0 || didread != 1) {
biffAddf(NRRD, "%s: hit an error skipping byte %ld of %ld",
me, bi, nio->byteSkip);
return 1;
}
}
}
/* Pointer to chunks as we read them. */
data = AIR_CAST(char *, _data);
while (!(error = _nrrdGzRead(gzfin, data, sizeChunk, &didread))
&& didread > 0) {
/* Increment the data pointer to the next available chunk. */
data += didread;
sizeRed += didread;
/* We only want to read as much data as we need, so we need to check
to make sure that we don't request data that might be there but that
we don't want. This will reduce sizeChunk when we get to the last
block (which may be smaller than the original sizeChunk). */
if (sizeData >= sizeRed
&& sizeData - sizeRed < sizeChunk) {
sizeChunk = AIR_CAST(unsigned int, sizeData - sizeRed);
}
}
if (error) {
biffAddf(NRRD, "%s: error reading from gzFile", me);
return 1;
}
/* Check to see if we got out as much as we thought we should. */
if (sizeRed != sizeData) {
char stmp1[AIR_STRLEN_SMALL], stmp2[AIR_STRLEN_SMALL];
biffAddf(NRRD, "%s: expected %s bytes but received %s", me,
airSprintSize_t(stmp1, sizeData),
airSprintSize_t(stmp2, sizeRed));
return 1;
}
}
/*
** nio->byteSkip < 0 functionality contributed by Katharina Quintus
*/
int
_nrrdEncodingGzip_read(FILE *file, void *_data, size_t elNum,
Nrrd *nrrd, NrrdIoState *nio) {
char me[]="_nrrdEncodingGzip_read", err[BIFF_STRLEN];
#if TEEM_ZLIB
size_t sizeData, sizeRed, sizeChunk;
int error;
long int bi;
unsigned int read;
char *data;
gzFile gzfin;
ptrHack hack;
sizeData = nrrdElementSize(nrrd)*elNum;
/* Create the gzFile for reading in the gzipped data. */
if ((gzfin = _nrrdGzOpen(file, "rb")) == Z_NULL) {
/* there was a problem */
sprintf(err, "%s: error opening gzFile", me);
biffAdd(NRRD, err);
return 1;
}
/* keeps track of how many bytes have been successfully read in */
sizeRed = 0;
/* zlib can only handle data sizes up to UINT_MAX ==> if there's more
than UINT_MAX bytes to read in, we read in in chunks */
sizeChunk = AIR_MIN(sizeData, UINT_MAX);
if (nio->byteSkip < 0) {
/* We don't know the size of the size to skip before the data, so
decompress the data first into a temporary memory buffer. Then
the byteskipping is then just memcpy-ing the appropriate region
of memory from "buff" into the given "_data" pointer */
char *buff;
airArray *buffArr;
/* setting the airArray increment to twice the chunk size means that for
headers that are small compared to the data, the airArray never
actually has to reallocate. The unit is 1 because we are managing
the reading in terms of bytes (sizeof(char)==1 by definition) */
buff = NULL;
hack.c = &buff;
buffArr = airArrayNew(hack.v, NULL, 1, 2*sizeChunk);
airArrayLenSet(buffArr, sizeChunk);
if (!( buffArr && buffArr->data )) {
sprintf(err, "%s: couldn't initialize airArray\n", me);
biffAdd(NRRD, err);
return 1;
}
/* we keep reading in chunks as long as there hasn't been an error,
and we haven't hit EOF (EOF signified by read == 0). Unlike the
code below (for positive byteskip), we are obligated to read until
the bitter end, and can't update sizeChunk to encompass only the
required data. Cast on third arg ok because of AIR_MIN use above */
while (!(error = _nrrdGzRead(gzfin, buff + sizeRed,
AIR_CAST(unsigned int, sizeChunk),
&read))
&& read > 0) {
sizeRed += read;
if (read >= sizeChunk) {
/* we were able to read as much data as we requested, maybe there is
more, so we need to make our temp buffer bigger */
airArrayLenIncr(buffArr, sizeChunk);
if (!buffArr->data) {
sprintf(err, "%s: couldn't re-allocate data buffer", me);
biffAdd(NRRD, err);
return 1;
}
}
}
if (error) {
sprintf(err, "%s: error reading from gzFile", me);
biffAdd(NRRD, err);
return 1;
}
if (sizeRed < sizeData + (-nio->byteSkip - 1)) {
sprintf(err, "%s: expected " _AIR_SIZE_T_CNV " bytes and received only "
_AIR_SIZE_T_CNV " bytes", me,
AIR_CAST(size_t, sizeData + (-nio->byteSkip - 1)), sizeRed);
biffAdd(NRRD, err);
return 1;
}
/* also handles nio->byteSkip == -N-1 signifying extra N bytes at end */
memcpy(_data, buff + sizeRed - sizeData - (-nio->byteSkip - 1), sizeData);
airArrayNuke(buffArr);
} else {
