- Main Page
- Namespaces
- Classes
- Files
- Related Pages

# /Users/fpy/titan-1-5-MBARI/Mers/Estimation/Discrete/CompiledME/CCMEReader/CCMEReader.yy.cpp

    00001 #define yy_create_buffer yyCCMEReader_create_buffer
    00002 #define yy_delete_buffer yyCCMEReader_delete_buffer
    00003 #define yy_scan_buffer yyCCMEReader_scan_buffer
    00004 #define yy_scan_string yyCCMEReader_scan_string
    00005 #define yy_scan_bytes yyCCMEReader_scan_bytes
    00006 #define yy_flex_debug yyCCMEReader_flex_debug
    00007 #define yy_init_buffer yyCCMEReader_init_buffer
    00008 #define yy_flush_buffer yyCCMEReader_flush_buffer
    00009 #define yy_load_buffer_state yyCCMEReader_load_buffer_state
    00010 #define yy_switch_to_buffer yyCCMEReader_switch_to_buffer
    00011 #define yyin yyCCMEReaderin
    00012 #define yyleng yyCCMEReaderleng
    00013 #define yylex yyCCMEReaderlex
    00014 #define yyout yyCCMEReaderout
    00015 #define yyrestart yyCCMEReaderrestart
    00016 #define yytext yyCCMEReadertext
    00017
    00018 #line 19 "CCMEReader.yy.cpp"
    00019 /* A lexical scanner generated by flex */
    00020
    00021 /* Scanner skeleton version:
    00022  * $Header$
    00023  */
    00024
    00025 #define FLEX_SCANNER
    00026 #define YY_FLEX_MAJOR_VERSION 2
    00027 #define YY_FLEX_MINOR_VERSION 5
    00028
    00029 #include <stdio.h>
    00030 #include <errno.h>
    00031
    00032 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
    00033 #ifdef c_plusplus
    00034 #ifndef __cplusplus
    00035 #define __cplusplus
    00036 #endif
    00037 #endif
    00038
    00039
    00040 #ifdef __cplusplus
    00041
    00042 #include <stdlib.h>
    00043 #ifndef _WIN32
    00044 #include <unistd.h>
    00045 #endif
    00046
    00047 /* Use prototypes in function declarations. */
    00048 #define YY_USE_PROTOS
    00049
    00050 /* The "const" storage-class-modifier is valid. */
    00051 #define YY_USE_CONST
    00052
    00053 #else   /* ! __cplusplus */
    00054
    00055 #if __STDC__
    00056
    00057 #define YY_USE_PROTOS
    00058 #define YY_USE_CONST
    00059
    00060 #endif  /* __STDC__ */
    00061 #endif  /* ! __cplusplus */
    00062
    00063 #ifdef __TURBOC__
    00064  #pragma warn -rch
    00065  #pragma warn -use
    00066 #include <io.h>
    00067 #include <stdlib.h>
    00068 #define YY_USE_CONST
    00069 #define YY_USE_PROTOS
    00070 #endif
    00071
    00072 #ifdef YY_USE_CONST
    00073 #define yyconst const
    00074 #else
    00075 #define yyconst
    00076 #endif
    00077
    00078
    00079 #ifdef YY_USE_PROTOS
    00080 #define YY_PROTO(proto) proto
    00081 #else
    00082 #define YY_PROTO(proto) ()
    00083 #endif
    00084
    00085
    00086 /* Returned upon end-of-file. */
    00087 #define YY_NULL 0
    00088
    00089 /* Promotes a possibly negative, possibly signed char to an unsigned
    00090  * integer for use as an array index.  If the signed char is negative,
    00091  * we want to instead treat it as an 8-bit unsigned char, hence the
    00092  * double cast.
    00093  */
    00094 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
    00095
    00096 /* Enter a start condition.  This macro really ought to take a parameter,
    00097  * but we do it the disgusting crufty way forced on us by the ()-less
    00098  * definition of BEGIN.
    00099  */
    00100 #define BEGIN yy_start = 1 + 2 *
    00101
    00102 /* Translate the current start state into a value that can be later handed
    00103  * to BEGIN to return to the state.  The YYSTATE alias is for lex
    00104  * compatibility.
    00105  */
    00106 #define YY_START ((yy_start - 1) / 2)
    00107 #define YYSTATE YY_START
    00108
    00109 /* Action number for EOF rule of a given start state. */
    00110 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
    00111
    00112 /* Special action meaning "start processing a new file". */
    00113 #define YY_NEW_FILE yyrestart( yyin )
    00114
    00115 #define YY_END_OF_BUFFER_CHAR 0
    00116
    00117 /* Size of default input buffer. */
    00118 #define YY_BUF_SIZE 16384
    00119
    00120 typedef struct yy_buffer_state *YY_BUFFER_STATE;
    00121
    00122 extern int yyleng;
    00123 extern FILE *yyin, *yyout;
    00124
    00125 #define EOB_ACT_CONTINUE_SCAN 0
    00126 #define EOB_ACT_END_OF_FILE 1
    00127 #define EOB_ACT_LAST_MATCH 2
    00128
    00129 /* The funky do-while in the following #define is used to turn the definition
    00130  * int a single C statement (which needs a semi-colon terminator).  This
    00131  * avoids problems with code like:
    00132  *
    00133  *      if ( condition_holds )
    00134  *              yyless( 5 );
    00135  *      else
    00136  *              do_something_else();
    00137  *
    00138  * Prior to using the do-while the compiler would get upset at the
    00139  * "else" because it interpreted the "if" statement as being all
    00140  * done when it reached the ';' after the yyless() call.
    00141  */
    00142
    00143 /* Return all but the first 'n' matched characters back to the input stream. */
    00144
    00145 #define yyless(n) \
    00146         do \
    00147                 { \
    00148                 /* Undo effects of setting up yytext. */ \
    00149                 *yy_cp = yy_hold_char; \
    00150                 YY_RESTORE_YY_MORE_OFFSET \
    00151                 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
    00152                 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
    00153                 } \
    00154         while ( 0 )
    00155
    00156 #define unput(c) yyunput( c, yytext_ptr )
    00157
    00158 /* The following is because we cannot portably get our hands on size_t
    00159  * (without autoconf's help, which isn't available because we want
    00160  * flex-generated scanners to compile on their own).
    00161  */
    00162 typedef unsigned int yy_size_t;
    00163
    00164
    00165 struct yy_buffer_state
    00166         {
    00167         FILE *yy_input_file;
    00168
    00169         char *yy_ch_buf;                /* input buffer */
    00170         char *yy_buf_pos;               /* current position in input buffer */
    00171
    00172         /* Size of input buffer in bytes, not including room for EOB
    00173          * characters.
    00174          */
    00175         yy_size_t yy_buf_size;
    00176
    00177         /* Number of characters read into yy_ch_buf, not including EOB
    00178          * characters.
    00179          */
    00180         int yy_n_chars;
    00181
    00182         /* Whether we "own" the buffer - i.e., we know we created it,
    00183          * and can realloc() it to grow it, and should free() it to
    00184          * delete it.
    00185          */
    00186         int yy_is_our_buffer;
    00187
    00188         /* Whether this is an "interactive" input source; if so, and
    00189          * if we're using stdio for input, then we want to use getc()
    00190          * instead of fread(), to make sure we stop fetching input after
    00191          * each newline.
    00192          */
    00193         int yy_is_interactive;
    00194
    00195         /* Whether we're considered to be at the beginning of a line.
    00196          * If so, '^' rules will be active on the next match, otherwise
    00197          * not.
    00198          */
    00199         int yy_at_bol;
    00200
    00201         /* Whether to try to fill the input buffer when we reach the
    00202          * end of it.
    00203          */
    00204         int yy_fill_buffer;
    00205
    00206         int yy_buffer_status;
    00207 #define YY_BUFFER_NEW 0
    00208 #define YY_BUFFER_NORMAL 1
    00209         /* When an EOF's been seen but there's still some text to process
    00210          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
    00211          * shouldn't try reading from the input source any more.  We might
    00212          * still have a bunch of tokens to match, though, because of
    00213          * possible backing-up.
    00214          *
    00215          * When we actually see the EOF, we change the status to "new"
    00216          * (via yyrestart()), so that the user can continue scanning by
    00217          * just pointing yyin at a new input file.
    00218          */
    00219 #define YY_BUFFER_EOF_PENDING 2
    00220         };
    00221
    00222 static YY_BUFFER_STATE yy_current_buffer = 0;
    00223
    00224 /* We provide macros for accessing buffer states in case in the
    00225  * future we want to put the buffer states in a more general
    00226  * "scanner state".
    00227  */
    00228 #define YY_CURRENT_BUFFER yy_current_buffer
    00229
    00230
    00231 /* yy_hold_char holds the character lost when yytext is formed. */
    00232 static char yy_hold_char;
    00233
    00234 static int yy_n_chars;          /* number of characters read into yy_ch_buf */
    00235
    00236
    00237 int yyleng;
    00238
    00239 /* Points to current character in buffer. */
    00240 static char *yy_c_buf_p = (char *) 0;
    00241 static int yy_init = 1;         /* whether we need to initialize */
    00242 static int yy_start = 0;        /* start state number */
    00243
    00244 /* Flag which is used to allow yywrap()'s to do buffer switches
    00245  * instead of setting up a fresh yyin.  A bit of a hack ...
    00246  */
    00247 static int yy_did_buffer_switch_on_eof;
    00248
    00249 void yyrestart YY_PROTO(( FILE *input_file ));
    00250
    00251 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
    00252 void yy_load_buffer_state YY_PROTO(( void ));
    00253 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
    00254 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
    00255 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
    00256 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
    00257 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
    00258
    00259 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
    00260 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
    00261 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
    00262
    00263 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
    00264 static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
    00265 static void yy_flex_free YY_PROTO(( void * ));
    00266
    00267 #define yy_new_buffer yy_create_buffer
    00268
    00269 #define yy_set_interactive(is_interactive) \
    00270         { \
    00271         if ( ! yy_current_buffer ) \
    00272                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
    00273         yy_current_buffer->yy_is_interactive = is_interactive; \
    00274         }
    00275
    00276 #define yy_set_bol(at_bol) \
    00277         { \
    00278         if ( ! yy_current_buffer ) \
    00279                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
    00280         yy_current_buffer->yy_at_bol = at_bol; \
    00281         }
    00282
    00283 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
    00284
    00285
    00286 #define yywrap() 1
    00287 #define YY_SKIP_YYWRAP
    00288 typedef unsigned char YY_CHAR;
    00289 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
    00290 typedef int yy_state_type;
    00291 extern char *yytext;
    00292 #define yytext_ptr yytext
    00293
    00294 static yy_state_type yy_get_previous_state YY_PROTO(( void ));
    00295 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
    00296 static int yy_get_next_buffer YY_PROTO(( void ));
    00297 static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
    00298
    00299 /* Done after the current pattern has been matched and before the
    00300  * corresponding action - sets up yytext.
    00301  */
    00302 #define YY_DO_BEFORE_ACTION \
    00303         yytext_ptr = yy_bp; \
    00304         yyleng = (int) (yy_cp - yy_bp); \
    00305         yy_hold_char = *yy_cp; \
    00306         *yy_cp = '\0'; \
    00307         yy_c_buf_p = yy_cp;
    00308
    00309 #define YY_NUM_RULES 16
    00310 #define YY_END_OF_BUFFER 17
    00311 static yyconst short int yy_accept[66] =
    00312     {   0,
    00313         7,    7,   17,   15,   11,   12,   13,   15,    9,    7,
    00314         7,    7,    5,    7,    7,    7,    7,   11,    0,    8,
    00315         7,   10,    7,    7,    5,    7,    7,    7,    7,   14,
    00316         7,    6,    7,    7,    7,    7,    7,    7,    7,    7,
    00317         7,    7,    7,    7,    7,    7,    7,    7,    7,    7,
    00318         7,    7,    7,    2,    7,    7,    7,    7,    7,    1,
    00319         7,    7,    4,    3,    0
    00320     } ;
    00321
    00322 static yyconst int yy_ec[256] =
    00323     {   0,
    00324         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
    00325         1,    1,    4,    1,    1,    1,    1,    1,    1,    1,
    00326         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    00327         1,    2,    1,    5,    1,    1,    1,    1,    1,    1,
    00328         1,    1,    1,    6,    7,    8,    9,   10,   11,   10,
    00329        10,   10,   10,   10,   10,   10,   10,   12,    1,    1,
    00330        13,   14,    1,    1,   15,   15,   16,   17,   18,   19,
    00331        15,   15,   15,   15,   15,   15,   20,   15,   15,   21,
    00332        15,   15,   15,   22,   15,   23,   15,   15,   15,   15,
    00333         1,   15,    1,    1,   15,    1,   24,   25,   15,   15,
    00334
    00335        26,   15,   15,   15,   27,   15,   15,   28,   15,   29,
    00336        30,   15,   15,   31,   32,   33,   15,   15,   15,   15,
    00337        34,   15,   35,    1,   36,   15,    1,    1,    1,    1,
    00338         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    00339         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    00340         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    00341         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    00342         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    00343         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    00344         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    00345
    00346         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    00347         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    00348         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    00349         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    00350         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    00351         1,    1,    1,    1,    1
    00352     } ;
    00353
    00354 static yyconst int yy_meta[37] =
    00355     {   0,
    00356         1,    1,    2,    1,    1,    1,    3,    3,    3,    3,
    00357         3,    1,    1,    3,    3,    3,    3,    3,    3,    3,
    00358         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
    00359         3,    3,    3,    3,    1,    1
    00360     } ;
    00361
    00362 static yyconst short int yy_base[70] =
    00363     {   0,
    00364         0,    0,  156,  172,  153,  172,  172,  149,  172,  138,
    00365       137,   28,   30,   29,   25,   32,   33,  148,  144,  172,
    00366       134,  172,   64,   39,   46,   41,   48,   37,   34,    0,
    00367       100,   61,   65,   59,   60,   67,   68,   72,   70,   75,
    00368        76,   79,   95,   83,   97,  101,  102,  104,  105,  107,
    00369       110,  103,  109,  133,  113,  112,   81,  108,  114,  132,
    00370       119,  130,  131,   74,  172,  162,   56,  165,  168
    00371     } ;
    00372
    00373 static yyconst short int yy_def[70] =
    00374     {   0,
    00375        65,    1,   65,   65,   65,   65,   65,   66,   65,   67,
    00376        67,   67,   67,   67,   67,   67,   67,   65,   66,   65,
    00377        67,   65,   68,   67,   67,   67,   67,   67,   67,   69,
    00378        68,   67,   67,   67,   67,   67,   67,   67,   67,   67,
    00379        67,   67,   67,   67,   67,   67,   67,   67,   67,   67,
    00380        67,   67,   67,   67,   67,   67,   67,   67,   67,   67,
    00381        67,   67,   67,   67,    0,   65,   65,   65,   65
    00382     } ;
    00383
    00384 static yyconst short int yy_nxt[209] =
    00385     {   0,
    00386         4,    5,    6,    7,    8,    9,   10,   11,   12,   13,
    00387        13,    9,    9,    4,   11,   14,   15,   11,   11,   11,
    00388        16,   17,   11,   11,   11,   11,   11,   11,   11,   11,
    00389        11,   11,   11,   11,    9,    9,   23,   24,   65,   25,
    00390        25,   65,   65,   65,   26,   65,   65,   65,   32,   32,
    00391        65,   27,   65,   24,   65,   25,   25,   36,   21,   65,
    00392        33,   65,   28,   29,   30,   30,   35,   30,   30,   30,
    00393        32,   32,   65,   65,   65,   30,   30,   30,   65,   34,
    00394        65,   65,   37,   65,   39,   65,   41,   65,   65,   65,
    00395        38,   60,   65,   43,   65,   40,   65,   42,   30,   30,
    00396
    00397        30,   30,   45,   30,   30,   30,   44,   46,   65,   48,
    00398        65,   30,   30,   30,   65,   65,   65,   65,   65,   47,
    00399        65,   65,   65,   65,   49,   65,   65,   65,   51,   56,
    00400        53,   57,   65,   50,   30,   30,   52,   55,   54,   58,
    00401        61,   59,   62,   65,   65,   65,   65,   65,   20,   18,
    00402        65,   22,   63,   20,   18,   65,   65,   65,   65,   65,
    00403        65,   64,   19,   65,   19,   31,   65,   31,   30,   65,
    00404        30,    3,   65,   65,   65,   65,   65,   65,   65,   65,
    00405        65,   65,   65,   65,   65,   65,   65,   65,   65,   65,
    00406        65,   65,   65,   65,   65,   65,   65,   65,   65,   65,
    00407
    00408        65,   65,   65,   65,   65,   65,   65,   65
    00409     } ;
    00410
    00411 static yyconst short int yy_chk[209] =
    00412     {   0,
    00413         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    00414         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    00415         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
    00416         1,    1,    1,    1,    1,    1,   12,   13,   15,   13,
    00417        13,   12,   14,   13,   14,   16,   17,   29,   24,   24,
    00418        28,   15,   24,   25,   26,   25,   25,   29,   67,   25,
    00419        26,   27,   16,   17,   23,   23,   28,   23,   23,   23,
    00420        32,   32,   34,   35,   32,   23,   23,   23,   33,   27,
    00421        36,   37,   33,   39,   35,   38,   37,   64,   40,   41,
    00422        34,   57,   42,   39,   57,   36,   44,   38,   23,   23,
    00423
    00424        31,   31,   41,   31,   31,   31,   40,   42,   43,   44,
    00425        45,   31,   31,   31,   46,   47,   52,   48,   49,   43,
    00426        50,   58,   53,   51,   45,   56,   55,   59,   47,   52,
    00427        49,   53,   61,   46,   31,   31,   48,   51,   50,   55,
    00428        58,   56,   59,   62,   63,   60,   54,   21,   19,   18,
    00429        11,   10,   61,    8,    5,    3,    0,    0,    0,    0,
    00430         0,   62,   66,    0,   66,   68,    0,   68,   69,    0,
    00431        69,   65,   65,   65,   65,   65,   65,   65,   65,   65,
    00432        65,   65,   65,   65,   65,   65,   65,   65,   65,   65,
    00433        65,   65,   65,   65,   65,   65,   65,   65,   65,   65,
    00434
    00435        65,   65,   65,   65,   65,   65,   65,   65
    00436     } ;
    00437
    00438 static yy_state_type yy_last_accepting_state;
    00439 static char *yy_last_accepting_cpos;
    00440
    00441 /* The intent behind this definition is that it'll catch
    00442  * any uses of REJECT which flex missed.
    00443  */
    00444 #define REJECT reject_used_but_not_detected
    00445 #define yymore() yymore_used_but_not_detected
    00446 #define YY_MORE_ADJ 0
    00447 #define YY_RESTORE_YY_MORE_OFFSET
    00448 char *yytext;
    00449 #line 1 "CCMEReader.l"
    00450 #define INITIAL 0
    00451 #line 2 "CCMEReader.l"
    00452
    00453 //=============================================================================
    00454 //
    00455 // Copyright (c) 2002           Model-based Embedded and Robotic Systems Group
    00456 // All Rights Reserved          Massachusetts Institute of Technology
    00457 //
    00458 // This software is provided as is. Model-based Embedded and Robotic Systems
    00459 // (MERS) group does not assume any responsibility.
    00460 //
    00461 // Author:                      Paul H. Elliott
    00462 // Organization:        Model-based Embedded and Robotic Systems Group
    00463 //                                      Massachusetts Institute of Technology
    00464 //
    00465 // CCMEReader flex file
    00466 //=============================================================================
    00467
    00468 #include <iostream>
    00469 #include <string>
    00470 #include <Mers/Models/Base/BaseModel.h>
    00471 #include <Mers/Models/Base/BaseModelAssignmentArray.h>
    00472
    00473  using Mers::Models::Base::BaseModel;
    00474  using Mers::Models::Base::BaseModelAssignmentArray;
    00475  using Mers::Utils::Lang::String;
    00476
    00477 #include "CCMEReader.tab.cpp.h"
    00478 using namespace std;
    00479
    00480 #define YY_NO_UNPUT 1
    00481
    00482 int yyCCMEReaderline;
    00483
    00484 #define YY_NEVER_INTERACTIVE 1
    00485 #line 486 "CCMEReader.yy.cpp"
    00486
    00487 /* Macros after this point can all be overridden by user definitions in
    00488  * section 1.
    00489  */
    00490
    00491 #ifndef YY_SKIP_YYWRAP
    00492 #ifdef __cplusplus
    00493 extern "C" int yywrap YY_PROTO(( void ));
    00494 #else
    00495 extern int yywrap YY_PROTO(( void ));
    00496 #endif
    00497 #endif
    00498
    00499 #ifndef YY_NO_UNPUT
    00500 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
    00501 #endif
    00502
    00503 #ifndef yytext_ptr
    00504 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
    00505 #endif
    00506
    00507 #ifdef YY_NEED_STRLEN
    00508 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
    00509 #endif
    00510
    00511 #ifndef YY_NO_INPUT
    00512 #ifdef __cplusplus
    00513 static int yyinput YY_PROTO(( void ));
    00514 #else
    00515 static int input YY_PROTO(( void ));
    00516 #endif
    00517 #endif
    00518
    00519 #if YY_STACK_USED
    00520 static int yy_start_stack_ptr = 0;
    00521 static int yy_start_stack_depth = 0;
    00522 static int *yy_start_stack = 0;
    00523 #ifndef YY_NO_PUSH_STATE
    00524 static void yy_push_state YY_PROTO(( int new_state ));
    00525 #endif
    00526 #ifndef YY_NO_POP_STATE
    00527 static void yy_pop_state YY_PROTO(( void ));
    00528 #endif
    00529 #ifndef YY_NO_TOP_STATE
    00530 static int yy_top_state YY_PROTO(( void ));
    00531 #endif
    00532
    00533 #else
    00534 #define YY_NO_PUSH_STATE 1
    00535 #define YY_NO_POP_STATE 1
    00536 #define YY_NO_TOP_STATE 1
    00537 #endif
    00538
    00539 #ifdef YY_MALLOC_DECL
    00540 YY_MALLOC_DECL
    00541 #else
    00542 #if __STDC__
    00543 #ifndef __cplusplus
    00544 #include <stdlib.h>
    00545 #endif
    00546 #else
    00547 /* Just try to get by without declaring the routines.  This will fail
    00548  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
    00549  * or sizeof(void*) != sizeof(int).
    00550  */
    00551 #endif
    00552 #endif
    00553
    00554 /* Amount of stuff to slurp up with each read. */
    00555 #ifndef YY_READ_BUF_SIZE
    00556 #define YY_READ_BUF_SIZE 8192
    00557 #endif
    00558
    00559 /* Copy whatever the last rule matched to the standard output. */
    00560
    00561 #ifndef ECHO
    00562 /* This used to be an fputs(), but since the string might contain NUL's,
    00563  * we now use fwrite().
    00564  */
    00565 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
    00566 #endif
    00567
    00568 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
    00569  * is returned in "result".
    00570  */
    00571 #ifndef YY_INPUT
    00572 #define YY_INPUT(buf,result,max_size) \
    00573         if ( yy_current_buffer->yy_is_interactive ) \
    00574                 { \
    00575                 int c = '*', n; \
    00576                 for ( n = 0; n < max_size && \
    00577                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
    00578                         buf[n] = (char) c; \
    00579                 if ( c == '\n' ) \
    00580                         buf[n++] = (char) c; \
    00581                 if ( c == EOF && ferror( yyin ) ) \
    00582                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
    00583                 result = n; \
    00584                 } \
    00585         else \
    00586                 { \
    00587                 errno=0; \
    00588                 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
    00589                         { \
    00590                         if( errno != EINTR) \
    00591                                 { \
    00592                                 YY_FATAL_ERROR( "input in flex scanner failed" ); \
    00593                                 break; \
    00594                                 } \
    00595                         errno=0; \
    00596                         clearerr(yyin); \
    00597                         } \
    00598                 }
    00599 #endif
    00600
    00601 /* No semi-colon after return; correct usage is to write "yyterminate();" -
    00602  * we don't want an extra ';' after the "return" because that will cause
    00603  * some compilers to complain about unreachable statements.
    00604  */
    00605 #ifndef yyterminate
    00606 #define yyterminate() return YY_NULL
    00607 #endif
    00608
    00609 /* Number of entries by which start-condition stack grows. */
    00610 #ifndef YY_START_STACK_INCR
    00611 #define YY_START_STACK_INCR 25
    00612 #endif
    00613
    00614 /* Report a fatal error. */
    00615 #ifndef YY_FATAL_ERROR
    00616 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
    00617 #endif
    00618
    00619 /* Default declaration of generated scanner - a define so the user can
    00620  * easily add parameters.
    00621  */
    00622 #ifndef YY_DECL
    00623 #define YY_DECL int yylex YY_PROTO(( void ))
    00624 #endif
    00625
    00626 /* Code executed at the beginning of each rule, after yytext and yyleng
    00627  * have been set up.
    00628  */
    00629 #ifndef YY_USER_ACTION
    00630 #define YY_USER_ACTION
    00631 #endif
    00632
    00633 /* Code executed at the end of each rule. */
    00634 #ifndef YY_BREAK
    00635 #define YY_BREAK break;
    00636 #endif
    00637
    00638 #define YY_RULE_SETUP \
    00639         YY_USER_ACTION
    00640
    00641 YY_DECL
    00642         {
    00643         register yy_state_type yy_current_state;
    00644         register char *yy_cp, *yy_bp;
    00645         register int yy_act;
    00646
    00647 #line 43 "CCMEReader.l"
    00648
    00649
    00650 #line 651 "CCMEReader.yy.cpp"
    00651
    00652         if ( yy_init )
    00653                 {
    00654                 yy_init = 0;
    00655
    00656 #ifdef YY_USER_INIT
    00657                 YY_USER_INIT;
    00658 #endif
    00659
    00660                 if ( ! yy_start )
    00661                         yy_start = 1;   /* first start state */
    00662
    00663                 if ( ! yyin )
    00664                         yyin = stdin;
    00665
    00666                 if ( ! yyout )
    00667                         yyout = stdout;
    00668
    00669                 if ( ! yy_current_buffer )
    00670                         yy_current_buffer =
    00671                                 yy_create_buffer( yyin, YY_BUF_SIZE );
    00672
    00673                 yy_load_buffer_state();
    00674                 }
    00675
    00676         while ( 1 )             /* loops until end-of-file is reached */
    00677                 {
    00678                 yy_cp = yy_c_buf_p;
    00679
    00680                 /* Support of yytext. */
    00681                 *yy_cp = yy_hold_char;
    00682
    00683                 /* yy_bp points to the position in yy_ch_buf of the start of
    00684                  * the current run.
    00685                  */
    00686                 yy_bp = yy_cp;
    00687
    00688                 yy_current_state = yy_start;
    00689 yy_match:
    00690                 do
    00691                         {
    00692                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
    00693                         if ( yy_accept[yy_current_state] )
    00694                                 {
    00695                                 yy_last_accepting_state = yy_current_state;
    00696                                 yy_last_accepting_cpos = yy_cp;
    00697                                 }
    00698                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
    00699                                 {
    00700                                 yy_current_state = (int) yy_def[yy_current_state];
    00701                                 if ( yy_current_state >= 66 )
    00702                                         yy_c = yy_meta[(unsigned int) yy_c];
    00703                                 }
    00704                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
    00705                         ++yy_cp;
    00706                         }
    00707                 while ( yy_current_state != 65 );
    00708                 yy_cp = yy_last_accepting_cpos;
    00709                 yy_current_state = yy_last_accepting_state;
    00710
    00711 yy_find_action:
    00712                 yy_act = yy_accept[yy_current_state];
    00713
    00714                 YY_DO_BEFORE_ACTION;
    00715
    00716
    00717 do_action:      /* This label is used only to access EOF actions. */
    00718
    00719
    00720                 switch ( yy_act )
    00721         { /* beginning of action switch */
    00722                         case 0: /* must back up */
    00723                         /* undo the effects of YY_DO_BEFORE_ACTION */
    00724                         *yy_cp = yy_hold_char;
    00725                         yy_cp = yy_last_accepting_cpos;
    00726                         yy_current_state = yy_last_accepting_state;
    00727                         goto yy_find_action;
    00728
    00729 case 1:
    00730 YY_RULE_SETUP
    00731 #line 45 "CCMEReader.l"
    00732 return TOK_CCME_FILE_HEADER_1;
    00733         YY_BREAK
    00734 case 2:
    00735 YY_RULE_SETUP
    00736 #line 46 "CCMEReader.l"
    00737 return TOK_DISSENTS;
    00738         YY_BREAK
    00739 case 3:
    00740 YY_RULE_SETUP
    00741 #line 47 "CCMEReader.l"
    00742 return TOK_TRANSITIONS;
    00743         YY_BREAK
    00744 case 4:
    00745 YY_RULE_SETUP
    00746 #line 48 "CCMEReader.l"
    00747 return TOK_PROBABILITY;
    00748         YY_BREAK
    00749 case 5:
    00750 YY_RULE_SETUP
    00751 #line 50 "CCMEReader.l"
    00752 {
    00753         yyCCMEReaderlval.val = atoi(yytext);
    00754         return TOK_INTEGER;
    00755 }
    00756         YY_BREAK
    00757 case 6:
    00758 YY_RULE_SETUP
    00759 #line 55 "CCMEReader.l"
    00760 {
    00761         yyCCMEReaderlval.dbl = atof(yytext);
    00762         return TOK_REAL;
    00763 }
    00764         YY_BREAK
    00765 case 7:
    00766 YY_RULE_SETUP
    00767 #line 60 "CCMEReader.l"
    00768 {
    00769   yyCCMEReaderlval.str = new char[strlen(yytext) + 1];
    00770         strcpy(yyCCMEReaderlval.str, yytext);
    00771   return TOK_NAME;
    00772 }
    00773         YY_BREAK
    00774 case 8:
    00775 YY_RULE_SETUP
    00776 #line 66 "CCMEReader.l"
    00777 {
    00778         yyCCMEReaderlval.str = new char[strlen(yytext)];
    00779         strcpy(yyCCMEReaderlval.str, yytext + 1);
    00780         yyCCMEReaderlval.str[strlen(yyCCMEReaderlval.str) - 1] = '\0';
    00781         return TOK_NAME;
    00782 }
    00783         YY_BREAK
    00784 case 9:
    00785 YY_RULE_SETUP
    00786 #line 73 "CCMEReader.l"
    00787 {
    00788   return yytext[0];
    00789 }
    00790         YY_BREAK
    00791 case 10:
    00792 YY_RULE_SETUP
    00793 #line 77 "CCMEReader.l"
    00794 {
    00795         return TOK_ARROW;
    00796 }
    00797         YY_BREAK
    00798 case 11:
    00799 YY_RULE_SETUP
    00800 #line 81 "CCMEReader.l"
    00801 {
    00802   //cout << "::::YYLEX::Ignoring white space" << endl;
    00803 }
    00804         YY_BREAK
    00805 case 12:
    00806 YY_RULE_SETUP
    00807 #line 85 "CCMEReader.l"
    00808 {
    00809   yyCCMEReaderline++;
    00810 }
    00811         YY_BREAK
    00812 case 13:
    00813 YY_RULE_SETUP
    00814 #line 89 "CCMEReader.l"
    00815 {
    00816 }
    00817         YY_BREAK
    00818 case 14:
    00819 YY_RULE_SETUP
    00820 #line 92 "CCMEReader.l"
    00821 {
    00822         // ignore one line comments
    00823 }
    00824         YY_BREAK
    00825 case 15:
    00826 YY_RULE_SETUP
    00827 #line 96 "CCMEReader.l"
    00828 {
    00829   cout << "!!!!Invalid input: \"" << yytext << "\"!!!!" << endl;
    00830   yyterminate();
    00831 }
    00832         YY_BREAK
    00833 case 16:
    00834 YY_RULE_SETUP
    00835 #line 101 "CCMEReader.l"
    00836 ECHO;
    00837         YY_BREAK
    00838 #line 839 "CCMEReader.yy.cpp"
    00839 case YY_STATE_EOF(INITIAL):
    00840         yyterminate();
    00841
    00842         case YY_END_OF_BUFFER:
    00843                 {
    00844                 /* Amount of text matched not including the EOB char. */
    00845                 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
    00846
    00847                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
    00848                 *yy_cp = yy_hold_char;
    00849                 YY_RESTORE_YY_MORE_OFFSET
    00850
    00851                 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
    00852                         {
    00853                         /* We're scanning a new file or input source.  It's
    00854                          * possible that this happened because the user
    00855                          * just pointed yyin at a new source and called
    00856                          * yylex().  If so, then we have to assure
    00857                          * consistency between yy_current_buffer and our
    00858                          * globals.  Here is the right place to do so, because
    00859                          * this is the first action (other than possibly a
    00860                          * back-up) that will match for the new input source.
    00861                          */
    00862                         yy_n_chars = yy_current_buffer->yy_n_chars;
    00863                         yy_current_buffer->yy_input_file = yyin;
    00864                         yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
    00865                         }
    00866
    00867                 /* Note that here we test for yy_c_buf_p "<=" to the position
    00868                  * of the first EOB in the buffer, since yy_c_buf_p will
    00869                  * already have been incremented past the NUL character
    00870                  * (since all states make transitions on EOB to the
    00871                  * end-of-buffer state).  Contrast this with the test
    00872                  * in input().
    00873                  */
    00874                 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
    00875                         { /* This was really a NUL. */
    00876                         yy_state_type yy_next_state;
    00877
    00878                         yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
    00879
    00880                         yy_current_state = yy_get_previous_state();
    00881
    00882                         /* Okay, we're now positioned to make the NUL
    00883                          * transition.  We couldn't have
    00884                          * yy_get_previous_state() go ahead and do it
    00885                          * for us because it doesn't know how to deal
    00886                          * with the possibility of jamming (and we don't
    00887                          * want to build jamming into it because then it
    00888                          * will run more slowly).
    00889                          */
    00890
    00891                         yy_next_state = yy_try_NUL_trans( yy_current_state );
    00892
    00893                         yy_bp = yytext_ptr + YY_MORE_ADJ;
    00894
    00895                         if ( yy_next_state )
    00896                                 {
    00897                                 /* Consume the NUL. */
    00898                                 yy_cp = ++yy_c_buf_p;
    00899                                 yy_current_state = yy_next_state;
    00900                                 goto yy_match;
    00901                                 }
    00902
    00903                         else
    00904                                 {
    00905                                 yy_cp = yy_last_accepting_cpos;
    00906                                 yy_current_state = yy_last_accepting_state;
    00907                                 goto yy_find_action;
    00908                                 }
    00909                         }
    00910
    00911                 else switch ( yy_get_next_buffer() )
    00912                         {
    00913                         case EOB_ACT_END_OF_FILE:
    00914                                 {
    00915                                 yy_did_buffer_switch_on_eof = 0;
    00916
    00917                                 if ( yywrap() )
    00918                                         {
    00919                                         /* Note: because we've taken care in
    00920                                          * yy_get_next_buffer() to have set up
    00921                                          * yytext, we can now set up
    00922                                          * yy_c_buf_p so that if some total
    00923                                          * hoser (like flex itself) wants to
    00924                                          * call the scanner after we return the
    00925                                          * YY_NULL, it'll still work - another
    00926                                          * YY_NULL will get returned.
    00927                                          */
    00928                                         yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
    00929
    00930                                         yy_act = YY_STATE_EOF(YY_START);
    00931                                         goto do_action;
    00932                                         }
    00933
    00934                                 else
    00935                                         {
    00936                                         if ( ! yy_did_buffer_switch_on_eof )
    00937                                                 YY_NEW_FILE;
    00938                                         }
    00939                                 break;
    00940                                 }
    00941
    00942                         case EOB_ACT_CONTINUE_SCAN:
    00943                                 yy_c_buf_p =
    00944                                         yytext_ptr + yy_amount_of_matched_text;
    00945
    00946                                 yy_current_state = yy_get_previous_state();
    00947
    00948                                 yy_cp = yy_c_buf_p;
    00949                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
    00950                                 goto yy_match;
    00951
    00952                         case EOB_ACT_LAST_MATCH:
    00953                                 yy_c_buf_p =
    00954                                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
    00955
    00956                                 yy_current_state = yy_get_previous_state();
    00957
    00958                                 yy_cp = yy_c_buf_p;
    00959                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
    00960                                 goto yy_find_action;
    00961                         }
    00962                 break;
    00963                 }
    00964
    00965         default:
    00966                 YY_FATAL_ERROR(
    00967                         "fatal flex scanner internal error--no action found" );
    00968         } /* end of action switch */
    00969                 } /* end of scanning one token */
    00970         } /* end of yylex */
    00971
    00972
    00973 /* yy_get_next_buffer - try to read in a new buffer
    00974  *
    00975  * Returns a code representing an action:
    00976  *      EOB_ACT_LAST_MATCH -
    00977  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
    00978  *      EOB_ACT_END_OF_FILE - end of file
    00979  */
    00980
    00981 static int yy_get_next_buffer()
    00982         {
    00983         register char *dest = yy_current_buffer->yy_ch_buf;
    00984         register char *source = yytext_ptr;
    00985         register int number_to_move, i;
    00986         int ret_val;
    00987
    00988         if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
    00989                 YY_FATAL_ERROR(
    00990                 "fatal flex scanner internal error--end of buffer missed" );
    00991
    00992         if ( yy_current_buffer->yy_fill_buffer == 0 )
    00993                 { /* Don't try to fill the buffer, so this is an EOF. */
    00994                 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
    00995                         {
    00996                         /* We matched a single character, the EOB, so
    00997                          * treat this as a final EOF.
    00998                          */
    00999                         return EOB_ACT_END_OF_FILE;
    01000                         }
    01001
    01002                 else
    01003                         {
    01004                         /* We matched some text prior to the EOB, first
    01005                          * process it.
    01006                          */
    01007                         return EOB_ACT_LAST_MATCH;
    01008                         }
    01009                 }
    01010
    01011         /* Try to read more data. */
    01012
    01013         /* First move last chars to start of buffer. */
    01014         number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
    01015
    01016         for ( i = 0; i < number_to_move; ++i )
    01017                 *(dest++) = *(source++);
    01018
    01019         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
    01020                 /* don't do the read, it's not guaranteed to return an EOF,
    01021                  * just force an EOF
    01022                  */
    01023                 yy_current_buffer->yy_n_chars = yy_n_chars = 0;
    01024
    01025         else
    01026                 {
    01027                 int num_to_read =
    01028                         yy_current_buffer->yy_buf_size - number_to_move - 1;
    01029
    01030                 while ( num_to_read <= 0 )
    01031                         { /* Not enough room in the buffer - grow it. */
    01032 #ifdef YY_USES_REJECT
    01033                         YY_FATAL_ERROR(
    01034 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
    01035 #else
    01036
    01037                         /* just a shorter name for the current buffer */
    01038                         YY_BUFFER_STATE b = yy_current_buffer;
    01039
    01040                         int yy_c_buf_p_offset =
    01041                                 (int) (yy_c_buf_p - b->yy_ch_buf);
    01042
    01043                         if ( b->yy_is_our_buffer )
    01044                                 {
    01045                                 int new_size = b->yy_buf_size * 2;
    01046
    01047                                 if ( new_size <= 0 )
    01048                                         b->yy_buf_size += b->yy_buf_size / 8;
    01049                                 else
    01050                                         b->yy_buf_size *= 2;
    01051
    01052                                 b->yy_ch_buf = (char *)
    01053                                         /* Include room in for 2 EOB chars. */
    01054                                         yy_flex_realloc( (void *) b->yy_ch_buf,
    01055                                                          b->yy_buf_size + 2 );
    01056                                 }
    01057                         else
    01058                                 /* Can't grow it, we don't own it. */
    01059                                 b->yy_ch_buf = 0;
    01060
    01061                         if ( ! b->yy_ch_buf )
    01062                                 YY_FATAL_ERROR(
    01063                                 "fatal error - scanner input buffer overflow" );
    01064
    01065                         yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
    01066
    01067                         num_to_read = yy_current_buffer->yy_buf_size -
    01068                                                 number_to_move - 1;
    01069 #endif
    01070                         }
    01071
    01072                 if ( num_to_read > YY_READ_BUF_SIZE )
    01073                         num_to_read = YY_READ_BUF_SIZE;
    01074
    01075                 /* Read in more data. */
    01076                 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
    01077                         yy_n_chars, num_to_read );
    01078
    01079                 yy_current_buffer->yy_n_chars = yy_n_chars;
    01080                 }
    01081
    01082         if ( yy_n_chars == 0 )
    01083                 {
    01084                 if ( number_to_move == YY_MORE_ADJ )
    01085                         {
    01086                         ret_val = EOB_ACT_END_OF_FILE;
    01087                         yyrestart( yyin );
    01088                         }
    01089
    01090                 else
    01091                         {
    01092                         ret_val = EOB_ACT_LAST_MATCH;
    01093                         yy_current_buffer->yy_buffer_status =
    01094                                 YY_BUFFER_EOF_PENDING;
    01095                         }
    01096                 }
    01097
    01098         else
    01099                 ret_val = EOB_ACT_CONTINUE_SCAN;
    01100
    01101         yy_n_chars += number_to_move;
    01102         yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
    01103         yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
    01104
    01105         yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
    01106
    01107         return ret_val;
    01108         }
    01109
    01110
    01111 /* yy_get_previous_state - get the state just before the EOB char was reached */
    01112
    01113 static yy_state_type yy_get_previous_state()
    01114         {
    01115         register yy_state_type yy_current_state;
    01116         register char *yy_cp;
    01117
    01118         yy_current_state = yy_start;
    01119
    01120         for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
    01121                 {
    01122                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
    01123                 if ( yy_accept[yy_current_state] )
    01124                         {
    01125                         yy_last_accepting_state = yy_current_state;
    01126                         yy_last_accepting_cpos = yy_cp;
    01127                         }
    01128                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
    01129                         {
    01130                         yy_current_state = (int) yy_def[yy_current_state];
    01131                         if ( yy_current_state >= 66 )
    01132                                 yy_c = yy_meta[(unsigned int) yy_c];
    01133                         }
    01134                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
    01135                 }
    01136
    01137         return yy_current_state;
    01138         }
    01139
    01140
    01141 /* yy_try_NUL_trans - try to make a transition on the NUL character
    01142  *
    01143  * synopsis
    01144  *      next_state = yy_try_NUL_trans( current_state );
    01145  */
    01146
    01147 #ifdef YY_USE_PROTOS
    01148 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
    01149 #else
    01150 static yy_state_type yy_try_NUL_trans( yy_current_state )
    01151 yy_state_type yy_current_state;
    01152 #endif
    01153         {
    01154         register int yy_is_jam;
    01155         register char *yy_cp = yy_c_buf_p;
    01156
    01157         register YY_CHAR yy_c = 1;
    01158         if ( yy_accept[yy_current_state] )
    01159                 {
    01160                 yy_last_accepting_state = yy_current_state;
    01161                 yy_last_accepting_cpos = yy_cp;
    01162                 }
    01163         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
    01164                 {
    01165                 yy_current_state = (int) yy_def[yy_current_state];
    01166                 if ( yy_current_state >= 66 )
    01167                         yy_c = yy_meta[(unsigned int) yy_c];
    01168                 }
    01169         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
    01170         yy_is_jam = (yy_current_state == 65);
    01171
    01172         return yy_is_jam ? 0 : yy_current_state;
    01173         }
    01174
    01175
    01176 #ifndef YY_NO_UNPUT
    01177 #ifdef YY_USE_PROTOS
    01178 static void yyunput( int c, register char *yy_bp )
    01179 #else
    01180 static void yyunput( c, yy_bp )
    01181 int c;
    01182 register char *yy_bp;
    01183 #endif
    01184         {
    01185         register char *yy_cp = yy_c_buf_p;
    01186
    01187         /* undo effects of setting up yytext */
    01188         *yy_cp = yy_hold_char;
    01189
    01190         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
    01191                 { /* need to shift things up to make room */
    01192                 /* +2 for EOB chars. */
    01193                 register int number_to_move = yy_n_chars + 2;
    01194                 register char *dest = &yy_current_buffer->yy_ch_buf[
    01195                                         yy_current_buffer->yy_buf_size + 2];
    01196                 register char *source =
    01197                                 &yy_current_buffer->yy_ch_buf[number_to_move];
    01198
    01199                 while ( source > yy_current_buffer->yy_ch_buf )
    01200                         *--dest = *--source;
    01201
    01202                 yy_cp += (int) (dest - source);
    01203                 yy_bp += (int) (dest - source);
    01204                 yy_current_buffer->yy_n_chars =
    01205                         yy_n_chars = yy_current_buffer->yy_buf_size;
    01206
    01207                 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
    01208                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
    01209                 }
    01210
    01211         *--yy_cp = (char) c;
    01212
    01213
    01214         yytext_ptr = yy_bp;
    01215         yy_hold_char = *yy_cp;
    01216         yy_c_buf_p = yy_cp;
    01217         }
    01218 #endif  /* ifndef YY_NO_UNPUT */
    01219
    01220
    01221 #ifdef __cplusplus
    01222 static int yyinput()
    01223 #else
    01224 static int input()
    01225 #endif
    01226         {
    01227         int c;
    01228
    01229         *yy_c_buf_p = yy_hold_char;
    01230
    01231         if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
    01232                 {
    01233                 /* yy_c_buf_p now points to the character we want to return.
    01234                  * If this occurs *before* the EOB characters, then it's a
    01235                  * valid NUL; if not, then we've hit the end of the buffer.
    01236                  */
    01237                 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
    01238                         /* This was really a NUL. */
    01239                         *yy_c_buf_p = '\0';
    01240
    01241                 else
    01242                         { /* need more input */
    01243                         int offset = yy_c_buf_p - yytext_ptr;
    01244                         ++yy_c_buf_p;
    01245
    01246                         switch ( yy_get_next_buffer() )
    01247                                 {
    01248                                 case EOB_ACT_LAST_MATCH:
    01249                                         /* This happens because yy_g_n_b()
    01250                                          * sees that we've accumulated a
    01251                                          * token and flags that we need to
    01252                                          * try matching the token before
    01253                                          * proceeding.  But for input(),
    01254                                          * there's no matching to consider.
    01255                                          * So convert the EOB_ACT_LAST_MATCH
    01256                                          * to EOB_ACT_END_OF_FILE.
    01257                                          */
    01258
    01259                                         /* Reset buffer status. */
    01260                                         yyrestart( yyin );
    01261
    01262                                         /* fall through */
    01263
    01264                                 case EOB_ACT_END_OF_FILE:
    01265                                         {
    01266                                         if ( yywrap() )
    01267                                                 return EOF;
    01268
    01269                                         if ( ! yy_did_buffer_switch_on_eof )
    01270                                                 YY_NEW_FILE;
    01271 #ifdef __cplusplus
    01272                                         return yyinput();
    01273 #else
    01274                                         return input();
    01275 #endif
    01276                                         }
    01277
    01278                                 case EOB_ACT_CONTINUE_SCAN:
    01279                                         yy_c_buf_p = yytext_ptr + offset;
    01280                                         break;
    01281                                 }
    01282                         }
    01283                 }
    01284
    01285         c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */
    01286         *yy_c_buf_p = '\0';     /* preserve yytext */
    01287         yy_hold_char = *++yy_c_buf_p;
    01288
    01289
    01290         return c;
    01291         }
    01292
    01293
    01294 #ifdef YY_USE_PROTOS
    01295 void yyrestart( FILE *input_file )
    01296 #else
    01297 void yyrestart( input_file )
    01298 FILE *input_file;
    01299 #endif
    01300         {
    01301         if ( ! yy_current_buffer )
    01302                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
    01303
    01304         yy_init_buffer( yy_current_buffer, input_file );
    01305         yy_load_buffer_state();
    01306         }
    01307
    01308
    01309 #ifdef YY_USE_PROTOS
    01310 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
    01311 #else
    01312 void yy_switch_to_buffer( new_buffer )
    01313 YY_BUFFER_STATE new_buffer;
    01314 #endif
    01315         {
    01316         if ( yy_current_buffer == new_buffer )
    01317                 return;
    01318
    01319         if ( yy_current_buffer )
    01320                 {
    01321                 /* Flush out information for old buffer. */
    01322                 *yy_c_buf_p = yy_hold_char;
    01323                 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
    01324                 yy_current_buffer->yy_n_chars = yy_n_chars;
    01325                 }
    01326
    01327         yy_current_buffer = new_buffer;
    01328         yy_load_buffer_state();
    01329
    01330         /* We don't actually know whether we did this switch during
    01331          * EOF (yywrap()) processing, but the only time this flag
    01332          * is looked at is after yywrap() is called, so it's safe
    01333          * to go ahead and always set it.
    01334          */
    01335         yy_did_buffer_switch_on_eof = 1;
    01336         }
    01337
    01338
    01339 #ifdef YY_USE_PROTOS
    01340 void yy_load_buffer_state( void )
    01341 #else
    01342 void yy_load_buffer_state()
    01343 #endif
    01344         {
    01345         yy_n_chars = yy_current_buffer->yy_n_chars;
    01346         yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
    01347         yyin = yy_current_buffer->yy_input_file;
    01348         yy_hold_char = *yy_c_buf_p;
    01349         }
    01350
    01351
    01352 #ifdef YY_USE_PROTOS
    01353 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
    01354 #else
    01355 YY_BUFFER_STATE yy_create_buffer( file, size )
    01356 FILE *file;
    01357 int size;
    01358 #endif
    01359         {
    01360         YY_BUFFER_STATE b;
    01361
    01362         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
    01363         if ( ! b )
    01364                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
    01365
    01366         b->yy_buf_size = size;
    01367
    01368         /* yy_ch_buf has to be 2 characters longer than the size given because
    01369          * we need to put in 2 end-of-buffer characters.
    01370          */
    01371         b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
    01372         if ( ! b->yy_ch_buf )
    01373                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
    01374
    01375         b->yy_is_our_buffer = 1;
    01376
    01377         yy_init_buffer( b, file );
    01378
    01379         return b;
    01380         }
    01381
    01382
    01383 #ifdef YY_USE_PROTOS
    01384 void yy_delete_buffer( YY_BUFFER_STATE b )
    01385 #else
    01386 void yy_delete_buffer( b )
    01387 YY_BUFFER_STATE b;
    01388 #endif
    01389         {
    01390         if ( ! b )
    01391                 return;
    01392
    01393         if ( b == yy_current_buffer )
    01394                 yy_current_buffer = (YY_BUFFER_STATE) 0;
    01395
    01396         if ( b->yy_is_our_buffer )
    01397                 yy_flex_free( (void *) b->yy_ch_buf );
    01398
    01399         yy_flex_free( (void *) b );
    01400         }
    01401
    01402
    01403 #ifndef _WIN32
    01404 #include <unistd.h>
    01405 #else
    01406 #ifndef YY_ALWAYS_INTERACTIVE
    01407 #ifndef YY_NEVER_INTERACTIVE
    01408 extern int isatty YY_PROTO(( int ));
    01409 #endif
    01410 #endif
    01411 #endif
    01412
    01413 #ifdef YY_USE_PROTOS
    01414 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
    01415 #else
    01416 void yy_init_buffer( b, file )
    01417 YY_BUFFER_STATE b;
    01418 FILE *file;
    01419 #endif
    01420
    01421
    01422         {
    01423         yy_flush_buffer( b );
    01424
    01425         b->yy_input_file = file;
    01426         b->yy_fill_buffer = 1;
    01427
    01428 #if YY_ALWAYS_INTERACTIVE
    01429         b->yy_is_interactive = 1;
    01430 #else
    01431 #if YY_NEVER_INTERACTIVE
    01432         b->yy_is_interactive = 0;
    01433 #else
    01434         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
    01435 #endif
    01436 #endif
    01437         }
    01438
    01439
    01440 #ifdef YY_USE_PROTOS
    01441 void yy_flush_buffer( YY_BUFFER_STATE b )
    01442 #else
    01443 void yy_flush_buffer( b )
    01444 YY_BUFFER_STATE b;
    01445 #endif
    01446
    01447         {
    01448         if ( ! b )
    01449                 return;
    01450
    01451         b->yy_n_chars = 0;
    01452
    01453         /* We always need two end-of-buffer characters.  The first causes
    01454          * a transition to the end-of-buffer state.  The second causes
    01455          * a jam in that state.
    01456          */
    01457         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
    01458         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
    01459
    01460         b->yy_buf_pos = &b->yy_ch_buf[0];
    01461
    01462         b->yy_at_bol = 1;
    01463         b->yy_buffer_status = YY_BUFFER_NEW;
    01464
    01465         if ( b == yy_current_buffer )
    01466                 yy_load_buffer_state();
    01467         }
    01468
    01469
    01470 #ifndef YY_NO_SCAN_BUFFER
    01471 #ifdef YY_USE_PROTOS
    01472 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
    01473 #else
    01474 YY_BUFFER_STATE yy_scan_buffer( base, size )
    01475 char *base;
    01476 yy_size_t size;
    01477 #endif
    01478         {
    01479         YY_BUFFER_STATE b;
    01480
    01481         if ( size < 2 ||
    01482              base[size-2] != YY_END_OF_BUFFER_CHAR ||
    01483              base[size-1] != YY_END_OF_BUFFER_CHAR )
    01484                 /* They forgot to leave room for the EOB's. */
    01485                 return 0;
    01486
    01487         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
    01488         if ( ! b )
    01489                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
    01490
    01491         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
    01492         b->yy_buf_pos = b->yy_ch_buf = base;
    01493         b->yy_is_our_buffer = 0;
    01494         b->yy_input_file = 0;
    01495         b->yy_n_chars = b->yy_buf_size;
    01496         b->yy_is_interactive = 0;
    01497         b->yy_at_bol = 1;
    01498         b->yy_fill_buffer = 0;
    01499         b->yy_buffer_status = YY_BUFFER_NEW;
    01500
    01501         yy_switch_to_buffer( b );
    01502
    01503         return b;
    01504         }
    01505 #endif
    01506
    01507
    01508 #ifndef YY_NO_SCAN_STRING
    01509 #ifdef YY_USE_PROTOS
    01510 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
    01511 #else
    01512 YY_BUFFER_STATE yy_scan_string( yy_str )
    01513 yyconst char *yy_str;
    01514 #endif
    01515         {
    01516         int len;
    01517         for ( len = 0; yy_str[len]; ++len )
    01518                 ;
    01519
    01520         return yy_scan_bytes( yy_str, len );
    01521         }
    01522 #endif
    01523
    01524
    01525 #ifndef YY_NO_SCAN_BYTES
    01526 #ifdef YY_USE_PROTOS
    01527 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
    01528 #else
    01529 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
    01530 yyconst char *bytes;
    01531 int len;
    01532 #endif
    01533         {
    01534         YY_BUFFER_STATE b;
    01535         char *buf;
    01536         yy_size_t n;
    01537         int i;
    01538
    01539         /* Get memory for full buffer, including space for trailing EOB's. */
    01540         n = len + 2;
    01541         buf = (char *) yy_flex_alloc( n );
    01542         if ( ! buf )
    01543                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
    01544
    01545         for ( i = 0; i < len; ++i )
    01546                 buf[i] = bytes[i];
    01547
    01548         buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
    01549
    01550         b = yy_scan_buffer( buf, n );
    01551         if ( ! b )
    01552                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
    01553
    01554         /* It's okay to grow etc. this buffer, and we should throw it
    01555          * away when we're done.
    01556          */
    01557         b->yy_is_our_buffer = 1;
    01558
    01559         return b;
    01560         }
    01561 #endif
    01562
    01563
    01564 #ifndef YY_NO_PUSH_STATE
    01565 #ifdef YY_USE_PROTOS
    01566 static void yy_push_state( int new_state )
    01567 #else
    01568 static void yy_push_state( new_state )
    01569 int new_state;
    01570 #endif
    01571         {
    01572         if ( yy_start_stack_ptr >= yy_start_stack_depth )
    01573                 {
    01574                 yy_size_t new_size;
    01575
    01576                 yy_start_stack_depth += YY_START_STACK_INCR;
    01577                 new_size = yy_start_stack_depth * sizeof( int );
    01578
    01579                 if ( ! yy_start_stack )
    01580                         yy_start_stack = (int *) yy_flex_alloc( new_size );
    01581
    01582                 else
    01583                         yy_start_stack = (int *) yy_flex_realloc(
    01584                                         (void *) yy_start_stack, new_size );
    01585
    01586                 if ( ! yy_start_stack )
    01587                         YY_FATAL_ERROR(
    01588                         "out of memory expanding start-condition stack" );
    01589                 }
    01590
    01591         yy_start_stack[yy_start_stack_ptr++] = YY_START;
    01592
    01593         BEGIN(new_state);
    01594         }
    01595 #endif
    01596
    01597
    01598 #ifndef YY_NO_POP_STATE
    01599 static void yy_pop_state()
    01600         {
    01601         if ( --yy_start_stack_ptr < 0 )
    01602                 YY_FATAL_ERROR( "start-condition stack underflow" );
    01603
    01604         BEGIN(yy_start_stack[yy_start_stack_ptr]);
    01605         }
    01606 #endif
    01607
    01608
    01609 #ifndef YY_NO_TOP_STATE
    01610 static int yy_top_state()
    01611         {
    01612         return yy_start_stack[yy_start_stack_ptr - 1];
    01613         }
    01614 #endif
    01615
    01616 #ifndef YY_EXIT_FAILURE
    01617 #define YY_EXIT_FAILURE 2
    01618 #endif
    01619
    01620 #ifdef YY_USE_PROTOS
    01621 static void yy_fatal_error( yyconst char msg[] )
    01622 #else
    01623 static void yy_fatal_error( msg )
    01624 char msg[];
    01625 #endif
    01626         {
    01627         (void) fprintf( stderr, "%s\n", msg );
    01628         exit( YY_EXIT_FAILURE );
    01629         }
    01630
    01631
    01632
    01633 /* Redefine yyless() so it works in section 3 code. */
    01634
    01635 #undef yyless
    01636 #define yyless(n) \
    01637         do \
    01638                 { \
    01639                 /* Undo effects of setting up yytext. */ \
    01640                 yytext[yyleng] = yy_hold_char; \
    01641                 yy_c_buf_p = yytext + n; \
    01642                 yy_hold_char = *yy_c_buf_p; \
    01643                 *yy_c_buf_p = '\0'; \
    01644                 yyleng = n; \
    01645                 } \
    01646         while ( 0 )
    01647
    01648
    01649 /* Internal utility routines. */
    01650
    01651 #ifndef yytext_ptr
    01652 #ifdef YY_USE_PROTOS
    01653 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
    01654 #else
    01655 static void yy_flex_strncpy( s1, s2, n )
    01656 char *s1;
    01657 yyconst char *s2;
    01658 int n;
    01659 #endif
    01660         {
    01661         register int i;
    01662         for ( i = 0; i < n; ++i )
    01663                 s1[i] = s2[i];
    01664         }
    01665 #endif
    01666
    01667 #ifdef YY_NEED_STRLEN
    01668 #ifdef YY_USE_PROTOS
    01669 static int yy_flex_strlen( yyconst char *s )
    01670 #else
    01671 static int yy_flex_strlen( s )
    01672 yyconst char *s;
    01673 #endif
    01674         {
    01675         register int n;
    01676         for ( n = 0; s[n]; ++n )
    01677                 ;
    01678
    01679         return n;
    01680         }
    01681 #endif
    01682
    01683
    01684 #ifdef YY_USE_PROTOS
    01685 static void *yy_flex_alloc( yy_size_t size )
    01686 #else
    01687 static void *yy_flex_alloc( size )
    01688 yy_size_t size;
    01689 #endif
    01690         {
    01691         return (void *) malloc( size );
    01692         }
    01693
    01694 #ifdef YY_USE_PROTOS
    01695 static void *yy_flex_realloc( void *ptr, yy_size_t size )
    01696 #else
    01697 static void *yy_flex_realloc( ptr, size )
    01698 void *ptr;
    01699 yy_size_t size;
    01700 #endif
    01701         {
    01702         /* The cast to (char *) in the following accommodates both
    01703          * implementations that use char* generic pointers, and those
    01704          * that use void* generic pointers.  It works with the latter
    01705          * because both ANSI C and C++ allow castless assignment from
    01706          * any pointer type to void*, and deal with argument conversions
    01707          * as though doing an assignment.
    01708          */
    01709         return (void *) realloc( (char *) ptr, size );
    01710         }
    01711
    01712 #ifdef YY_USE_PROTOS
    01713 static void yy_flex_free( void *ptr )
    01714 #else
    01715 static void yy_flex_free( ptr )
    01716 void *ptr;
    01717 #endif
    01718         {
    01719         free( ptr );
    01720         }
    01721
    01722 #if YY_MAIN
    01723 int main()
    01724         {
    01725         yylex();
    01726         return 0;
    01727         }
    01728 #endif
    01729 #line 101 "CCMEReader.l"
    01730
    01731