readc.c

Go to the documentation of this file.

 
#ifdef USE_SHIFT_RFIO
#include <shift.h>
// or this??
// // needed?#define _LARGEFILE64_SOURCE
//#include <sys/types.h>
//#include "rfio_api.h"
#else
#include <stdio.h>
#endif
#include <stdlib.h>
#ifdef USE_ZLIB
#include <zlib.h>
#endif
 
/* ________ global variables used for file handling __________ */
 
#ifdef USE_ZLIB
gzFile *files;   
#else
FILE **files;     
#endif
 
unsigned int maxNumFiles;      
unsigned int numAllFiles;      
 
/*______________________________________________________________*/
 
void initc(int nFiles) {
        maxNumFiles = nFiles;
#ifdef USE_ZLIB
        printf(" initc: using zlib version %s\n",ZLIB_VERSION);
        files = (gzFile *) malloc(sizeof(gzFile *)*maxNumFiles);
#else
        files = (FILE **) malloc(sizeof(FILE *) * maxNumFiles);
#endif
        {
                int i = 0;
                for (; i < maxNumFiles; ++i) {
                        files[i] = 0;
                }
        }
        numAllFiles = 0;
}
 
/*______________________________________________________________*/
void openc(const char *fileName, int lfn, int nFileIn, int *errorFlag)
{
        /* No return value since to be called as subroutine from fortran */
 
        if (!errorFlag)
                return; /* 'printout' error? */
 
        int fileIndex = nFileIn - 1; /* index of specific file */
        if (fileIndex < 0) fileIndex = numAllFiles; /* next one */
 
        if (fileIndex >= maxNumFiles) {
                        *errorFlag = 1;
        } else {
                char *s = malloc(lfn+1);
                int i;
                for ( i=0; i<lfn; i++ ) {
                        s[i] = fileName[i];
                }
                s[lfn] = '\0';
#ifdef USE_ZLIB
                files[fileIndex] = gzopen(s, "rb");
                if (!files[fileIndex]) {
                        *errorFlag = 2;
                } else
#else
                files[fileIndex] = fopen(s, "rb");
                if (!files[fileIndex]) {
                        *errorFlag = 2;
                } else if (ferror(files[fileIndex])) {
                        fclose(files[fileIndex]);
                        files[fileIndex] = 0;
                        *errorFlag = 3;
                } else
#endif
                {
                        ++numAllFiles; /* We have one more opened file! */
                        *errorFlag = 0;
                }
 
                free(s);
        }
}
 
/*______________________________________________________________*/
 
void closec(int nFileIn) {
        int fileIndex = nFileIn - 1; /* index of current file */
        if (fileIndex < 0)
                return; /* no file opened at all... */
#ifdef USE_ZLIB
        gzclose(files[fileIndex]);
#else
        fclose(files[fileIndex]);
#endif
        files[fileIndex] = 0;
}
 
/*______________________________________________________________*/
 
void resetc(int nFileIn) {
        int fileIndex = nFileIn - 1; /* index of current file */
        if (fileIndex < 0)
                return; /* no file opened at all... */
#ifdef USE_ZLIB
        gzrewind(files[fileIndex]);
#else
        /* rewind(files[fileIndex]);  Does not work with rfio, so call: */
        fseek(files[fileIndex], 0L, SEEK_SET);
        clearerr(files[fileIndex]); /* These two should be the same as rewind...
 */
#endif
}
 
/*______________________________________________________________*/
 
void readc(double *bufferDouble, float *bufferFloat, int *bufferInt,
                int *lengthBuffers, int nFileIn, int *errorFlag) {
        /* No return value since to be called as subroutine from fortran,
         negative *errorFlag are errors, otherwise fine.
 
         *nFileIn: number of the file the record is read from,
         starting from 1 (not 0)
         */
        int doublePrec = 0;
 
        if (!errorFlag)
                return;
        *errorFlag = 0;
        int fileIndex = nFileIn - 1; /* index of current file */
        if (fileIndex < 0)
                return; /* no file opened at all... */
        if (!bufferFloat || !bufferInt || !lengthBuffers) {
                *errorFlag = -1;
                return;
        }
 
        /* read length of 'record' */
        int recordLength = 0; /* becomes number of words following in file */
#ifdef USE_ZLIB
        int nCheckR = gzread(files[fileIndex], &recordLength, sizeof(recordLength));
        if (gzeof(files[fileIndex])) {
                /* gzrewind(files[fileIndex]); CHK: moved to binrwd */
                *errorFlag = 0; /* Means EOF of file. */
                return;
        }
        if (recordLength<0) {
                doublePrec = 1;
                recordLength = -recordLength;
        }
        if (sizeof(recordLength) != nCheckR) {
                printf("readc: problem reading length of record file %d\n", fileIndex);
                *errorFlag = -2;
                return;
        }
 
        if (recordLength/2 > *lengthBuffers) {
                /*     printf("readC: given buffers too short (%d, need > %d)\n", *lengthBuffers,
                 recordLength/2); */
                /* skip floats */
                int i=0;
                if (doublePrec) {
                        for (; i< recordLength/2; ++i)
                        {
                                int nCheckD = gzread(files[fileIndex], bufferDouble, sizeof(bufferDouble[0]));
                                if (nCheckD != sizeof(bufferDouble[0])) {
                                        printf("readc: problem with stream or EOF skipping doubles\n");
                                        *errorFlag = -32;
                                        return;
                                }
                        }
                } else {
                        for (; i< recordLength/2; ++i)
                        {
                                int nCheckF = gzread(files[fileIndex], bufferFloat, sizeof(bufferFloat[0]));
                                if (nCheckF != sizeof(bufferFloat[0])) {
                                        printf("readc: problem with stream or EOF skipping floats\n");
                                        *errorFlag = -8;
                                        return;
                                }
                        }
                }
                i=0;
                /* skip ints */
                for (; i< recordLength/2; ++i)
                {
                        int nCheckI = gzread(files[fileIndex], bufferInt, sizeof(bufferInt[0]));
                        if (nCheckI != sizeof(bufferInt[0])) {
                                printf("readc: problem with stream or EOF skipping ints\n");
                                *errorFlag = -16;
                                return;
                        }
                }
 
                *errorFlag = -4;
                *lengthBuffers = recordLength/2;
                return;
        } else {
                *lengthBuffers = recordLength/2;
        }
 
        /* read floats (i.e. derivatives + value + sigma) */
        if (doublePrec) {
                int nCheckD = gzread(files[fileIndex], bufferDouble, *lengthBuffers*8);
                if (nCheckD != *lengthBuffers*8) {
                        printf("readc: problem with stream or EOF reading doubles\n");
                        *errorFlag = -32;
                        return;
                }
        } else {
                int nCheckF = gzread(files[fileIndex], bufferFloat, *lengthBuffers*4);
                if (nCheckF != *lengthBuffers*4) {
                        printf("readc: problem with stream or EOF reading floats\n");
                        *errorFlag = -8;
                        return;
                }
                int i=0;
                for (; i< recordLength/2; ++i) bufferDouble[i] = (double) bufferFloat[i];
        }
 
        /* read ints (i.e. parameter labels) */
        int nCheckI = gzread(files[fileIndex], bufferInt, *lengthBuffers*4);
        if (nCheckI != *lengthBuffers*4) {
                printf("readc: problem with stream or EOF reading ints\n");
                *errorFlag = -16;
                return;
        }
#else
        size_t nCheckR = fread(&recordLength, sizeof(recordLength), 1,
                        files[fileIndex]);
        if (feof(files[fileIndex])) {
                /* rewind(files[fileIndex]);  Does not work with rfio, so call: */
                /* fseek(files[fileIndex], 0L, SEEK_SET); CHK: moved to binrwd
                clearerr(files[fileIndex]); These two should be the same as rewind... */
                *errorFlag = 0; /* Means EOF of file. */
                return;
        }
 
        if (1 != nCheckR || ferror(files[fileIndex])) {
                printf("readc: problem reading length of record, file %d\n", fileIndex);
                *errorFlag = -2;
                return;
        }
 
        if (recordLength < 0) {
                doublePrec = 1;
                recordLength = -recordLength;
        }
        if (recordLength / 2 > *lengthBuffers) {
                /* printf("readC: given buffers too short (%d, need > %d)\n", *lengthBuffers,
                 recordLength/2); */
                /* skip floats */
                int i = 0;
                if (doublePrec) {
                        for (; i < recordLength / 2; ++i) {
                                size_t nCheckD = fread(bufferDouble, sizeof(bufferDouble[0]), 1,
                                                files[fileIndex]);
                                if (ferror(files[fileIndex]) || feof(files[fileIndex])
                                                || nCheckD != *lengthBuffers) {
                                        printf(
                                                        "readc: problem with stream or EOF skipping doubles\n");
                                        *errorFlag = -32;
                                        return;
                                }
                        }
                } else {
                        for (; i < recordLength / 2; ++i) {
                                size_t nCheckF = fread(bufferFloat, sizeof(bufferFloat[0]), 1,
                                                files[fileIndex]);
                                if (ferror(files[fileIndex]) || feof(files[fileIndex])
                                                || nCheckF != *lengthBuffers) {
                                        printf(
                                                        "readc: problem with stream or EOF skipping floats\n");
                                        *errorFlag = -8;
                                        return;
                                }
                        }
                }
                i = 0;
                /* skip ints */
                for (; i < recordLength / 2; ++i) {
                        size_t nCheckI = fread(bufferInt, sizeof(bufferInt[0]), 1,
                                        files[fileIndex]);
                        if (ferror(files[fileIndex]) || feof(files[fileIndex])
                                        || nCheckI != *lengthBuffers) {
                                printf("readc: problem with stream or EOF skiping ints\n");
                                *errorFlag = -16;
                                return;
                        }
                }
 
                *errorFlag = -4;
                *lengthBuffers = recordLength / 2;
                return;
        } else {
                *lengthBuffers = recordLength / 2;
        }
 
        /* read floats (i.e. derivatives + value + sigma) */
        if (doublePrec) {
                size_t nCheckD = fread(bufferDouble, sizeof(bufferDouble[0]),
                                *lengthBuffers, files[fileIndex]);
                if (ferror(files[fileIndex]) || feof(files[fileIndex])
                                || nCheckD != *lengthBuffers) {
                        printf("readc: problem with stream or EOF reading doubles\n");
                        *errorFlag = -32;
                        return;
                }
        } else {
                size_t nCheckF = fread(bufferFloat, sizeof(bufferFloat[0]),
                                *lengthBuffers, files[fileIndex]);
                if (ferror(files[fileIndex]) || feof(files[fileIndex])
                                || nCheckF != *lengthBuffers) {
                        printf("readc: problem with stream or EOF reading floats\n");
                        *errorFlag = -8;
                        return;
                }
                int i = 0;
                for (; i < recordLength / 2; ++i)
                        bufferDouble[i] = (double) bufferFloat[i];
        }
        /* read ints (i.e. parameter labels) */
        size_t nCheckI = fread(bufferInt, sizeof(bufferInt[0]), *lengthBuffers,
                        files[fileIndex]);
        if (ferror(files[fileIndex]) || feof(files[fileIndex])
                        || nCheckI != *lengthBuffers) {
                printf("readc: problem with stream or EOF reading ints\n");
                *errorFlag = -16;
                return;
        }
#endif
 
        *errorFlag = 4 * (doublePrec + 1);
}