scanner.c

一个通用的隐性马尔可夫C代码库 开发环境:C语言 简要说明:这是一个通用的隐性马尔可夫C代码库

STOP:
  m_free( val );
  return(NULL);
# undef CUR_PROC
} /* scanner_get_str */

/*============================================================================*/
char* scanner_get_path(scanner_t *s) {
#define CUR_PROC "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
} /* scanner_get_path */

/*============================================================================*/
int scanner_get_int( scanner_t* s ) {
  int val   = 0;
  int sign  = 0;
  
  if( !s || s->err ) return(0);
  if( s->eof ) { 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 ) { 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( 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); 
    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
} /* scanner_get_int */


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

  if( !s || s->err ) return(0);
  if( s->eof ) { 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 - '.' ) 
    { 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 );
} /* scanner_get_double */


/*============================================================================*/
double scanner_get_edouble(scanner_t* s) {
  double val  = 0;
  int    sign = 0;
  
  if( !s || s->err ) return(0);
  if( s->eof ) { 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 - '.' ) 
    { 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 = 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 );
} /* scanner_get_edouble */


/*============================================================================*/
void* scanner_get_array( scanner_t* s, int* len, char* type ) {
  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 ) { 
    scanner_error(s, mprintf( txt, sizeof(txt), "unknown type %s ", type )); 
    goto STOP;
  }
  if( !len || !s || s->err ) goto STOP;
  if( s->eof ) { 
    scanner_error( s, mprintf( txt, sizeof(txt), "%s array expected ", type ) ); 
    goto STOP;
  }
  if( s->c == ';') {  *len=0; goto STOP; }
  mes_stat = mes_ability( 0 );
  err = !m_malloc( val, maxlen );
  mes_ability( mes_stat );
  if( err ){ 
    mprintf(txt, sizeof(txt), "Not enough memory to read %s array", type);
    scanner_error( s, txt );
    goto STOP;
  }
  
  while( s->c - ';' ) {
    /* Originally:
       if( i && scanner_consume( s, ',' ) )  goto STOP; */
    /* Changed: read array without seperator now possible */
    if ( s->c == ',') scanner_consume( s, ',' );
    switch( typ ) {
    case SCANNER_TYPE_CHAR :
      val[i] = scanner_get_int( s );
      break;      
    case SCANNER_TYPE_INT :
      *(int*)(val+i) = scanner_get_int( s );
      break;      
    case SCANNER_TYPE_DOUBLE :
      *(double*)(val+i) = scanner_get_double( s );
      break;      
    case SCANNER_TYPE_EDOUBLE :
      *(double*)(val+i) = 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 = mes_ability( 0 );
      err = m_realloc( val, maxlen+16*size );
      mes_ability( mes_stat );
      if( err ) {
	mprintf( txt, sizeof(txt), "Not enough memory to read %s array", type);
	scanner_error( s, txt ); 
	goto STOP;
      }
      maxlen += 16*size;
    }
  }
  mes_stat = mes_ability( 0 );
  m_realloc( val, i );           /* Do'nt worry if this fails ! */
  mes_ability( mes_stat );
  
  *len = i/size;
  
  return( val );
  
STOP:
  m_free( val );
  if( len ) *len = 0;
  return(NULL);  
# undef CUR_PROC
} /* scanner_get_array */


/*============================================================================*/
int scanner_free_array( int* len, void*** arr ) {
# define CUR_PROC "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
} /* scanner_free_array */

/*============================================================================*/
int scanner_get_index(scanner_t* s, int n) {
  int index = n-1;
  if( !s || s->err ) return(0);
  if( s->eof || s->c - '@' ) { scanner_error( s, "index expected" ); return(0); }
  if( scanner_consume( s, '@') ) return(0);
  index = scanner_get_int(s);
  if( s->err ) return(0);
  if( index >= n ) scanner_error (s,"index too high");
  if( scanner_consume(s,';') ) return(0);
  return( index );
} /* scanner_get_index */

/*============================================================================*/
double scanner_get_resolution(scanner_t* s) {
  double val;
  
  if( !s || s->err ) return(0);
  val = scanner_get_double(s);
  if( s->err ) return(0); 
  if( scanner_get_id( s ) ) return(0);
  if( strcmp(s->id,"DPI") ) { scanner_error( s , "dpi expected" ); return(0); }
  return( val );
} /* scanner_get_resolution */

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

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


#if defined( TEST )
/*============================================================================*/
int scanner_tst( void ) {
# define CUR_PROC "scanner_tst"
  scanner_t* s          = 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 ) { mes_proc(); goto STOP; }
  
  while( !s->err && !s->eof ) {
    if( scanner_get_name( s ) ) break;
    if( 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 scanner_error( s, "unknown identifyer" );
    if( scanner_consume( s, ';') ) break;
  }
  
  if( char_arr ){
    mes_win( "\nchar:\n" );
    for( i = 0; i < char_len; i++ ) mes( MES_WIN, "  '%c'\n", char_arr[i] );
  }
  if( int_arr ){
    mes_win( "\nint:\n" );
    for( i = 0; i < int_len; i++ ) mes( MES_WIN, "  %d\n", int_arr[i] );
  }
  if( double_arr ){
    mes_win( "\ndouble:\n" );
    for( i = 0; i < double_len; i++ ) mes( MES_WIN, "  %f\n", double_arr[i] );
  }
  if( string_arr ){
    mes_win( "\nstring:\n" );
    for( i = 0; i < string_len; i++ ) mes( MES_WIN, "  \"%s\"\n", string_arr[i] );
  }
  
  res = 0;
STOP:
  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 **scanner_get_d_matrix(scanner_t *s, int *rows, int *cols) {
#define CUR_PROC "scanner_get_d_matrix"
  double **matrix = NULL;
  int local_cols = 0;
  *rows = *cols = 0;
  while(!s->eof && !s->err && s->c - '}') {
    (*rows)++;
    if (m_realloc(matrix, *rows)) {mes_proc(); goto STOP;}
    matrix[*rows - 1] = scanner_get_double_array(s, &local_cols);
    scanner_consume(s, ';'); if (s->err) goto STOP;
    if (*rows > 1) 
      if (local_cols != *cols) {
	scanner_error(s, "rows of variing length in matrix");
	goto STOP;
      }
    *cols = local_cols;
  } /* while ... */
  return matrix;
STOP:
  scanner_free_d_matrix(&matrix, *rows);
  return NULL;
#undef CUR_PROC
} /* scanner_get_d_matrix */