esig_asc.c

隐马尔科夫模型工具箱

      return FALSE;

   name[i] = '\0';

   if (ch != EOF)
      ungetc(ch, file);

   code = TypeCode(name);

   if (code == 0)
      return FALSE;

   *type = code;

   return TRUE;
}

/*
 * Read a possibly empty sequence of unsigned longs (typically
 * array dimensions) from file.  If it's nonempty, allocate an
 * array to hold the values.  Assign to *rank the number of values
 * read.  Assign to *dim a pointer to the allocated array, if any,
 * or NULL if the sequence was empty.  (But if rank or dim is NULL,
 * omit the corresponding assignment.)  Return TRUE for success,
 * FALSE for error.
 */

static int
ReadAsciiDims(short *rank, long **dim, FILE *file)
{
   long    d;
   long    *dd;
   int     r;

   /*! Check for overflow.  fscanf doesn't, and Sun's strtol doesn't. */

   if (!ReadSpace(file) || fscanf(file, "%lu", &d) != 1)
      {
         r = 0;
         dd = NULL;
      }
   else
      {
         dd = (long *) malloc(sizeof(*dd));
         if (dd == NULL)
            return FALSE;

         dd[0] = d;

         for (r = 1;
              ReadSpace(file) && fscanf(file, "%lu", &d) == 1;
              r++)
            {
               dd = (long *) realloc(dd, (r + 1) * sizeof(*dd));
               if (dd == NULL)
                  return FALSE;

               dd[r] = d;
            }
      }

   if (rank != NULL)
      *rank = r;

   if (dim != NULL)
      *dim = dd;

   return TRUE;
}


/*
 * Read Ascii representations of the miscellaneous attributes
 * (units, scale, offset, axis_names) from file, and output the
 * values found by assignment to the variables *units, *scale, *offset,
 * and *axis_names (if defined).  If no explicit representation
 * for an attribute is found, omit the corresponding assignment.
 * (The caller is assumed to have assigned default values to the
 * variables before calling ReadAsciiMisc).  If any of the arguments
 * units, scale, offset, and axis_names is NULL, omit the corresponding
 * assignment.  Return TRUE upon success and FALSE in case of error.
 */

static int
ReadAsciiMisc(int rank, char **units, double *scale,
              double *offset, char ***axis_names, FILE *file)
{
   /*
    * Length of longest attribute name ("axis_names"), including
    * terminal null character.
    */
#define MAX_ATTR        11

   char    attr[MAX_ATTR];
   int     ch;
   int     i;
   char    *un;
   double  sc;
   double  offsetr;
   char    **ax;
   char    got_units = FALSE;
   char    got_scale = FALSE;
   char    got_offset = FALSE;
   char    got_axis_names = FALSE;

   ch = GetNonSpace(file);

   if (ch != '{')
      {
         ungetc(ch, file);
         return TRUE;
      }

   do {
      ch = GetNonSpace(file);
      for (i = 0; i < MAX_ATTR && (islower(ch) || ch == '_'); i++)
         {
            attr[i] = ch;
            ch = getc(file);
         }

      if (i == MAX_ATTR)
         return FALSE;

      attr[i] = '\0';

      ch = SkipSpace(ch, file);
      if (ch != ':')
         return FALSE;

      if (strcmp(attr, "units") == 0)
         {
            if (!got_units++
                && ReadAsciiString(&un, file))
               {
                  if (units != NULL)
                     *units = un;
               }
            else
               return FALSE;
         }
      else if (strcmp(attr, "scale") == 0)
         {
            if (!got_scale++
                && ReadAsciiDouble(&sc, file))
               {
                  if (scale != NULL)
                     *scale = sc;
               }
            else
               return FALSE;
         }
      else if (strcmp(attr, "offset") == 0)
         {
            if (!got_offset++
                && ReadAsciiDouble(&offsetr, file))
               {
                  if (offset != NULL)
                     *offset = offsetr;
               }
            else
               return FALSE;
         }
      else if (strcmp(attr, "axis_names") == 0)
         {
            if (!got_axis_names++
                && ReadAsciiAxisNames(&ax, rank, file))
               {
                  if (axis_names != NULL)
                     *axis_names = ax;
               }
            else
               return FALSE;
         }
      else
         return FALSE;

      ch = GetNonSpace(file);

   } while (ch == ';');

   if (ch != '}')
      return FALSE;

   return TRUE;

#undef MAX_ATTR
}


/*
 * Read from file a string constant consisting of Ascii printing characters
 * and including surrounding double quote characters("").  Interpret escape
 * sequences \\, \?, \', and \"  by removing the backslash.  Allocate space
 * to hold the string value, including terminating null character.  Store
 * a pointer to the string in the variable whose address is given by
 * string (unless string is NULL).  Return TRUE on success, FALSE on
 * failure.
 */

static int
ReadAsciiString(char **string, FILE *file)
{
   int     ch;
   char    *str = NULL;
   long    alloc_len = 0;
   long    len = 0;

   ch = GetNonSpace(file);
   if (ch != '"')
      return FALSE;

   for (ch = getc(file); isprint(ch) && ch != '"'; ch = getc(file))
      {
         if (ch == '\\')
            {
               ch = getc(file);

               switch (ch)
                  {
                  case '\\':    /* fall through */
                  case '?':     /* fall through */
                  case '\'':    /* fall through */
                  case '"':
                     if (!AddChar(ch, &str, &alloc_len, &len))
                        return FALSE;
                     break;
                  default:
                     free(str);
                     return FALSE;
                  }
            }
         else if (!AddChar(ch, &str, &alloc_len, &len))
            return FALSE;

      }

   if (ch != '"' || !AddChar('\0', &str, &alloc_len, &len))
      {
         free(str);
         return FALSE;
      }

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

   return TRUE;
}


/*
 * Read a floating-point constant (with optional leading whitespace)
 * from file and assign the value to the variable whose address
 * is given by x.
 */

static int
ReadAsciiDouble(double *x, FILE *file)
{
   return (ReadOptSpace(file) && fscanf(file, "%lf", x) == 1);
}


/*
 * Read from file a comma-separated list with at most "rank" members,
 * each of which is either a C identifier or empty.  (This construct
 * occurs in the Ascii form of a specification for the miscellaneous
 * field attribute "axis_names".)  Allocate a pointer array of length
 * rank (or NULL if rank is 0) and assign to its elements:
 * - a string pointer for each identifier on the list,
 * - a NULL for each empty member of the list
 * - a NULL for each array position beyond the end of the list.
 * Store a pointer to the array (or NULL) in the variable whose
 * address is given by "axis_names" (unless that argument is NULL).
 * Return TRUE for success, FALSE for failure.
 */

static int
ReadAsciiAxisNames(char ***axis_names, int rank, FILE *file)
{
   char    **ax;
   int     ch;
   char    *str;
   long    len;
   long    alloc_len;
   int     i;

   if (rank == 0)
      {
         ax = NULL;

         ch = GetNonSpace(file);

         if (isalpha(ch) || ch == '_' || ch == ',')
            return FALSE;
      }
   else
      {
         ax = (char **) malloc(rank * sizeof(*ax));
         if (ax == NULL)
            return FALSE;

         i = 0;

         do {
            ch = GetNonSpace(file);

            if (isalpha(ch) || ch == '_')
               {
                  str = NULL;
                  len = 0;
                  alloc_len = 0;

                  if (!AddChar(ch, &str, &alloc_len, &len))
                     {
                        FreeAxisNames(ax, rank);
                        return FALSE;
                     }

                  for (ch = getc(file);
                       isalnum(ch) || ch == '_';
                       ch = getc(file))
                     {
                        if (!AddChar(ch, &str, &alloc_len, &len))
                           {
                              FreeAxisNames(ax, rank);
                              return FALSE;
                           }
                     }

                  if (!AddChar('\0', &str, &alloc_len, &len))
                     {
                        FreeAxisNames(ax, rank);
                        return FALSE;
                     }

                  ax[i] = str;

                  ch = SkipSpace(ch, file);
               }
            else
               ax[i] = NULL;

            i++;

         } while (ch == ',' && i < rank);

         if (ch == ',')
            {
               FreeAxisNames(ax, rank);
               return FALSE;
            }
         else
            for ( ; i < rank; i++)
               ax[i] = NULL;
      }

   ungetc(ch, file);

   if (axis_names != NULL)
      *axis_names = ax;

   return TRUE;
}


/*
 * Read from file an "occurrence" construct (which occurs in Ascii field
 * specifications: <g>, <r>, <o>, <v), or <i>.  Assign the corresponding code
 * (GLOBAL, REQUIRED, OPTIONAL, VIRTUAL, or INCLUDED) to the variable
 * whose address is occurrence (unless that argument is NULL).
 * Return TRUE for success, FALSE for failure.
 */

static int
ReadAsciiOccurrence(short *occurrence, FILE *file)
{
   int     ch;
   int     occ;

   ch = GetNonSpace(file);

   if (ch != '<')
      return FALSE;

   switch (getc(file))
      {
      case 'g':
         occ = GLOBAL;
         break;
      case 'r':
         occ = REQUIRED;
         break;
      case 'o':
         occ = OPTIONAL;
         break;
      case 'v':
         occ = VIRTUAL;
         break;
      case 'i':
         occ = INCLUDED;
         break;
      default:
         return FALSE;
      }

   if (getc(file) != '>')
      return FALSE;

   if (occurrence != NULL)
      *occurrence = occ;

   return TRUE;
}


/*
 * Read from "file" a sequence of length "length" of values of data
 * type "type" (in Ascii representation); store the results starting
 * at the location indicated by "datap".  Return the number of values
 * successfully read, which will be less than "length" in case of
 * error.
 */

static int
AsciiRead(void  *datap,
          int   type,
          long  length,
          FILE  *file)
{
   long    j;
   int     ch;

   if (length == 0)
      return TRUE;

   if (!ReadOptSpace(file))
      return 0;

   j = 0;

   switch (type)
      {
      case ARRAY:
         {
            Array   *data = (Array *) datap;

            do {
               ch = getc(file);

               if (ch != '(')
                  return j;

               if (!ReadOptSpace(file)
                   || !ReadAsciiArray(&data[j], file))
                  {
                     return j;
                  }

               ch = GetNonSpace(file);
               if (ch != ')')
                  return j;

            } while (++j < length && ReadSpace(file));
         }
         break;
      case DOUBLE:
         {
            double  *data = (double *) datap;

            do {
               if (fscanf(file, "%lf", &data[j]) != 1)
                  return j;
            } while (++j < length && ReadSpace(file));
         }
         break;
      case FLOAT:
         {
            float   *data = (float *) datap;

            do {
               if (fscanf(file, "%f", &data[j]) != 1)
                  return j;

            } while (++j < length && ReadSpace(file));
         }
         break;
      case LONG:
         {
            long    *data = (long *) datap;

            do {
               if (fscanf(file, "%ld", &data[j]) != 1)
                  return j;