scanner.c

General Hidden Markov Model Library 一个通用的隐马尔科夫模型的C代码库

      if (s->eof || ((!s->c || s->c == '\n') && !s->esc)) {
        ighmm_scanner_error (s, "String not closed");
        goto STOP;
      }
      if (i + 1 == maxlen) {
        ARRAY_REALLOC (val, maxlen + 128);
        maxlen += 128;
      }
      if (s->c || len)
        val[i++] = s->c;
      if (cmode) {
        if (scanner_nextcchar (s))
          goto STOP;
      }
      else {
        if (scanner_nextchar (s, 1))
          goto STOP;
      }
    }

    if (ighmm_scanner_consume (s, '"'))
      goto STOP;
    if (scanner_skipspace (s))
      goto STOP;
  }
  val[i++] = 0;
  ARRAY_REALLOC (val, i);
  if (len)
    *len = i;
  return (val);

STOP:     /* Label STOP from ARRAY_[CM]ALLOC */
  m_free (val);
  return (NULL);
# undef CUR_PROC
}                               /* ighmm_scanner_get_str */

/*============================================================================*/
char *ighmm_scanner_get_path (scanner_t * s)
{
#define CUR_PROC "ighmm_scanner_get_path"
  char *res = scanner_get_string (s);
  char *p;
# if defined(_PPC) || defined(_DOS) || defined(_WINDOWS)
  if (res)
    for (p = res; *p; p++)
      if (*p == '/')
        *p = '\\';
# else
  if (res)
    for (p = res; *p; p++)
      if (*p == '\\')
        *p = '/';
# endif
  return (res);
#undef CUR_PROC
}                               /* ighmm_scanner_get_path */

/*============================================================================*/
int ighmm_scanner_get_int (scanner_t * s)
{
  int val = 0;
  int sign = 0;

  if (!s || s->err)
    return (0);
  if (s->eof) {
    ighmm_scanner_error (s, "integer expected");
    return (0);
  }

  if (s->c == '-') {
    if (scanner_nextchar (s, 1))
      return (0);
    sign = 1;
  }
  else if (s->c == '+') {
    if (scanner_nextchar (s, 1))
      return (0);
  }
  if (scanner_skipspace (s))
    return (0);

  if (s->c == '\'') {
    if (scanner_nextcchar (s))
      return (0);
    val = (unsigned char) (s->c);
    if (scanner_nextchar (s, 1))
      return (0);
    if (s->c - '\'') {
      if (!s->esc) {
        ighmm_scanner_error (s, " \' expected");
        return (0);
      }
      val = (unsigned char) '\\';
    }
    else if (scanner_nextchar (s, 1))
      return (0);
  }

  else if (!m_scanner_isdigit (s->c)) {
    if (ighmm_scanner_get_id (s))
      return (0);
    if (!strcmp (s->id, "TRUE"))
      return (sign ? 0 : 1);
    else if (!strcmp (s->id, "FALSE"))
      return (sign ? 1 : 0);
    if (!strcmp (s->id, "ON"))
      return (sign ? 0 : 1);
    else if (!strcmp (s->id, "OFF"))
      return (sign ? 1 : 0);
    ighmm_scanner_error (s, "integer value expected");
    return (0);
  }

  else {
    int radix = 10;

    if (s->c == '0') {
      if (scanner_nextchar (s, 1))
        return (0);
      if (m_scanner_isdigit (s->c)) {
        val = s->c - '0';
        if (scanner_nextchar (s, 1))
          return (0);
      }
      else
        switch (s->c) {
        case 'x':
        case 'X':
          radix = 16;
          break;
        case '_':
          radix = 2;
          break;
        case 'o':
          radix = 8;
          break;
        }
      if (radix - 10) {
        if (scanner_nextchar (s, 1))
          return (0);
        if (scanner_digit (&val, s, radix, 1))
          return (0);
        if (scanner_nextchar (s, 1))
          return (0);
      }
    }
    while (!scanner_digit (&val, s, radix, 0)) {
      if (scanner_nextchar (s, 1))
        return (0);
    }
  }
  if (scanner_skipspace (s))
    return (0);
  return (sign ? -val : val);
# undef CUR_PROC
}                               /* ighmm_scanner_get_int */


/*============================================================================*/
double ighmm_scanner_get_double (scanner_t * s)
{
  double val = 0;
  int sign = 0;

  if (!s || s->err)
    return (0);
  if (s->eof) {
    ighmm_scanner_error (s, "real number expected");
    return (0);
  }

  if (s->c == '-') {
    if (scanner_nextchar (s, 1))
      return (0);
    sign = 1;
  }
  else if (s->c == '+' && scanner_nextchar (s, 1))
    return (0);

  if (scanner_skipspace (s))
    return (0);

  if (!m_scanner_isdigit (s->c) && s->c - '.') {
    ighmm_scanner_error (s, "real number expected");
    return (0);
  }
  while (m_scanner_isdigit (s->c)) {
    val = 10 * val + (double) (s->c - '0');
    if (scanner_nextchar (s, 1))
      return (0);
  }
  if (s->c == '.') {
    double factor = 1;
    if (scanner_nextchar (s, 1))
      return (0);
    while (m_scanner_isdigit (s->c)) {
      val = 10 * val + (double) (s->c - '0');
      if (scanner_nextchar (s, 1))
        return (0);
      factor *= 10;
    }
    val /= factor;
  }
  if (scanner_skipspace (s))
    return (0);
  return (sign ? -val : val);
}                               /* ighmm_scanner_get_double */


/*============================================================================*/
double ighmm_scanner_get_edouble (scanner_t * s)
{
  double val = 0;
  int sign = 0;

  if (!s || s->err)
    return (0);
  if (s->eof) {
    ighmm_scanner_error (s, "real number expected");
    return (0);
  }

  if (s->c == '-') {
    if (scanner_nextchar (s, 1))
      return (0);
    sign = 1;
  }
  else if (s->c == '+' && scanner_nextchar (s, 1))
    return (0);

  if (scanner_skipspace (s))
    return (0);

  if (!m_scanner_isdigit (s->c) && s->c - '.') {
    ighmm_scanner_error (s, "real number expected");
    return (0);
  }
  while (m_scanner_isdigit (s->c)) {
    val = 10 * val + (double) (s->c - '0');
    if (scanner_nextchar (s, 1))
      return (0);
  }
  if (s->c == '.') {
    double factor = 1;
    if (scanner_nextchar (s, 1))
      return (0);
    while (m_scanner_isdigit (s->c)) {
      val = 10 * val + (double) (s->c - '0');
      if (scanner_nextchar (s, 1))
        return (0);
      factor *= 10;
    }
    val /= factor;
  }
  if (s->c == 'e' || s->c == 'E') {
    int i;
    double eval;
    double efactor = 1;
    int esign = 0;
    if (scanner_nextchar (s, 1))
      return (0);
    if (s->c == '-') {
      if (scanner_nextchar (s, 1))
        return (0);
      esign = 1;
    }
    else if (s->c == '+' && scanner_nextchar (s, 1))
      return (0);
    eval = ighmm_scanner_get_int (s);
    if (eval < 0)
      return (0);
    for (i = 0; i < eval; i++)
      efactor *= 10;
    if (esign)
      val /= efactor;
    else
      val *= efactor;
  }

  if (scanner_skipspace (s))
    return (0);
  return (sign ? -val : val);
}                               /* ighmm_scanner_get_edouble */


/*============================================================================*/
void *ighmm_scanner_get_array (scanner_t * s, int *len, char *type)
{
#define CUR_PROC "ighmm_scanner_get_array"
  int size = 0;
  int typ = scanner_type (type, &size);
  int maxlen = 16 * size;
  char *val = NULL;
  int i = 0;
  char txt[256];
  int err;
  int mes_stat;

  if (!s || !type || !len || s->err)
    goto STOP;
  if (!typ) {
    ighmm_scanner_error (s, ighmm_mprintf (txt, sizeof (txt), "unknown type %s ", type));
    goto STOP;
  }
  if (!len || !s || s->err)
    goto STOP;
  if (s->eof) {
    ighmm_scanner_error (s,
                   ighmm_mprintf (txt, sizeof (txt), "%s array expected ", type));
    goto STOP;
  }
  if (s->c == ';') {
    *len = 0;
    goto STOP;
  }
  mes_stat = ighmm_mes_ability (0);
  val = ighmm_malloc (sizeof (char *) * maxlen);
  err = !val;
  ighmm_mes_ability (mes_stat);
  if (err) {
    ighmm_mprintf (txt, sizeof (txt), "Not enough memory to read %s array", type);
    ighmm_scanner_error (s, txt);
    goto STOP;
  }

  while (s->c - ';') {
    /* Originally:
       if( i && ighmm_scanner_consume( s, ',' ) )  goto STOP; */
    /* Changed: read array without seperator now possible */
    if (s->c == ',')
      ighmm_scanner_consume (s, ',');
    switch (typ) {
    case SCANNER_TYPE_CHAR:
      val[i] = ighmm_scanner_get_int (s);
      break;
    case SCANNER_TYPE_INT:
      *(int *) (val + i) = ighmm_scanner_get_int (s);
      break;
    case SCANNER_TYPE_DOUBLE:
      *(double *) (val + i) = ighmm_scanner_get_double (s);
      break;
    case SCANNER_TYPE_EDOUBLE:
      *(double *) (val + i) = ighmm_scanner_get_edouble (s);
      break;
    case SCANNER_TYPE_STRING:
      *(char **) (val + i) = scanner_get_string (s);
      break;
    case SCANNER_TYPE_CSTRING:
      *(char **) (val + i) = scanner_get_cstring (s);
      break;
    default:
      goto STOP;
    }
    i += size;
    if (s->err)
      goto STOP;

    if (i == maxlen) {
      mes_stat = ighmm_mes_ability (0);
      err = ighmm_realloc ((void**)&val, sizeof (*val) * (maxlen + 16 * size));
      ighmm_mes_ability (mes_stat);
      if (err) {
        ighmm_mprintf (txt, sizeof (txt), "Not enough memory to read %s array", type);
        ighmm_scanner_error (s, txt);
        goto STOP;
      }
      maxlen += 16 * size;
    }
  }
  mes_stat = ighmm_mes_ability (0);
  ighmm_realloc ((void**)&val, sizeof (*val) * i);/* Do'nt worry if this fails!*/
  ighmm_mes_ability (mes_stat);

  *len = i / size;

  return (val);

STOP:     /* Label STOP from ARRAY_[CM]ALLOC */
  m_free (val);
  if (len)
    *len = 0;
  return (NULL);
# undef CUR_PROC
}                               /* ighmm_scanner_get_array */


/*============================================================================*/
int ighmm_scanner_free_array (int *len, void ***arr)
{
# define CUR_PROC "ighmm_scanner_free_array"
  mes_check_ptr (len, return (-1));
  mes_check_ptr (arr, return (-1));
  while ((*len)-- > 0) {
    m_free ((*arr)[*len]);
  }
  free (*arr);
  *len = 0;
  return (0);
# undef CUR_PROC
}                               /* ighmm_scanner_free_array */

/*============================================================================*/
int ighmm_scanner_get_index (scanner_t * s, int n)
{
  int index = n - 1;
  if (!s || s->err)
    return (0);
  if (s->eof || s->c - '@') {
    ighmm_scanner_error (s, "index expected");
    return (0);
  }
  if (ighmm_scanner_consume (s, '@'))
    return (0);
  index = ighmm_scanner_get_int (s);
  if (s->err)
    return (0);
  if (index >= n)
    ighmm_scanner_error (s, "index too high");
  if (ighmm_scanner_consume (s, ';'))
    return (0);
  return (index);
}                               /* ighmm_scanner_get_index */

/*============================================================================*/
double ighmm_scanner_get_resolution (scanner_t * s)
{
  double val;

  if (!s || s->err)
    return (0);
  val = ighmm_scanner_get_double (s);
  if (s->err)
    return (0);
  if (ighmm_scanner_get_id (s))
    return (0);
  if (strcmp (s->id, "DPI")) {
    ighmm_scanner_error (s, "dpi expected");
    return (0);
  }
  return (val);
}                               /* ighmm_scanner_get_resolution */

/*============================================================================*/
int ighmm_scanner_get_length_x (scanner_t * s)
{
  return (s->x_scale * scanner_get_length (s, s->x_resolution) + 0.5);
}                               /* ighmm_scanner_get_length_x */

/*============================================================================*/
int ighmm_scanner_get_length_y (scanner_t * s)
{
  return (s->y_scale * scanner_get_length (s, s->y_resolution) + 0.5);
}                               /* ighmm_scanner_get_length_y */


#if defined( TEST )
/*============================================================================*/
int scanner_tst (void)
{
# define CUR_PROC "scanner_tst"
  scanner_t *s = ighmm_scanner_alloc ("scanner.cfg");
  char *char_arr = NULL;
  int char_len = 0;
  int *int_arr = NULL;
  int int_len = 0;
  double *double_arr = NULL;
  int double_len = 0;
  char **string_arr = NULL;
  int string_len = 0;
  int res = -1;
  int i;

  if (!s) {
    GHMM_LOG_QUEUED(LCONVERTED);
    goto STOP;
  }

  while (!s->err && !s->eof) {
    if (ighmm_scanner_get_name (s))
      break;
    if (ighmm_scanner_consume (s, '='))
      break;
    else if (!strcmp (s->id, "char")) {
      m_free (char_arr);
      char_arr = scanner_get_char_array (s, &char_len);
    }
    else if (!strcmp (s->id, "int")) {
      m_free (int_arr);
      int_arr = scanner_get_int_array (s, &int_len);
    }
    else if (!strcmp (s->id, "string")) {
      m_free (string_arr);
      string_arr = scanner_get_cstring_array (s, &string_len);
    }
    else if (!strcmp (s->id, "double")) {
      m_free (double_arr);
      double_arr = scanner_get_double_array (s, &double_len);
    }
    else
      ighmm_scanner_error (s, "unknown identifyer");
    if (ighmm_scanner_consume (s, ';'))
      break;
  }

  if (char_arr) {
    mes_win ("\nchar:\n");
    for (i = 0; i < char_len; i++)
      ighmm_mes (MES_WIN, "  '%c'\n", char_arr[i]);
  }
  if (int_arr) {
    mes_win ("\nint:\n");
    for (i = 0; i < int_len; i++)
      ighmm_mes (MES_WIN, "  %d\n", int_arr[i]);
  }
  if (double_arr) {
    mes_win ("\ndouble:\n");
    for (i = 0; i < double_len; i++)
      ighmm_mes (MES_WIN, "  %f\n", double_arr[i]);
  }
  if (string_arr) {
    mes_win ("\nstring:\n");
    for (i = 0; i < string_len; i++)
      ighmm_mes (MES_WIN, "  \"%s\"\n", string_arr[i]);
  }

  res = 0;
STOP:
  ighmm_scanner_free (&s);
  m_free (char_arr);
  m_free (int_arr);
  m_free (double_arr);
  if (string_arr)
    for (i = 0; i < string_len; i++)
      m_free (string_arr[i]);
  m_free (string_arr);
  return (res);
# undef CUR_PROC
}                               /* scanner_tst */
#endif /* defined( TEST ) */

/*----------------------------------------------------------------------------*/
static int scanner_free_d_matrix (double ***matrix, long rows)
{
# define CUR_PROC "scanner_free_d_matrix"
  long i;
  mes_check_ptr (matrix, return (-1));
  if (!*matrix)
    return (0);
  for (i = 0; i < rows; i++)
    m_free ((*matrix)[i]);
  m_free (*matrix);
  return (0);
# undef CUR_PROC
}                               /* scanner_free_d_matrix */

/*============================================================================*/
double **ighmm_scanner_get_d_matrix (scanner_t * s, int *rows, int *cols)
{
#define CUR_PROC "ighmm_scanner_get_d_matrix"
  double **matrix = NULL;
  int local_cols = 0;
  *rows = *cols = 0;
  while (!s->eof && !s->err && s->c - '}') {
    (*rows)++;
    ARRAY_REALLOC (matrix, *rows);
    matrix[*rows - 1] = scanner_get_double_array (s, &local_cols);
    ighmm_scanner_consume (s, ';');
    if (s->err)
      goto STOP;
    if (*rows > 1)
      if (local_cols != *cols) {
        ighmm_scanner_error (s, "rows of variing length in matrix");
        goto STOP;
      }
    *cols = local_cols;
  }                             /* while ... */
  return matrix;
STOP:     /* Label STOP from ARRAY_[CM]ALLOC */
  scanner_free_d_matrix (&matrix, *rows);
  return NULL;
#undef CUR_PROC
}                               /* ighmm_scanner_get_d_matrix */

#endif /* GHMM_OBSOLETE */