esig_nat.c

隐马尔科夫模型工具箱

   long    size;                /* size of element (bytes) */
   long    length;              /* number of elements */

   if (file  == NULL || field == NULL || field->type == NO_TYPE)
      {
         DebugMsg(1, "ReadNativeData: NULL argument or type NO_TYPE.");
         return FALSE;
      }

   size = InternTypeSize(field->type);
   length = FieldLength(field);

   if (field->data == NULL && length != 0)
      {
         field->data = malloc(length * size);
         if (field->data == NULL)
            {
               DebugMsg(1, "ReadNativeData: allocation failure.");
               return FALSE;
            }
      }

   return (NativeRead(field->data, field->type, length, file) == length);
}


/*
 * Read items of data from a file into a block of storage indicated
 * by a pointer "data".  The number of items is given by "length",
 * and their data type is indicated by the integer code "type".
 * Return the number of successfully read items.  (A value other
 * than "length" indicates an error).
 */

static int
NativeRead(void *data,
           int  type,
           long length,
           FILE *file)
{
   if (file == NULL || data == NULL || length <= 0)
      return 0;

   if (type == ARRAY)
      {
         Array  *array = (Array *) data;
         long   n;

         for (n = 0;
              n < length && ReadNativeArray(&array[n], file);
              n++)
            { }

         return n;
      }
   else
      {
         long   size;           /* size of element (bytes) */

         size = InternTypeSize(type);
         return fread(data, size, length, file);
      }
}


/*
 * Read from file the native-mode representation of one item of type
 * ARRAY.  Store the type, rank, dimensions, and data in the members of
 * the array structure, allocating the necessary space for dimensions
 * and data.  Return TRUE for success, FALSE for failure.
 */

static int
ReadNativeArray(Array *array,
                FILE *file)
{
   short   type, rank;
   long    *dim;
   long    length;
   long    size;
   void    *data;

   if (array == NULL || file == NULL)
      return FALSE;

   /* Read type, rank. */

   if (fread(&type, sizeof(short), 1, file) != 1)
      return FALSE;             /* Couldn't get type. */

   if (fread(&rank, sizeof(short), 1, file) != 1)
      return FALSE;             /* Couldn't get rank. */

   if (rank == 0)
      dim = NULL;
   else
      {
         dim = (long *) malloc(rank * sizeof(long));
         if (dim == NULL)
            return FALSE;       /* Allocation failure. */

         if (fread(dim, sizeof(long), rank, file) != rank)
            return FALSE;       /* Couldn't get dimensions. */
      }

   length = LongProd(rank, dim);
   size = InternTypeSize(type);

   if (length == 0)
      data = NULL;
   else
      {
         data = malloc(length*size);

         if (data == NULL)
            return FALSE;       /* Allocation failure. */

         if (NativeRead(data, type, length, file) != length)
            return FALSE;
      }

   array->type = type;
   array->rank = rank;
   array->dim = dim;
   array->data = data;

   return TRUE;
}


/*
 * Read field specification in native binary format from file
 * and return pointer to it; return NULL on failure.
 */

static FieldSpec *
ReadNativeFieldSpec(FILE *file)
{
   char *name;          /* field name */
   short        type;           /* data type code */
   short        rank;           /* number of dimensions */
   int          i;              /* loop index */
   FieldSpec    *field;         /* field spec being read */
   long num_ax_names;   /* number of axis names */

   /* Read name, type, rank. */

   if (!ReadNativeString(&name, file))
      return NULL;              /* Failure getting field name. */

   if (fread(&type, sizeof(short), 1, file) != 1)
      return NULL;              /* Couldn't get type. */

   if (fread(&rank, sizeof(short), 1, file) != 1)
      return NULL;              /* Couldn't get rank. */

   /* Allocate structure. */

   field = NewFieldSpec(type, rank);
   if (field == NULL)
      return NULL;              /* Couldn't create field spec. */

   field->name = name;

   /* Read dimensions. */

   if (rank != 0 && field->dim == NULL)
      return NULL;              /* Inconsistent rank and dimensions. */

   if (fread(field->dim, sizeof(long), rank, file) != rank)
      return NULL;              /* Couldn't get dimensions. */

   /* Read units, scale, offset, axis_names. */

   if (!ReadNativeString(&field->units, file))
      return NULL;

   if (fread(&field->scale, sizeof(double), 1, file) != 1)
      return NULL;              /* Couldn't get scale. */

   if (fread(&field->offset, sizeof(double), 1, file) != 1)
      return NULL;              /* Couldn't get offset. */

   if (fread(&num_ax_names, sizeof(long), 1, file) != 1)
      return NULL;              /* Couldn't get number of axis names. */

   if (num_ax_names > rank)
      return NULL;              /* Bad value for num_ax_names. */

   if (num_ax_names != 0)
      {
         field->axis_names = (char **) malloc(rank * sizeof(char *));
         if (field->axis_names == NULL)
            return NULL;        /* Allocation failure. */

         for (i = 0; i < num_ax_names; i++)
            ReadNativeString(&field->axis_names[i], file);

         for ( ; i < rank; i++)
            field->axis_names[i] = NULL;
      }

   /* Read occurrence class. */

   if (fread(&field->occurrence, sizeof(short), 1, file) != 1)
      return NULL;              /* Couldn't get occurrence code. */

   /* Read data if required. */

   if (type != NO_TYPE
       && field->occurrence != REQUIRED && field->occurrence != OPTIONAL)
      {
         if (!ReadNativeData(field, file))
            return NULL;        /* Failure reading data. */
      }

   /* Read subfield list. */

   if (!ReadNativeFieldList(&field->subfields, file))
      {
         FreeFieldSpec(field);
         return NULL;           /* Failure getting subfields. */
      }

   return field;                /* Success. */
}


/*
 * Read character string in native binary format from file and
 * assign a pointer to it via output variable.  Return TRUE on
 * success, FALSE on failure.
 */

static int
ReadNativeString(char **string, FILE *file)
{
   long    length;
   char    *str;

   if (fread(&length, sizeof(long), 1, file) != 1)
      return FALSE;             /* Couldn't get length. */

   if (length == 0)
      str = NULL;
   else
      {
         str = (char *) malloc(length + 1);
         if (str ==  NULL)
            return FALSE;

         if (fread(str, 1, length, file) != length)
            {
               free(str);
               return FALSE;
            }

         str[length] = '\0';
      }

   if (string != NULL)
      *string = str;

   return TRUE;
}


/*
 * *** FUNCTIONS FOR OUTPUT
 */

/*
 * Write "data" member of field to file in native binary format.
 * Return TRUE on success, FALSE on failure.
 */

static int
WriteNativeData(FieldSpec *field,
                FILE      *file)
{
   long    length;              /* number of elements */

   if (file  == NULL || field == NULL || field->type == NO_TYPE)
      return FALSE;

   length = FieldLength(field);

   if (length != 0 && field->data == NULL)
      return FALSE;

   return (NativeWrite(field->data, field->type, length, file) == length);
}


/*
 * Write items of data to a file in native binary format from
 * the block of storage indicated by the pointer "data".
 * The number of items is given by "length", and their data type
 * is indicated by the integer code "type".
 * Return the number of successfully written items.  (A value other
 * than "length" indicates an error).
 */

static int
NativeWrite(void    *data,
            int     type,
            long    length,
            FILE    *file)
{
   if (file == NULL || data == NULL || length <= 0)
      return 0;

   if (type == ARRAY)
      {
         Array  *array = (Array *) data;
         long   n;

         for (n = 0;
              n < length && WriteNativeArray(&array[n], file);
              n++)
            { }

         return n;
      }
   else
      {
         long   size;           /* size of element (bytes) */

         size = InternTypeSize(type);
         return fwrite(data, size, length, file);
      }
}


/*
 * Write to "file" the native binary representation of one item of type
 * ARRAY from the location indicated by "array".
 * Return TRUE for success, FALSE for failure.
 * *
 */

static int
WriteNativeArray(Array *array,
                 FILE  *file)
{
   short   type, rank;
   long    *dim;
   void    *data;
   long    length;

   if (array == NULL || file == NULL)
      return FALSE;

   type = array->type;
   rank = array->rank;
   dim = array->dim;
   data = array->data;

   if (fwrite(&type, sizeof(short), 1, file) != 1)
      return FALSE;

   if (fwrite(&rank, sizeof(short), 1, file) != 1)
      return FALSE;

   if (rank > 0)
      {
         if (dim == NULL)
            return FALSE;

         if (fwrite(dim, sizeof(long), rank, file) != rank)
            return FALSE;
      }

   length = LongProd(rank, dim);

   if (length > 0)
      {
         if (data == NULL)
            return FALSE;

         if (NativeWrite(data, type, length, file) != length)
            return FALSE;
      }

   return TRUE;
}


/*
 * Write field specification to file in native binary format.
 * Return TRUE on success, FALSE on failure.
 */

static int
WriteNativeFieldSpec(FieldSpec  *field,
                     FILE       *file)
{
   int     rank;                /* number of dimensions */
   int     i;                   /* loop index */
   long    num_ax_names;        /* number of axis names */

   if (file == NULL || field == NULL)
      return FALSE;

   if (!WriteNativeString(field->name, file))
      return FALSE;

   if (fwrite(&field->type, sizeof(short), 1, file) != 1)
      return FALSE;

   if (fwrite(&field->rank, sizeof(short), 1, file) != 1)
      return FALSE;

   rank = field->rank;

   if (rank != 0 && field->dim == NULL)
      return FALSE;             /* Inconsistent rank and dimensions. */

   if (fwrite(field->dim, sizeof(long), rank, file) != rank)
      return FALSE;

   if (!WriteNativeString(field->units, file))
      return FALSE;

   if (fwrite(&field->scale, sizeof(double), 1, file) != 1)
      return FALSE;

   if (fwrite(&field->offset, sizeof(double), 1, file) != 1)
      return FALSE;

   num_ax_names = (field->axis_names == NULL) ? 0 : rank;
   if (fwrite(&num_ax_names, sizeof(long), 1, file) != 1)
      return FALSE;
   for (i = 0; i < num_ax_names; i++)
      if (!WriteNativeString(field->axis_names[i], file))
         return FALSE;

   if (fwrite(&field->occurrence, sizeof(short), 1, file) != 1)
      return FALSE;

   if (field->type != NO_TYPE
       && field->occurrence != REQUIRED && field->occurrence != OPTIONAL)
      {
         if (!WriteNativeData(field, file))
            return FALSE;
      }

   if (!WriteNativeFieldList(field->subfields, file))
      return FALSE;

   return TRUE;
}


/*
 * Write character string in native binary format to a file.
 *  Return TRUE on success, FALSE on failure.
 */

static int
WriteNativeString(char *string,
                  FILE *file)
{
   long    length;

   if (file == NULL)
      return FALSE;

   if (string == NULL)
      string = "";

   length = strlen(string);

   if (fwrite(&length, sizeof(long), 1, file) != 1)
      return FALSE;             /* Couldn't write length. */

   if (fwrite(string, 1, length, file) != length)
      return FALSE;

   return TRUE;
}