Main Page | Modules | Class Hierarchy | Class List | File List | Class Members | File Members | Related Pages | Examples

lex.yy.c

00001 #line 2 "src/acpp/lex.yy.c"
00002 /* A lexical scanner generated by flex */
00003 
00004 /* Scanner skeleton version:
00005  * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.91 96/09/10 16:58:48 vern Exp $
00006  */
00007 
00008 #define FLEX_SCANNER
00009 #define YY_FLEX_MAJOR_VERSION 2
00010 #define YY_FLEX_MINOR_VERSION 5
00011 
00012 #include <stdio.h>
00013 #include <unistd.h>
00014 
00015 
00016 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
00017 #ifdef c_plusplus
00018 #ifndef __cplusplus
00019 #define __cplusplus
00020 #endif
00021 #endif
00022 
00023 
00024 #ifdef __cplusplus
00025 
00026 #include <stdlib.h>
00027 
00028 /* Use prototypes in function declarations. */
00029 #define YY_USE_PROTOS
00030 
00031 /* The "const" storage-class-modifier is valid. */
00032 #define YY_USE_CONST
00033 
00034 #else   /* ! __cplusplus */
00035 
00036 #if __STDC__
00037 
00038 #define YY_USE_PROTOS
00039 #define YY_USE_CONST
00040 
00041 #endif  /* __STDC__ */
00042 #endif  /* ! __cplusplus */
00043 
00044 #ifdef __TURBOC__
00045  #pragma warn -rch
00046  #pragma warn -use
00047 #include <io.h>
00048 #include <stdlib.h>
00049 #define YY_USE_CONST
00050 #define YY_USE_PROTOS
00051 #endif
00052 
00053 #ifdef YY_USE_CONST
00054 #define yyconst const
00055 #else
00056 #define yyconst
00057 #endif
00058 
00059 
00060 #ifdef YY_USE_PROTOS
00061 #define YY_PROTO(proto) proto
00062 #else
00063 #define YY_PROTO(proto) ()
00064 #endif
00065 
00066 /* Returned upon end-of-file. */
00067 #define YY_NULL 0
00068 
00069 /* Promotes a possibly negative, possibly signed char to an unsigned
00070  * integer for use as an array index.  If the signed char is negative,
00071  * we want to instead treat it as an 8-bit unsigned char, hence the
00072  * double cast.
00073  */
00074 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
00075 
00076 /* Enter a start condition.  This macro really ought to take a parameter,
00077  * but we do it the disgusting crufty way forced on us by the ()-less
00078  * definition of BEGIN.
00079  */
00080 #define BEGIN yy_start = 1 + 2 *
00081 
00082 /* Translate the current start state into a value that can be later handed
00083  * to BEGIN to return to the state.  The YYSTATE alias is for lex
00084  * compatibility.
00085  */
00086 #define YY_START ((yy_start - 1) / 2)
00087 #define YYSTATE YY_START
00088 
00089 /* Action number for EOF rule of a given start state. */
00090 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
00091 
00092 /* Special action meaning "start processing a new file". */
00093 #define YY_NEW_FILE yyrestart( yyin )
00094 
00095 #define YY_END_OF_BUFFER_CHAR 0
00096 
00097 /* Size of default input buffer. */
00098 #define YY_BUF_SIZE 16384
00099 
00100 typedef struct yy_buffer_state *YY_BUFFER_STATE;
00101 
00102 extern int yyleng;
00103 extern FILE *yyin, *yyout;
00104 
00105 #define EOB_ACT_CONTINUE_SCAN 0
00106 #define EOB_ACT_END_OF_FILE 1
00107 #define EOB_ACT_LAST_MATCH 2
00108 
00109 /* The funky do-while in the following #define is used to turn the definition
00110  * int a single C statement (which needs a semi-colon terminator).  This
00111  * avoids problems with code like:
00112  *
00113  *      if ( condition_holds )
00114  *              yyless( 5 );
00115  *      else
00116  *              do_something_else();
00117  *
00118  * Prior to using the do-while the compiler would get upset at the
00119  * "else" because it interpreted the "if" statement as being all
00120  * done when it reached the ';' after the yyless() call.
00121  */
00122 
00123 /* Return all but the first 'n' matched characters back to the input stream. */
00124 
00125 #define yyless(n) \
00126         do \
00127                 { \
00128                 /* Undo effects of setting up yytext. */ \
00129                 *yy_cp = yy_hold_char; \
00130                 YY_RESTORE_YY_MORE_OFFSET \
00131                 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
00132                 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
00133                 } \
00134         while ( 0 )
00135 
00136 #define unput(c) yyunput( c, yytext_ptr )
00137 
00138 /* The following is because we cannot portably get our hands on size_t
00139  * (without autoconf's help, which isn't available because we want
00140  * flex-generated scanners to compile on their own).
00141  */
00142 typedef unsigned int yy_size_t;
00143 
00144 
00145 struct yy_buffer_state
00146         {
00147         FILE *yy_input_file;
00148 
00149         char *yy_ch_buf;                /* input buffer */
00150         char *yy_buf_pos;               /* current position in input buffer */
00151 
00152         /* Size of input buffer in bytes, not including room for EOB
00153          * characters.
00154          */
00155         yy_size_t yy_buf_size;
00156 
00157         /* Number of characters read into yy_ch_buf, not including EOB
00158          * characters.
00159          */
00160         int yy_n_chars;
00161 
00162         /* Whether we "own" the buffer - i.e., we know we created it,
00163          * and can realloc() it to grow it, and should free() it to
00164          * delete it.
00165          */
00166         int yy_is_our_buffer;
00167 
00168         /* Whether this is an "interactive" input source; if so, and
00169          * if we're using stdio for input, then we want to use getc()
00170          * instead of fread(), to make sure we stop fetching input after
00171          * each newline.
00172          */
00173         int yy_is_interactive;
00174 
00175         /* Whether we're considered to be at the beginning of a line.
00176          * If so, '^' rules will be active on the next match, otherwise
00177          * not.
00178          */
00179         int yy_at_bol;
00180 
00181         /* Whether to try to fill the input buffer when we reach the
00182          * end of it.
00183          */
00184         int yy_fill_buffer;
00185 
00186         int yy_buffer_status;
00187 #define YY_BUFFER_NEW 0
00188 #define YY_BUFFER_NORMAL 1
00189         /* When an EOF's been seen but there's still some text to process
00190          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
00191          * shouldn't try reading from the input source any more.  We might
00192          * still have a bunch of tokens to match, though, because of
00193          * possible backing-up.
00194          *
00195          * When we actually see the EOF, we change the status to "new"
00196          * (via yyrestart()), so that the user can continue scanning by
00197          * just pointing yyin at a new input file.
00198          */
00199 #define YY_BUFFER_EOF_PENDING 2
00200         };
00201 
00202 static YY_BUFFER_STATE yy_current_buffer = 0;
00203 
00204 /* We provide macros for accessing buffer states in case in the
00205  * future we want to put the buffer states in a more general
00206  * "scanner state".
00207  */
00208 #define YY_CURRENT_BUFFER yy_current_buffer
00209 
00210 
00211 /* yy_hold_char holds the character lost when yytext is formed. */
00212 static char yy_hold_char;
00213 
00214 static int yy_n_chars;          /* number of characters read into yy_ch_buf */
00215 
00216 
00217 int yyleng;
00218 
00219 /* Points to current character in buffer. */
00220 static char *yy_c_buf_p = (char *) 0;
00221 static int yy_init = 1;         /* whether we need to initialize */
00222 static int yy_start = 0;        /* start state number */
00223 
00224 /* Flag which is used to allow yywrap()'s to do buffer switches
00225  * instead of setting up a fresh yyin.  A bit of a hack ...
00226  */
00227 static int yy_did_buffer_switch_on_eof;
00228 
00229 void yyrestart YY_PROTO(( FILE *input_file ));
00230 
00231 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
00232 void yy_load_buffer_state YY_PROTO(( void ));
00233 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
00234 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
00235 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
00236 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
00237 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
00238 
00239 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
00240 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
00241 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
00242 
00243 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
00244 static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
00245 static void yy_flex_free YY_PROTO(( void * ));
00246 
00247 #define yy_new_buffer yy_create_buffer
00248 
00249 #define yy_set_interactive(is_interactive) \
00250         { \
00251         if ( ! yy_current_buffer ) \
00252                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
00253         yy_current_buffer->yy_is_interactive = is_interactive; \
00254         }
00255 
00256 #define yy_set_bol(at_bol) \
00257         { \
00258         if ( ! yy_current_buffer ) \
00259                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
00260         yy_current_buffer->yy_at_bol = at_bol; \
00261         }
00262 
00263 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
00264 
00265 
00266 #define yywrap() 1
00267 #define YY_SKIP_YYWRAP
00268 typedef unsigned char YY_CHAR;
00269 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
00270 typedef int yy_state_type;
00271 extern char *yytext;
00272 #define yytext_ptr yytext
00273 
00274 static yy_state_type yy_get_previous_state YY_PROTO(( void ));
00275 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
00276 static int yy_get_next_buffer YY_PROTO(( void ));
00277 static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
00278 
00279 /* Done after the current pattern has been matched and before the
00280  * corresponding action - sets up yytext.
00281  */
00282 #define YY_DO_BEFORE_ACTION \
00283         yytext_ptr = yy_bp; \
00284         yyleng = (int) (yy_cp - yy_bp); \
00285         yy_hold_char = *yy_cp; \
00286         *yy_cp = '\0'; \
00287         yy_c_buf_p = yy_cp;
00288 
00289 #define YY_NUM_RULES 59
00290 #define YY_END_OF_BUFFER 60
00291 static yyconst short int yy_accept[225] =
00292     {   0,
00293         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
00294         0,    0,   60,   48,   20,   19,   16,    9,   10,    2,
00295         5,   48,    1,    1,    4,    3,    7,    6,    8,   47,
00296        47,   47,   11,   12,   47,   47,   47,   13,   14,   56,
00297        55,   56,   58,   57,   53,   52,   51,   50,   59,   49,
00298        20,   16,    9,   10,    2,    5,   59,    1,    4,    3,
00299         7,    6,    8,   47,   47,   47,   47,   47,   13,   14,
00300        17,   18,    1,   15,   47,   47,   47,   47,   47,   47,
00301        54,   49,   47,   47,   47,   47,   47,   47,   47,   47,
00302        47,   47,   47,   47,   47,   47,   47,   47,   47,   47,
00303 
00304        47,   47,   47,   47,   47,   47,   47,   47,   47,   47,
00305        47,   47,   47,   47,   47,   47,   47,   47,   47,   47,
00306        47,   47,   47,   47,   47,   47,   47,   47,   47,   47,
00307        47,   35,   47,   47,   47,   47,   47,   47,   47,   47,
00308        21,   47,   47,   47,   47,   47,   47,   47,   47,   47,
00309        47,   47,   47,   47,   36,   34,   47,   37,   47,   47,
00310        45,   47,   47,   29,   47,   47,   47,   47,   24,   47,
00311        47,   47,   47,   47,   47,   47,   47,   43,   47,   47,
00312        47,   46,   47,   22,   47,   28,   47,   47,   47,   47,
00313        31,   47,   47,   47,   47,   47,   42,   47,   47,   27,
00314 
00315        47,   47,   47,   30,   33,   47,   39,   32,   47,   47,
00316        47,   47,   25,   47,   47,   38,   47,   44,   26,   23,
00317        47,   40,   41,    0
00318     } ;
00319 
00320 static yyconst int yy_ec[256] =
00321     {   0,
00322         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
00323         1,    1,    2,    1,    1,    1,    1,    1,    1,    1,
00324         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00325         1,    2,    1,    4,    1,    1,    1,    1,    1,    5,
00326         6,    7,    1,    8,    1,    9,   10,   11,   12,   12,
00327        12,   12,   12,   12,   12,   12,   12,   13,   14,   15,
00328        16,   17,    1,    1,   18,   19,   20,   19,   19,   19,
00329        21,   22,   23,   21,   21,   21,   21,   21,   24,   21,
00330        21,   25,   26,   27,   21,   21,   21,   21,   21,   21,
00331        28,    1,   29,    1,   30,    1,   31,   32,   33,   34,
00332 
00333        35,   36,   37,   38,   39,   21,   40,   41,   42,   43,
00334        44,   45,   21,   46,   47,   48,   21,   21,   49,   50,
00335        51,   52,   53,    1,   54,    1,    1,    1,    1,    1,
00336         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00337         1,    1,    1,    1,    1,    1,    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 
00344         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00345         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
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
00350     } ;
00351 
00352 static yyconst int yy_meta[55] =
00353     {   0,
00354         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00355         2,    2,    1,    1,    1,    1,    1,    2,    2,    2,
00356         3,    3,    3,    3,    3,    3,    3,    1,    1,    3,
00357         2,    2,    2,    2,    2,    2,    3,    3,    3,    3,
00358         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
00359         3,    3,    1,    1
00360     } ;
00361 
00362 static yyconst short int yy_base[231] =
00363     {   0,
00364         0,    0,   52,   53,  315,  314,   54,   58,   60,   94,
00365       130,    0,  316,  319,  319,  319,  319,  319,  319,  319,
00366       319,   57,   54,   57,  319,  319,  319,  319,  319,  295,
00367         0,  288,  319,  319,  280,  261,  276,  319,  319,  319,
00368       319,  300,  319,  319,  319,  319,  319,  319,  319,    0,
00369       319,  319,  319,  319,  319,  319,   63,   63,  319,  319,
00370       319,  319,  319,  284,    0,  275,  268,  271,  319,  319,
00371       319,  319,   65,  319,    0,  275,  286,  273,  269,  253,
00372       319,    0,  280,  269,  255,  249,   63,  266,   46,  254,
00373       264,  271,  152,  258,  261,  265,  263,  268,  243,  243,
00374 
00375       250,   56,  254,  252,  249,   63,   55,  246,   70,  245,
00376       231,  234,   72,  242,  256,  257,  247,  227,  225,  241,
00377       223,  218,  233,  247,  233,  234,  216,  217,  231,  230,
00378       218,    0,  214,  221,  226,  210,  211,  227,  210,  230,
00379         0,  227,  208,  201,  202,  205,  213,  212,  217,  205,
00380       209,  208,  198,  206,    0,    0,  203,  205,  199,  201,
00381         0,  190,  199,    0,  207,  200,  184,  198,    0,  187,
00382       183,  202,  190,  186,  185,  191,  183,    0,  189,  184,
00383       171,    0,  178,    0,  168,    0,  157,  161,  161,  168,
00384         0,  157,  143,  141,  152,   81,    0,   84,   91,    0,
00385 
00386        84,   73,   83,    0,    0,   78,    0,    0,   76,   63,
00387        68,   75,    0,   62,   49,    0,   65,    0,    0,    0,
00388        49,    0,    0,  319,  201,  204,  207,  210,  212,   81
00389     } ;
00390 
00391 static yyconst short int yy_def[231] =
00392     {   0,
00393       224,    1,  225,  225,  226,  226,  227,  227,  228,  228,
00394       224,   11,  224,  224,  224,  224,  224,  224,  224,  224,
00395       224,  224,  224,  224,  224,  224,  224,  224,  224,  229,
00396       229,  229,  224,  224,  229,  229,  229,  224,  224,  224,
00397       224,  224,  224,  224,  224,  224,  224,  224,  224,  230,
00398       224,  224,  224,  224,  224,  224,  224,  224,  224,  224,
00399       224,  224,  224,  229,  229,  229,  229,  229,  224,  224,
00400       224,  224,  224,  224,  229,  229,  229,  229,  229,  229,
00401       224,  230,  229,  229,  229,  229,  229,  229,  229,  229,
00402       229,  229,  229,  229,  229,  229,  229,  229,  229,  229,
00403 
00404       229,  229,  229,  229,  229,  229,  229,  229,  229,  229,
00405       229,  229,  229,  229,  229,  229,  229,  229,  229,  229,
00406       229,  229,  229,  229,  229,  229,  229,  229,  229,  229,
00407       229,  229,  229,  229,  229,  229,  229,  229,  229,  229,
00408       229,  229,  229,  229,  229,  229,  229,  229,  229,  229,
00409       229,  229,  229,  229,  229,  229,  229,  229,  229,  229,
00410       229,  229,  229,  229,  229,  229,  229,  229,  229,  229,
00411       229,  229,  229,  229,  229,  229,  229,  229,  229,  229,
00412       229,  229,  229,  229,  229,  229,  229,  229,  229,  229,
00413       229,  229,  229,  229,  229,  229,  229,  229,  229,  229,
00414 
00415       229,  229,  229,  229,  229,  229,  229,  229,  229,  229,
00416       229,  229,  229,  229,  229,  229,  229,  229,  229,  229,
00417       229,  229,  229,    0,  224,  224,  224,  224,  224,  224
00418     } ;
00419 
00420 static yyconst short int yy_nxt[374] =
00421     {   0,
00422        14,   15,   16,   17,   18,   19,   14,   20,   21,   22,
00423        23,   24,   25,   26,   27,   28,   29,   30,   31,   31,
00424        31,   31,   32,   31,   31,   31,   31,   33,   34,   14,
00425        35,   31,   36,   31,   31,   31,   31,   31,   31,   31,
00426        31,   31,   31,   31,   31,   31,   37,   31,   31,   31,
00427        31,   31,   38,   39,   41,   41,   46,   47,   42,   42,
00428        46,   47,   49,   71,   73,   73,   72,   73,   73,   71,
00429        50,   50,   72,   73,   73,   73,   73,   50,   50,   50,
00430        96,   99,   82,  223,  100,   97,  121,  129,  122,  123,
00431        50,   50,   50,   50,   50,   50,   49,  127,  137,  222,
00432 
00433       221,  130,  132,   74,   50,   50,  128,  220,  133,  219,
00434       218,   50,   50,   50,  217,  216,  215,  214,  138,  213,
00435       212,  211,  210,  209,   50,   50,   50,   50,   50,   50,
00436        49,   51,   16,   52,   53,   54,   49,   55,   56,   57,
00437        58,   58,   59,   60,   61,   62,   63,   64,   65,   65,
00438        65,   65,   65,   65,   65,   65,   65,   49,   49,   49,
00439        66,   67,   65,   65,   65,   65,   65,   65,   65,   65,
00440        65,   65,   65,   65,   65,   65,   68,   65,   65,   65,
00441        65,   65,   69,   70,  104,  105,  208,  106,  207,  206,
00442       107,  205,  204,  108,  203,  202,  109,  110,  111,  201,
00443 
00444       112,   40,   40,   40,   43,   43,   43,   45,   45,   45,
00445        48,   48,   48,   75,   75,  200,  199,  198,  197,  196,
00446       195,  194,  193,  192,  191,  190,  189,  188,  187,  186,
00447       185,  184,  183,  182,  181,  180,  179,  178,  177,  176,
00448       175,  174,  173,  172,  171,  170,  169,  168,  167,  166,
00449       165,  164,  163,  162,  161,  160,  159,  158,  157,  156,
00450       155,  154,  153,  152,  151,  150,  149,  148,  147,  146,
00451       145,  144,  143,  142,  141,  140,  139,  136,  135,  134,
00452       131,  126,  125,  124,  120,  119,  118,  117,  116,  115,
00453       114,  113,  103,  102,  101,   98,   95,   94,   93,   92,
00454 
00455        91,   90,   89,   88,   87,   86,   85,   84,   83,   81,
00456        80,   79,   78,   77,   76,  224,   44,   44,   13,  224,
00457       224,  224,  224,  224,  224,  224,  224,  224,  224,  224,
00458       224,  224,  224,  224,  224,  224,  224,  224,  224,  224,
00459       224,  224,  224,  224,  224,  224,  224,  224,  224,  224,
00460       224,  224,  224,  224,  224,  224,  224,  224,  224,  224,
00461       224,  224,  224,  224,  224,  224,  224,  224,  224,  224,
00462       224,  224,  224
00463     } ;
00464 
00465 static yyconst short int yy_chk[374] =
00466     {   0,
00467         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00468         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00469         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00470         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00471         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
00472         1,    1,    1,    1,    3,    4,    7,    7,    3,    4,
00473         8,    8,    9,   22,   23,   23,   22,   24,   24,   57,
00474         9,    9,   57,   58,   58,   73,   73,    9,    9,    9,
00475        87,   89,  230,  221,   89,   87,  102,  107,  102,  102,
00476         9,    9,    9,    9,    9,    9,   10,  106,  113,  217,
00477 
00478       215,  107,  109,   23,   10,   10,  106,  214,  109,  212,
00479       211,   10,   10,   10,  210,  209,  206,  203,  113,  202,
00480       201,  199,  198,  196,   10,   10,   10,   10,   10,   10,
00481        11,   11,   11,   11,   11,   11,   11,   11,   11,   11,
00482        11,   11,   11,   11,   11,   11,   11,   11,   11,   11,
00483        11,   11,   11,   11,   11,   11,   11,   11,   11,   11,
00484        11,   11,   11,   11,   11,   11,   11,   11,   11,   11,
00485        11,   11,   11,   11,   11,   11,   11,   11,   11,   11,
00486        11,   11,   11,   11,   93,   93,  195,   93,  194,  193,
00487        93,  192,  190,   93,  189,  188,   93,   93,   93,  187,
00488 
00489        93,  225,  225,  225,  226,  226,  226,  227,  227,  227,
00490       228,  228,  228,  229,  229,  185,  183,  181,  180,  179,
00491       177,  176,  175,  174,  173,  172,  171,  170,  168,  167,
00492       166,  165,  163,  162,  160,  159,  158,  157,  154,  153,
00493       152,  151,  150,  149,  148,  147,  146,  145,  144,  143,
00494       142,  140,  139,  138,  137,  136,  135,  134,  133,  131,
00495       130,  129,  128,  127,  126,  125,  124,  123,  122,  121,
00496       120,  119,  118,  117,  116,  115,  114,  112,  111,  110,
00497       108,  105,  104,  103,  101,  100,   99,   98,   97,   96,
00498        95,   94,   92,   91,   90,   88,   86,   85,   84,   83,
00499 
00500        80,   79,   78,   77,   76,   68,   67,   66,   64,   42,
00501        37,   36,   35,   32,   30,   13,    6,    5,  224,  224,
00502       224,  224,  224,  224,  224,  224,  224,  224,  224,  224,
00503       224,  224,  224,  224,  224,  224,  224,  224,  224,  224,
00504       224,  224,  224,  224,  224,  224,  224,  224,  224,  224,
00505       224,  224,  224,  224,  224,  224,  224,  224,  224,  224,
00506       224,  224,  224,  224,  224,  224,  224,  224,  224,  224,
00507       224,  224,  224
00508     } ;
00509 
00510 static yy_state_type yy_last_accepting_state;
00511 static char *yy_last_accepting_cpos;
00512 
00513 /* The intent behind this definition is that it'll catch
00514  * any uses of REJECT which flex missed.
00515  */
00516 #define REJECT reject_used_but_not_detected
00517 #define yymore() yymore_used_but_not_detected
00518 #define YY_MORE_ADJ 0
00519 #define YY_RESTORE_YY_MORE_OFFSET
00520 char *yytext;
00521 #line 1 "src/acpp/archc.lex"
00522 #define INITIAL 0
00523 /*  ArchC Language Sintax for GNU Flex
00524     Copyright (C) 2002-2004  The ArchC Team
00525 
00526     This program is free software; you can redistribute it and/or modify
00527     it under the terms of the GNU General Public License as published by
00528     the Free Software Foundation; either version 2 of the License, or
00529     (at your option) any later version.
00530 
00531     This program is distributed in the hope that it will be useful,
00532     but WITHOUT ANY WARRANTY; without even the implied warranty of
00533     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00534     GNU General Public License for more details.
00535 */
00536 #line 16 "src/acpp/archc.lex"
00537 #include <stdlib.h>
00538 #include <string.h>
00539 #include "archc.parser.h"
00540 
00541 #define MAX_STR_CONST  256
00542 #define MAX_CODE_CONST  256
00543 #define DEBUG_LEX 0
00544 #define COMMENT 1
00545 
00546 #define COMMENT1 2
00547 
00548 #define STRING 3
00549 
00550 #define HEXA 4
00551 
00552 #define ARCH 5
00553 
00554 #line 555 "src/acpp/lex.yy.c"
00555 
00556 /* Macros after this point can all be overridden by user definitions in
00557  * section 1.
00558  */
00559 
00560 #ifndef YY_SKIP_YYWRAP
00561 #ifdef __cplusplus
00562 extern "C" int yywrap YY_PROTO(( void ));
00563 #else
00564 extern int yywrap YY_PROTO(( void ));
00565 #endif
00566 #endif
00567 
00568 #ifndef YY_NO_UNPUT
00569 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
00570 #endif
00571 
00572 #ifndef yytext_ptr
00573 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
00574 #endif
00575 
00576 #ifdef YY_NEED_STRLEN
00577 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
00578 #endif
00579 
00580 #ifndef YY_NO_INPUT
00581 #ifdef __cplusplus
00582 static int yyinput YY_PROTO(( void ));
00583 #else
00584 static int input YY_PROTO(( void ));
00585 #endif
00586 #endif
00587 
00588 #if YY_STACK_USED
00589 static int yy_start_stack_ptr = 0;
00590 static int yy_start_stack_depth = 0;
00591 static int *yy_start_stack = 0;
00592 #ifndef YY_NO_PUSH_STATE
00593 static void yy_push_state YY_PROTO(( int new_state ));
00594 #endif
00595 #ifndef YY_NO_POP_STATE
00596 static void yy_pop_state YY_PROTO(( void ));
00597 #endif
00598 #ifndef YY_NO_TOP_STATE
00599 static int yy_top_state YY_PROTO(( void ));
00600 #endif
00601 
00602 #else
00603 #define YY_NO_PUSH_STATE 1
00604 #define YY_NO_POP_STATE 1
00605 #define YY_NO_TOP_STATE 1
00606 #endif
00607 
00608 #ifdef YY_MALLOC_DECL
00609 YY_MALLOC_DECL
00610 #else
00611 #if __STDC__
00612 #ifndef __cplusplus
00613 #include <stdlib.h>
00614 #endif
00615 #else
00616 /* Just try to get by without declaring the routines.  This will fail
00617  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
00618  * or sizeof(void*) != sizeof(int).
00619  */
00620 #endif
00621 #endif
00622 
00623 /* Amount of stuff to slurp up with each read. */
00624 #ifndef YY_READ_BUF_SIZE
00625 #define YY_READ_BUF_SIZE 8192
00626 #endif
00627 
00628 /* Copy whatever the last rule matched to the standard output. */
00629 
00630 #ifndef ECHO
00631 /* This used to be an fputs(), but since the string might contain NUL's,
00632  * we now use fwrite().
00633  */
00634 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
00635 #endif
00636 
00637 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
00638  * is returned in "result".
00639  */
00640 #ifndef YY_INPUT
00641 #define YY_INPUT(buf,result,max_size) \
00642         if ( yy_current_buffer->yy_is_interactive ) \
00643                 { \
00644                 int c = '*', n; \
00645                 for ( n = 0; n < max_size && \
00646                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
00647                         buf[n] = (char) c; \
00648                 if ( c == '\n' ) \
00649                         buf[n++] = (char) c; \
00650                 if ( c == EOF && ferror( yyin ) ) \
00651                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
00652                 result = n; \
00653                 } \
00654         else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
00655                   && ferror( yyin ) ) \
00656                 YY_FATAL_ERROR( "input in flex scanner failed" );
00657 #endif
00658 
00659 /* No semi-colon after return; correct usage is to write "yyterminate();" -
00660  * we don't want an extra ';' after the "return" because that will cause
00661  * some compilers to complain about unreachable statements.
00662  */
00663 #ifndef yyterminate
00664 #define yyterminate() return YY_NULL
00665 #endif
00666 
00667 /* Number of entries by which start-condition stack grows. */
00668 #ifndef YY_START_STACK_INCR
00669 #define YY_START_STACK_INCR 25
00670 #endif
00671 
00672 /* Report a fatal error. */
00673 #ifndef YY_FATAL_ERROR
00674 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
00675 #endif
00676 
00677 /* Default declaration of generated scanner - a define so the user can
00678  * easily add parameters.
00679  */
00680 #ifndef YY_DECL
00681 #define YY_DECL int yylex YY_PROTO(( void ))
00682 #endif
00683 
00684 /* Code executed at the beginning of each rule, after yytext and yyleng
00685  * have been set up.
00686  */
00687 #ifndef YY_USER_ACTION
00688 #define YY_USER_ACTION
00689 #endif
00690 
00691 /* Code executed at the end of each rule. */
00692 #ifndef YY_BREAK
00693 #define YY_BREAK break;
00694 #endif
00695 
00696 #define YY_RULE_SETUP \
00697         YY_USER_ACTION
00698 
00699 YY_DECL
00700         {
00701         register yy_state_type yy_current_state;
00702         register char *yy_cp = NULL, *yy_bp = NULL;
00703         register int yy_act;
00704 
00705 #line 37 "src/acpp/archc.lex"
00706 
00707 
00708    char string_buf[MAX_STR_CONST];
00709    char *string_buf_ptr;
00710    int return_state;
00711    extern unsigned line_num;
00712  /***************************************************/
00713  /* Regular expressions for general tokens in ArchC */
00714  /***************************************************/
00715 
00716 #line 717 "src/acpp/lex.yy.c"
00717 
00718         if ( yy_init )
00719                 {
00720                 yy_init = 0;
00721 
00722 #ifdef YY_USER_INIT
00723                 YY_USER_INIT;
00724 #endif
00725 
00726                 if ( ! yy_start )
00727                         yy_start = 1;   /* first start state */
00728 
00729                 if ( ! yyin )
00730                         yyin = stdin;
00731 
00732                 if ( ! yyout )
00733                         yyout = stdout;
00734 
00735                 if ( ! yy_current_buffer )
00736                         yy_current_buffer =
00737                                 yy_create_buffer( yyin, YY_BUF_SIZE );
00738 
00739                 yy_load_buffer_state();
00740                 }
00741 
00742         while ( 1 )             /* loops until end-of-file is reached */
00743                 {
00744                 yy_cp = yy_c_buf_p;
00745 
00746                 /* Support of yytext. */
00747                 *yy_cp = yy_hold_char;
00748 
00749                 /* yy_bp points to the position in yy_ch_buf of the start of
00750                  * the current run.
00751                  */
00752                 yy_bp = yy_cp;
00753 
00754                 yy_current_state = yy_start;
00755 yy_match:
00756                 do
00757                         {
00758                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
00759                         if ( yy_accept[yy_current_state] )
00760                                 {
00761                                 yy_last_accepting_state = yy_current_state;
00762                                 yy_last_accepting_cpos = yy_cp;
00763                                 }
00764                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
00765                                 {
00766                                 yy_current_state = (int) yy_def[yy_current_state];
00767                                 if ( yy_current_state >= 225 )
00768                                         yy_c = yy_meta[(unsigned int) yy_c];
00769                                 }
00770                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
00771                         ++yy_cp;
00772                         }
00773                 while ( yy_base[yy_current_state] != 319 );
00774 
00775 yy_find_action:
00776                 yy_act = yy_accept[yy_current_state];
00777                 if ( yy_act == 0 )
00778                         { /* have to back up */
00779                         yy_cp = yy_last_accepting_cpos;
00780                         yy_current_state = yy_last_accepting_state;
00781                         yy_act = yy_accept[yy_current_state];
00782                         }
00783 
00784                 YY_DO_BEFORE_ACTION;
00785 
00786 
00787 do_action:      /* This label is used only to access EOF actions. */
00788 
00789 
00790                 switch ( yy_act )
00791         { /* beginning of action switch */
00792                         case 0: /* must back up */
00793                         /* undo the effects of YY_DO_BEFORE_ACTION */
00794                         *yy_cp = yy_hold_char;
00795                         yy_cp = yy_last_accepting_cpos;
00796                         yy_current_state = yy_last_accepting_state;
00797                         goto yy_find_action;
00798 
00799 case 1:
00800 YY_RULE_SETUP
00801 #line 47 "src/acpp/archc.lex"
00802 {
00803      #if DEBUG_LEX
00804             printf( "An integer: %s (%d)\n", yytext,
00805                     atoi( yytext ) );
00806      #endif
00807             yylval.value = atoi( yytext );
00808             return INT;
00809    }
00810         YY_BREAK
00811 case 2:
00812 YY_RULE_SETUP
00813 #line 57 "src/acpp/archc.lex"
00814 { 
00815      #if DEBUG_LEX
00816             printf( "COMMA: %s\n", yytext );
00817      #endif
00818             return COMMA; 
00819    }
00820         YY_BREAK
00821 case 3:
00822 YY_RULE_SETUP
00823 #line 64 "src/acpp/archc.lex"
00824 {
00825      #if DEBUG_LEX
00826               printf( "SEMICOLON: %s\n", yytext );
00827      #endif
00828             return SEMICOLON; 
00829 
00830    }
00831         YY_BREAK
00832 case 4:
00833 YY_RULE_SETUP
00834 #line 72 "src/acpp/archc.lex"
00835 {
00836      #if DEBUG_LEX
00837               printf( "COLON: %s\n", yytext );
00838      #endif
00839             return COLON; 
00840 
00841    }
00842         YY_BREAK
00843 case 5:
00844 YY_RULE_SETUP
00845 #line 81 "src/acpp/archc.lex"
00846 { 
00847      #if DEBUG_LEX
00848               printf( "DOT: %s\n", yytext );
00849      #endif
00850               return DOT; 
00851 
00852    }
00853         YY_BREAK
00854 case 6:
00855 YY_RULE_SETUP
00856 #line 89 "src/acpp/archc.lex"
00857 {
00858      #if DEBUG_LEX
00859               printf( "EQUAL: %s\n", yytext );
00860      #endif
00861               return EQ; 
00862 
00863    }
00864         YY_BREAK
00865 case 7:
00866 YY_RULE_SETUP
00867 #line 97 "src/acpp/archc.lex"
00868 {
00869      #if DEBUG_LEX
00870               printf( "LT: %s\n", yytext );
00871      #endif
00872               return LT; 
00873 
00874    }
00875         YY_BREAK
00876 case 8:
00877 YY_RULE_SETUP
00878 #line 105 "src/acpp/archc.lex"
00879 {
00880      #if DEBUG_LEX
00881               printf( "GT: %s\n", yytext );
00882      #endif
00883               return GT; 
00884 
00885    }
00886         YY_BREAK
00887 case 9:
00888 YY_RULE_SETUP
00889 #line 113 "src/acpp/archc.lex"
00890 {
00891      #if DEBUG_LEX
00892               printf( "LPAREN: %s\n", yytext );
00893      #endif
00894               return LPAREN; 
00895    }
00896         YY_BREAK
00897 case 10:
00898 YY_RULE_SETUP
00899 #line 120 "src/acpp/archc.lex"
00900 {
00901      #if DEBUG_LEX
00902               printf( "RPAREN: %s\n", yytext );
00903      #endif
00904               return RPAREN; 
00905 
00906    }
00907         YY_BREAK
00908 case 11:
00909 YY_RULE_SETUP
00910 #line 128 "src/acpp/archc.lex"
00911 {
00912      #if DEBUG_LEX
00913               printf( "LBRACK: %s\n", yytext );
00914      #endif
00915               return LBRACK; 
00916 
00917    }
00918         YY_BREAK
00919 case 12:
00920 YY_RULE_SETUP
00921 #line 136 "src/acpp/archc.lex"
00922 {
00923      #if DEBUG_LEX
00924               printf( "RBRACK: %s\n", yytext );
00925      #endif
00926               return RBRACK; 
00927 
00928    }
00929         YY_BREAK
00930 case 13:
00931 YY_RULE_SETUP
00932 #line 144 "src/acpp/archc.lex"
00933 {
00934      #if DEBUG_LEX
00935               printf( "LBRACE: %s\n", yytext );
00936      #endif
00937               return LBRACE; 
00938 
00939    }
00940         YY_BREAK
00941 case 14:
00942 YY_RULE_SETUP
00943 #line 152 "src/acpp/archc.lex"
00944 {
00945      #if DEBUG_LEX
00946               printf( "RBRACE: %s\n", yytext );
00947      #endif
00948               return RBRACE; 
00949 
00950    }
00951         YY_BREAK
00952 case 15:
00953 YY_RULE_SETUP
00954 #line 162 "src/acpp/archc.lex"
00955 BEGIN(HEXA);
00956         YY_BREAK
00957 case 16:
00958 YY_RULE_SETUP
00959 #line 164 "src/acpp/archc.lex"
00960 {
00961              string_buf_ptr = string_buf; 
00962              return_state = YY_START;
00963              BEGIN(STRING);
00964    }
00965         YY_BREAK
00966 case 17:
00967 YY_RULE_SETUP
00968 #line 170 "src/acpp/archc.lex"
00969 {
00970      #if DEBUG_LEX
00971               printf( "Entering comment: \n" );
00972      #endif
00973              return_state = YY_START;
00974                          BEGIN(COMMENT);
00975    }
00976         YY_BREAK
00977 case 18:
00978 YY_RULE_SETUP
00979 #line 178 "src/acpp/archc.lex"
00980 {
00981      #if DEBUG_LEX
00982               printf( "Entering comment1: \n" );
00983      #endif
00984              return_state = YY_START;
00985                          BEGIN(COMMENT1);
00986    }
00987         YY_BREAK
00988 case 19:
00989 YY_RULE_SETUP
00990 #line 187 "src/acpp/archc.lex"
00991 { 
00992      line_num++;
00993      #if DEBUG_LEX
00994              printf( "New line: %d\n",line_num);
00995      #endif
00996    }
00997         YY_BREAK
00998 case 20:
00999 YY_RULE_SETUP
01000 #line 194 "src/acpp/archc.lex"
01001 /* eat up spaces */   { 
01002      #if DEBUG_LEX
01003              printf( "Eating space: <%s>\n",yytext);
01004      #endif
01005    }
01006         YY_BREAK
01007 /***************************************************/
01008 /* Regular expressions for ArchC ISA reserved words*/
01009 /***************************************************/
01010 case 21:
01011 YY_RULE_SETUP
01012 #line 204 "src/acpp/archc.lex"
01013 { 
01014      #if DEBUG_LEX
01015               printf( "AC_ISA: %s\n", yytext );
01016      #endif
01017 
01018                                 return AC_ISA_UPPER; 
01019 
01020    }
01021         YY_BREAK
01022 case 22:
01023 YY_RULE_SETUP
01024 #line 213 "src/acpp/archc.lex"
01025 {
01026      #if DEBUG_LEX
01027               printf( "ISA_CTOR: %s\n", yytext );
01028      #endif
01029               return ISA_CTOR; 
01030 
01031    }
01032         YY_BREAK
01033 case 23:
01034 YY_RULE_SETUP
01035 #line 221 "src/acpp/archc.lex"
01036 {
01037      #if DEBUG_LEX
01038               printf( "SET_DECODER: %s\n", yytext );
01039      #endif
01040               return SET_DECODER; 
01041 
01042    }
01043         YY_BREAK
01044 case 24:
01045 YY_RULE_SETUP
01046 #line 229 "src/acpp/archc.lex"
01047 {
01048      #if DEBUG_LEX
01049               printf( "SET_ASM: %s\n", yytext );
01050       #endif
01051              return SET_ASM; 
01052 
01053    }
01054         YY_BREAK
01055 case 25:
01056 YY_RULE_SETUP
01057 #line 237 "src/acpp/archc.lex"
01058 {
01059      #if DEBUG_LEX
01060               printf( "SET_CYCLES: %s\n", yytext );
01061       #endif
01062              return SET_CYCLES; 
01063 
01064    }
01065         YY_BREAK
01066 case 26:
01067 YY_RULE_SETUP
01068 #line 245 "src/acpp/archc.lex"
01069 {
01070      #if DEBUG_LEX
01071               printf( "CYCLE_RANGE: %s\n", yytext );
01072       #endif
01073              return CYCLE_RANGE; 
01074 
01075    }
01076         YY_BREAK
01077 case 27:
01078 YY_RULE_SETUP
01079 #line 253 "src/acpp/archc.lex"
01080 {
01081      #if DEBUG_LEX
01082               printf( "AC_FORMAT: %s\n", yytext );
01083       #endif
01084              return AC_FORMAT; 
01085 
01086    }
01087         YY_BREAK
01088 case 28:
01089 YY_RULE_SETUP
01090 #line 261 "src/acpp/archc.lex"
01091 { 
01092      #if DEBUG_LEX
01093               printf( "AC_INSTR: %s\n", yytext );
01094      #endif
01095              return AC_INSTR; 
01096  
01097    }
01098         YY_BREAK
01099 case 29:
01100 YY_RULE_SETUP
01101 #line 270 "src/acpp/archc.lex"
01102 { 
01103      /* Changing to ARCH state */
01104      #if DEBUG_LEX
01105               printf( "AC_ARCH: %s\n", yytext );
01106      #endif
01107               line_num = 1;
01108               BEGIN(ARCH);
01109               return AC_ARCH; 
01110 
01111    }
01112         YY_BREAK
01113 /******************************************************/
01114 /* Regular expressions for ARchC ARCH reserved words */
01115 /******************************************************/
01116 case 30:
01117 YY_RULE_SETUP
01118 #line 286 "src/acpp/archc.lex"
01119 {
01120      #if DEBUG_LEX
01121               printf( "ARCH_CTOR: %s\n", yytext );
01122      #endif
01123               return ARCH_CTOR; 
01124 
01125    }
01126         YY_BREAK
01127 case 31:
01128 YY_RULE_SETUP
01129 #line 295 "src/acpp/archc.lex"
01130 {
01131      #if DEBUG_LEX
01132               printf( "AC_CACHE: %s\n", yytext );
01133       #endif
01134              return AC_CACHE; 
01135 
01136    }
01137         YY_BREAK
01138 case 32:
01139 YY_RULE_SETUP
01140 #line 303 "src/acpp/archc.lex"
01141 {
01142      #if DEBUG_LEX
01143               printf( "AC_ICACHE: %s\n", yytext );
01144       #endif
01145              return AC_ICACHE; 
01146 
01147    }
01148         YY_BREAK
01149 case 33:
01150 YY_RULE_SETUP
01151 #line 310 "src/acpp/archc.lex"
01152 {
01153      #if DEBUG_LEX
01154               printf( "AC_DCACHE: %s\n", yytext );
01155       #endif
01156              return AC_DCACHE; 
01157 
01158    }
01159         YY_BREAK
01160 case 34:
01161 YY_RULE_SETUP
01162 #line 319 "src/acpp/archc.lex"
01163 {
01164      #if DEBUG_LEX
01165               printf( "AC_MEM: %s\n", yytext );
01166       #endif
01167              return AC_MEM; 
01168 
01169    }
01170         YY_BREAK
01171 case 35:
01172 YY_RULE_SETUP
01173 #line 327 "src/acpp/archc.lex"
01174 {
01175      #if DEBUG_LEX
01176               printf( "AC_PC: %s\n", yytext );
01177       #endif
01178              return AC_PC; 
01179 
01180    }
01181         YY_BREAK
01182 case 36:
01183 YY_RULE_SETUP
01184 #line 335 "src/acpp/archc.lex"
01185 {
01186      #if DEBUG_LEX
01187               printf( "ac_isa: %s\n", yytext );
01188       #endif
01189              return AC_ISA; 
01190 
01191    }
01192         YY_BREAK
01193 case 37:
01194 YY_RULE_SETUP
01195 #line 343 "src/acpp/archc.lex"
01196 { 
01197      #if DEBUG_LEX
01198               printf( "AC_REG: %s\n", yytext );
01199      #endif
01200              return AC_REG; 
01201  
01202    }
01203         YY_BREAK
01204 case 38:
01205 YY_RULE_SETUP
01206 #line 351 "src/acpp/archc.lex"
01207 { 
01208      #if DEBUG_LEX
01209               printf( "AC_REGBANK: %s\n", yytext );
01210      #endif
01211              return AC_REGBANK; 
01212  
01213    }
01214         YY_BREAK
01215 case 39:
01216 YY_RULE_SETUP
01217 #line 359 "src/acpp/archc.lex"
01218 {
01219      #if DEBUG_LEX
01220               printf( "AC_FORMAT FOR ARCH: %s\n", yytext );
01221       #endif
01222              return AC_FORMAT; 
01223 
01224    }
01225         YY_BREAK
01226 case 40:
01227 YY_RULE_SETUP
01228 #line 367 "src/acpp/archc.lex"
01229 { 
01230      #if DEBUG_LEX
01231               printf( "AC_WORDSIZE: %s\n", yytext );
01232      #endif
01233              return AC_WORDSIZE; 
01234  
01235    }
01236         YY_BREAK
01237 case 41:
01238 YY_RULE_SETUP
01239 #line 375 "src/acpp/archc.lex"
01240 { 
01241      #if DEBUG_LEX
01242               printf( "AC_FETCHSIZE: %s\n", yytext );
01243      #endif
01244              return AC_FETCHSIZE; 
01245  
01246    }
01247         YY_BREAK
01248 case 42:
01249 YY_RULE_SETUP
01250 #line 383 "src/acpp/archc.lex"
01251 { 
01252      #if DEBUG_LEX
01253               printf( "AC_STAGE: %s\n", yytext );
01254      #endif
01255              return AC_STAGE; 
01256  
01257    }
01258         YY_BREAK
01259 case 43:
01260 YY_RULE_SETUP
01261 #line 391 "src/acpp/archc.lex"
01262 { 
01263      #if DEBUG_LEX
01264               printf( "AC_PIPE: %s\n", yytext );
01265      #endif
01266              return AC_PIPE; 
01267  
01268    }
01269         YY_BREAK
01270 case 44:
01271 YY_RULE_SETUP
01272 #line 399 "src/acpp/archc.lex"
01273 { 
01274      #if DEBUG_LEX
01275               printf( "SET_ENDIAN: %s\n", yytext );
01276      #endif
01277              return SET_ENDIAN; 
01278  
01279    }
01280         YY_BREAK
01281 case 45:
01282 YY_RULE_SETUP
01283 #line 407 "src/acpp/archc.lex"
01284 { 
01285      #if DEBUG_LEX
01286               printf( "BIND_TO: %s\n", yytext );
01287      #endif
01288              return BIND_TO; 
01289  
01290    }
01291         YY_BREAK
01292 case 46:
01293 YY_RULE_SETUP
01294 #line 415 "src/acpp/archc.lex"
01295 { 
01296      #if DEBUG_LEX
01297               printf( "BIND_TO: %s\n", yytext );
01298      #endif
01299              return BIND_TO; 
01300  
01301    }
01302         YY_BREAK
01303 case 47:
01304 YY_RULE_SETUP
01305 #line 423 "src/acpp/archc.lex"
01306 { 
01307      #if DEBUG_LEX
01308               printf( "An identifier: %s\n", yytext );
01309      #endif
01310               yylval.text = (char*)malloc(strlen(yytext)+1);
01311               strcpy(yylval.text,yytext);
01312               return ID; 
01313 
01314    }
01315         YY_BREAK
01316 case YY_STATE_EOF(INITIAL):
01317 case YY_STATE_EOF(ARCH):
01318 #line 433 "src/acpp/archc.lex"
01319 { 
01320              BEGIN(INITIAL);
01321              yyterminate();
01322    } 
01323         YY_BREAK
01324 case 48:
01325 YY_RULE_SETUP
01326 #line 438 "src/acpp/archc.lex"
01327 { 
01328              printf( "ArchC Unmatched input at line %d: <%s>\n", line_num, yytext);
01329    }
01330         YY_BREAK
01331 /********************************************************/
01332 /* Regular expressions for hexadecimal numbers in ArchC */
01333 /********************************************************/
01334 case 49:
01335 YY_RULE_SETUP
01336 #line 446 "src/acpp/archc.lex"
01337 {  /* Handling Hexadecimal numbers */
01338      #if DEBUG_LEX
01339                     printf( "An hexa integer: 0x%s (%d)\n", yytext,(int)strtol( yytext, NULL, 16 ));
01340      #endif
01341                     yylval.value = (int)strtol( yytext, NULL, 16 );
01342                     BEGIN(INITIAL);
01343                     return INT; 
01344    } 
01345         YY_BREAK
01346 case YY_STATE_EOF(HEXA):
01347 #line 455 "src/acpp/archc.lex"
01348 {
01349          printf( "ArchC Lexical ERROR: Unexpected end of file" );
01350          yyterminate();
01351    }
01352         YY_BREAK
01353 case 50:
01354 YY_RULE_SETUP
01355 #line 460 "src/acpp/archc.lex"
01356 { 
01357                 printf( "ArchC Lexical ERROR: Unrecognized character in hexa state: %s\n", yytext );
01358                 BEGIN(INITIAL);
01359                 yyterminate();
01360    } 
01361         YY_BREAK
01362 /*****************************************************/
01363 /* Regular expressions for handling Strings in ArchC */
01364 /*****************************************************/
01365 case 51:
01366 YY_RULE_SETUP
01367 #line 470 "src/acpp/archc.lex"
01368 { /* Handling Strings*/
01369                 /* saw closing quote - all done */
01370                 *string_buf_ptr = '\0';
01371                 /* return string constant token type and
01372                  * value to parser
01373                  */
01374      #if DEBUG_LEX
01375                  printf( "A string: %s\n",string_buf);  
01376                  printf( "Returning token: %d\n",STR);  
01377      #endif
01378                  yylval.text = (char*)malloc(strlen(string_buf)+1);
01379                  strcpy(yylval.text,string_buf);
01380                  BEGIN(return_state);
01381                  return STR;
01382    }
01383         YY_BREAK
01384 case 52:
01385 YY_RULE_SETUP
01386 #line 486 "src/acpp/archc.lex"
01387 {
01388                /* error - unterminated string constant */
01389                /* generate error message */
01390                *string_buf_ptr = '\0';
01391                printf( "AC_ERROR: Line %d: Unterminated string constant: %s\n", line_num,string_buf  );
01392                 yyterminate();
01393    }
01394         YY_BREAK
01395 case 53:
01396 YY_RULE_SETUP
01397 #line 494 "src/acpp/archc.lex"
01398 {
01399                *string_buf_ptr++ = *yytext;
01400    }
01401         YY_BREAK
01402 case YY_STATE_EOF(STRING):
01403 #line 498 "src/acpp/archc.lex"
01404 {
01405          printf( "ArchC Lexical ERROR: Unexpected end of file" );
01406          yyterminate();
01407    }
01408         YY_BREAK
01409 /*****************************************************/
01410 /* Regular expressions for comments in ArchC */
01411 /*****************************************************/
01412 case 54:
01413 YY_RULE_SETUP
01414 #line 506 "src/acpp/archc.lex"
01415 {
01416  
01417 #if DEBUG_LEX
01418           printf( "End of comment in line: %d\n",line_num);
01419 #endif
01420                  BEGIN(return_state);
01421    }
01422         YY_BREAK
01423 case 55:
01424 YY_RULE_SETUP
01425 #line 514 "src/acpp/archc.lex"
01426 { 
01427 
01428      line_num++;
01429      #if DEBUG_LEX
01430              printf( "Comment. New line: %d\n",line_num);
01431      #endif
01432    }
01433         YY_BREAK
01434 case 56:
01435 YY_RULE_SETUP
01436 #line 522 "src/acpp/archc.lex"
01437 {
01438    }
01439         YY_BREAK
01440 case YY_STATE_EOF(COMMENT):
01441 #line 525 "src/acpp/archc.lex"
01442 {
01443            BEGIN(INITIAL);
01444            printf( "ArchC Lexical ERROR: Unexpected end of file" );
01445            yyterminate();
01446    }
01447         YY_BREAK
01448 /* Comment style regular expressions*/
01449 case 57:
01450 YY_RULE_SETUP
01451 #line 533 "src/acpp/archc.lex"
01452 { 
01453 
01454      line_num++;
01455      #if DEBUG_LEX
01456              printf( "Leaving comment1. New line: %d\n",line_num);
01457      #endif
01458                  BEGIN(return_state);
01459    }
01460         YY_BREAK
01461 case 58:
01462 YY_RULE_SETUP
01463 #line 542 "src/acpp/archc.lex"
01464 {
01465           
01466    }
01467         YY_BREAK
01468 case YY_STATE_EOF(COMMENT1):
01469 #line 546 "src/acpp/archc.lex"
01470 {
01471            BEGIN(INITIAL);
01472            printf( "ArchC Lexical ERROR: Unexpected end of file" );
01473            yyterminate();
01474    }
01475         YY_BREAK
01476 case 59:
01477 YY_RULE_SETUP
01478 #line 552 "src/acpp/archc.lex"
01479 ECHO;
01480         YY_BREAK
01481 #line 1482 "src/acpp/lex.yy.c"
01482 
01483         case YY_END_OF_BUFFER:
01484                 {
01485                 /* Amount of text matched not including the EOB char. */
01486                 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
01487 
01488                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
01489                 *yy_cp = yy_hold_char;
01490                 YY_RESTORE_YY_MORE_OFFSET
01491 
01492                 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
01493                         {
01494                         /* We're scanning a new file or input source.  It's
01495                          * possible that this happened because the user
01496                          * just pointed yyin at a new source and called
01497                          * yylex().  If so, then we have to assure
01498                          * consistency between yy_current_buffer and our
01499                          * globals.  Here is the right place to do so, because
01500                          * this is the first action (other than possibly a
01501                          * back-up) that will match for the new input source.
01502                          */
01503                         yy_n_chars = yy_current_buffer->yy_n_chars;
01504                         yy_current_buffer->yy_input_file = yyin;
01505                         yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
01506                         }
01507 
01508                 /* Note that here we test for yy_c_buf_p "<=" to the position
01509                  * of the first EOB in the buffer, since yy_c_buf_p will
01510                  * already have been incremented past the NUL character
01511                  * (since all states make transitions on EOB to the
01512                  * end-of-buffer state).  Contrast this with the test
01513                  * in input().
01514                  */
01515                 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
01516                         { /* This was really a NUL. */
01517                         yy_state_type yy_next_state;
01518 
01519                         yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
01520 
01521                         yy_current_state = yy_get_previous_state();
01522 
01523                         /* Okay, we're now positioned to make the NUL
01524                          * transition.  We couldn't have
01525                          * yy_get_previous_state() go ahead and do it
01526                          * for us because it doesn't know how to deal
01527                          * with the possibility of jamming (and we don't
01528                          * want to build jamming into it because then it
01529                          * will run more slowly).
01530                          */
01531 
01532                         yy_next_state = yy_try_NUL_trans( yy_current_state );
01533 
01534                         yy_bp = yytext_ptr + YY_MORE_ADJ;
01535 
01536                         if ( yy_next_state )
01537                                 {
01538                                 /* Consume the NUL. */
01539                                 yy_cp = ++yy_c_buf_p;
01540                                 yy_current_state = yy_next_state;
01541                                 goto yy_match;
01542                                 }
01543 
01544                         else
01545                                 {
01546                                 yy_cp = yy_c_buf_p;
01547                                 goto yy_find_action;
01548                                 }
01549                         }
01550 
01551                 else switch ( yy_get_next_buffer() )
01552                         {
01553                         case EOB_ACT_END_OF_FILE:
01554                                 {
01555                                 yy_did_buffer_switch_on_eof = 0;
01556 
01557                                 if ( yywrap() )
01558                                         {
01559                                         /* Note: because we've taken care in
01560                                          * yy_get_next_buffer() to have set up
01561                                          * yytext, we can now set up
01562                                          * yy_c_buf_p so that if some total
01563                                          * hoser (like flex itself) wants to
01564                                          * call the scanner after we return the
01565                                          * YY_NULL, it'll still work - another
01566                                          * YY_NULL will get returned.
01567                                          */
01568                                         yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
01569 
01570                                         yy_act = YY_STATE_EOF(YY_START);
01571                                         goto do_action;
01572                                         }
01573 
01574                                 else
01575                                         {
01576                                         if ( ! yy_did_buffer_switch_on_eof )
01577                                                 YY_NEW_FILE;
01578                                         }
01579                                 break;
01580                                 }
01581 
01582                         case EOB_ACT_CONTINUE_SCAN:
01583                                 yy_c_buf_p =
01584                                         yytext_ptr + yy_amount_of_matched_text;
01585 
01586                                 yy_current_state = yy_get_previous_state();
01587 
01588                                 yy_cp = yy_c_buf_p;
01589                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
01590                                 goto yy_match;
01591 
01592                         case EOB_ACT_LAST_MATCH:
01593                                 yy_c_buf_p =
01594                                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
01595 
01596                                 yy_current_state = yy_get_previous_state();
01597 
01598                                 yy_cp = yy_c_buf_p;
01599                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
01600                                 goto yy_find_action;
01601                         }
01602                 break;
01603                 }
01604 
01605         default:
01606                 YY_FATAL_ERROR(
01607                         "fatal flex scanner internal error--no action found" );
01608         } /* end of action switch */
01609                 } /* end of scanning one token */
01610         } /* end of yylex */
01611 
01612 
01613 /* yy_get_next_buffer - try to read in a new buffer
01614  *
01615  * Returns a code representing an action:
01616  *      EOB_ACT_LAST_MATCH -
01617  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
01618  *      EOB_ACT_END_OF_FILE - end of file
01619  */
01620 
01621 static int yy_get_next_buffer()
01622         {
01623         register char *dest = yy_current_buffer->yy_ch_buf;
01624         register char *source = yytext_ptr;
01625         register int number_to_move, i;
01626         int ret_val;
01627 
01628         if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
01629                 YY_FATAL_ERROR(
01630                 "fatal flex scanner internal error--end of buffer missed" );
01631 
01632         if ( yy_current_buffer->yy_fill_buffer == 0 )
01633                 { /* Don't try to fill the buffer, so this is an EOF. */
01634                 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
01635                         {
01636                         /* We matched a single character, the EOB, so
01637                          * treat this as a final EOF.
01638                          */
01639                         return EOB_ACT_END_OF_FILE;
01640                         }
01641 
01642                 else
01643                         {
01644                         /* We matched some text prior to the EOB, first
01645                          * process it.
01646                          */
01647                         return EOB_ACT_LAST_MATCH;
01648                         }
01649                 }
01650 
01651         /* Try to read more data. */
01652 
01653         /* First move last chars to start of buffer. */
01654         number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
01655 
01656         for ( i = 0; i < number_to_move; ++i )
01657                 *(dest++) = *(source++);
01658 
01659         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
01660                 /* don't do the read, it's not guaranteed to return an EOF,
01661                  * just force an EOF
01662                  */
01663                 yy_current_buffer->yy_n_chars = yy_n_chars = 0;
01664 
01665         else
01666                 {
01667                 int num_to_read =
01668                         yy_current_buffer->yy_buf_size - number_to_move - 1;
01669 
01670                 while ( num_to_read <= 0 )
01671                         { /* Not enough room in the buffer - grow it. */
01672 #ifdef YY_USES_REJECT
01673                         YY_FATAL_ERROR(
01674 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
01675 #else
01676 
01677                         /* just a shorter name for the current buffer */
01678                         YY_BUFFER_STATE b = yy_current_buffer;
01679 
01680                         int yy_c_buf_p_offset =
01681                                 (int) (yy_c_buf_p - b->yy_ch_buf);
01682 
01683                         if ( b->yy_is_our_buffer )
01684                                 {
01685                                 int new_size = b->yy_buf_size * 2;
01686 
01687                                 if ( new_size <= 0 )
01688                                         b->yy_buf_size += b->yy_buf_size / 8;
01689                                 else
01690                                         b->yy_buf_size *= 2;
01691 
01692                                 b->yy_ch_buf = (char *)
01693                                         /* Include room in for 2 EOB chars. */
01694                                         yy_flex_realloc( (void *) b->yy_ch_buf,
01695                                                          b->yy_buf_size + 2 );
01696                                 }
01697                         else
01698                                 /* Can't grow it, we don't own it. */
01699                                 b->yy_ch_buf = 0;
01700 
01701                         if ( ! b->yy_ch_buf )
01702                                 YY_FATAL_ERROR(
01703                                 "fatal error - scanner input buffer overflow" );
01704 
01705                         yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
01706 
01707                         num_to_read = yy_current_buffer->yy_buf_size -
01708                                                 number_to_move - 1;
01709 #endif
01710                         }
01711 
01712                 if ( num_to_read > YY_READ_BUF_SIZE )
01713                         num_to_read = YY_READ_BUF_SIZE;
01714 
01715                 /* Read in more data. */
01716                 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
01717                         yy_n_chars, num_to_read );
01718 
01719                 yy_current_buffer->yy_n_chars = yy_n_chars;
01720                 }
01721 
01722         if ( yy_n_chars == 0 )
01723                 {
01724                 if ( number_to_move == YY_MORE_ADJ )
01725                         {
01726                         ret_val = EOB_ACT_END_OF_FILE;
01727                         yyrestart( yyin );
01728                         }
01729 
01730                 else
01731                         {
01732                         ret_val = EOB_ACT_LAST_MATCH;
01733                         yy_current_buffer->yy_buffer_status =
01734                                 YY_BUFFER_EOF_PENDING;
01735                         }
01736                 }
01737 
01738         else
01739                 ret_val = EOB_ACT_CONTINUE_SCAN;
01740 
01741         yy_n_chars += number_to_move;
01742         yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
01743         yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
01744 
01745         yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
01746 
01747         return ret_val;
01748         }
01749 
01750 
01751 /* yy_get_previous_state - get the state just before the EOB char was reached */
01752 
01753 static yy_state_type yy_get_previous_state()
01754         {
01755         register yy_state_type yy_current_state;
01756         register char *yy_cp;
01757 
01758         yy_current_state = yy_start;
01759 
01760         for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
01761                 {
01762                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
01763                 if ( yy_accept[yy_current_state] )
01764                         {
01765                         yy_last_accepting_state = yy_current_state;
01766                         yy_last_accepting_cpos = yy_cp;
01767                         }
01768                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
01769                         {
01770                         yy_current_state = (int) yy_def[yy_current_state];
01771                         if ( yy_current_state >= 225 )
01772                                 yy_c = yy_meta[(unsigned int) yy_c];
01773                         }
01774                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
01775                 }
01776 
01777         return yy_current_state;
01778         }
01779 
01780 
01781 /* yy_try_NUL_trans - try to make a transition on the NUL character
01782  *
01783  * synopsis
01784  *      next_state = yy_try_NUL_trans( current_state );
01785  */
01786 
01787 #ifdef YY_USE_PROTOS
01788 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
01789 #else
01790 static yy_state_type yy_try_NUL_trans( yy_current_state )
01791 yy_state_type yy_current_state;
01792 #endif
01793         {
01794         register int yy_is_jam;
01795         register char *yy_cp = yy_c_buf_p;
01796 
01797         register YY_CHAR yy_c = 1;
01798         if ( yy_accept[yy_current_state] )
01799                 {
01800                 yy_last_accepting_state = yy_current_state;
01801                 yy_last_accepting_cpos = yy_cp;
01802                 }
01803         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
01804                 {
01805                 yy_current_state = (int) yy_def[yy_current_state];
01806                 if ( yy_current_state >= 225 )
01807                         yy_c = yy_meta[(unsigned int) yy_c];
01808                 }
01809         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
01810         yy_is_jam = (yy_current_state == 224);
01811 
01812         return yy_is_jam ? 0 : yy_current_state;
01813         }
01814 
01815 
01816 #ifndef YY_NO_UNPUT
01817 #ifdef YY_USE_PROTOS
01818 static void yyunput( int c, register char *yy_bp )
01819 #else
01820 static void yyunput( c, yy_bp )
01821 int c;
01822 register char *yy_bp;
01823 #endif
01824         {
01825         register char *yy_cp = yy_c_buf_p;
01826 
01827         /* undo effects of setting up yytext */
01828         *yy_cp = yy_hold_char;
01829 
01830         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
01831                 { /* need to shift things up to make room */
01832                 /* +2 for EOB chars. */
01833                 register int number_to_move = yy_n_chars + 2;
01834                 register char *dest = &yy_current_buffer->yy_ch_buf[
01835                                         yy_current_buffer->yy_buf_size + 2];
01836                 register char *source =
01837                                 &yy_current_buffer->yy_ch_buf[number_to_move];
01838 
01839                 while ( source > yy_current_buffer->yy_ch_buf )
01840                         *--dest = *--source;
01841 
01842                 yy_cp += (int) (dest - source);
01843                 yy_bp += (int) (dest - source);
01844                 yy_current_buffer->yy_n_chars =
01845                         yy_n_chars = yy_current_buffer->yy_buf_size;
01846 
01847                 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
01848                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
01849                 }
01850 
01851         *--yy_cp = (char) c;
01852 
01853 
01854         yytext_ptr = yy_bp;
01855         yy_hold_char = *yy_cp;
01856         yy_c_buf_p = yy_cp;
01857         }
01858 #endif  /* ifndef YY_NO_UNPUT */
01859 
01860 
01861 #ifndef YY_NO_INPUT
01862 #ifdef __cplusplus
01863 static int yyinput()
01864 #else
01865 static int input()
01866 #endif
01867         {
01868         int c;
01869 
01870         *yy_c_buf_p = yy_hold_char;
01871 
01872         if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
01873                 {
01874                 /* yy_c_buf_p now points to the character we want to return.
01875                  * If this occurs *before* the EOB characters, then it's a
01876                  * valid NUL; if not, then we've hit the end of the buffer.
01877                  */
01878                 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
01879                         /* This was really a NUL. */
01880                         *yy_c_buf_p = '\0';
01881 
01882                 else
01883                         { /* need more input */
01884                         int offset = yy_c_buf_p - yytext_ptr;
01885                         ++yy_c_buf_p;
01886 
01887                         switch ( yy_get_next_buffer() )
01888                                 {
01889                                 case EOB_ACT_LAST_MATCH:
01890                                         /* This happens because yy_g_n_b()
01891                                          * sees that we've accumulated a
01892                                          * token and flags that we need to
01893                                          * try matching the token before
01894                                          * proceeding.  But for input(),
01895                                          * there's no matching to consider.
01896                                          * So convert the EOB_ACT_LAST_MATCH
01897                                          * to EOB_ACT_END_OF_FILE.
01898                                          */
01899 
01900                                         /* Reset buffer status. */
01901                                         yyrestart( yyin );
01902 
01903                                         /* fall through */
01904 
01905                                 case EOB_ACT_END_OF_FILE:
01906                                         {
01907                                         if ( yywrap() )
01908                                                 return EOF;
01909 
01910                                         if ( ! yy_did_buffer_switch_on_eof )
01911                                                 YY_NEW_FILE;
01912 #ifdef __cplusplus
01913                                         return yyinput();
01914 #else
01915                                         return input();
01916 #endif
01917                                         }
01918 
01919                                 case EOB_ACT_CONTINUE_SCAN:
01920                                         yy_c_buf_p = yytext_ptr + offset;
01921                                         break;
01922                                 }
01923                         }
01924                 }
01925 
01926         c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */
01927         *yy_c_buf_p = '\0';     /* preserve yytext */
01928         yy_hold_char = *++yy_c_buf_p;
01929 
01930 
01931         return c;
01932         }
01933 #endif /* YY_NO_INPUT */
01934 
01935 #ifdef YY_USE_PROTOS
01936 void yyrestart( FILE *input_file )
01937 #else
01938 void yyrestart( input_file )
01939 FILE *input_file;
01940 #endif
01941         {
01942         if ( ! yy_current_buffer )
01943                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
01944 
01945         yy_init_buffer( yy_current_buffer, input_file );
01946         yy_load_buffer_state();
01947         }
01948 
01949 
01950 #ifdef YY_USE_PROTOS
01951 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
01952 #else
01953 void yy_switch_to_buffer( new_buffer )
01954 YY_BUFFER_STATE new_buffer;
01955 #endif
01956         {
01957         if ( yy_current_buffer == new_buffer )
01958                 return;
01959 
01960         if ( yy_current_buffer )
01961                 {
01962                 /* Flush out information for old buffer. */
01963                 *yy_c_buf_p = yy_hold_char;
01964                 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
01965                 yy_current_buffer->yy_n_chars = yy_n_chars;
01966                 }
01967 
01968         yy_current_buffer = new_buffer;
01969         yy_load_buffer_state();
01970 
01971         /* We don't actually know whether we did this switch during
01972          * EOF (yywrap()) processing, but the only time this flag
01973          * is looked at is after yywrap() is called, so it's safe
01974          * to go ahead and always set it.
01975          */
01976         yy_did_buffer_switch_on_eof = 1;
01977         }
01978 
01979 
01980 #ifdef YY_USE_PROTOS
01981 void yy_load_buffer_state( void )
01982 #else
01983 void yy_load_buffer_state()
01984 #endif
01985         {
01986         yy_n_chars = yy_current_buffer->yy_n_chars;
01987         yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
01988         yyin = yy_current_buffer->yy_input_file;
01989         yy_hold_char = *yy_c_buf_p;
01990         }
01991 
01992 
01993 #ifdef YY_USE_PROTOS
01994 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
01995 #else
01996 YY_BUFFER_STATE yy_create_buffer( file, size )
01997 FILE *file;
01998 int size;
01999 #endif
02000         {
02001         YY_BUFFER_STATE b;
02002 
02003         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
02004         if ( ! b )
02005                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
02006 
02007         b->yy_buf_size = size;
02008 
02009         /* yy_ch_buf has to be 2 characters longer than the size given because
02010          * we need to put in 2 end-of-buffer characters.
02011          */
02012         b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
02013         if ( ! b->yy_ch_buf )
02014                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
02015 
02016         b->yy_is_our_buffer = 1;
02017 
02018         yy_init_buffer( b, file );
02019 
02020         return b;
02021         }
02022 
02023 
02024 #ifdef YY_USE_PROTOS
02025 void yy_delete_buffer( YY_BUFFER_STATE b )
02026 #else
02027 void yy_delete_buffer( b )
02028 YY_BUFFER_STATE b;
02029 #endif
02030         {
02031         if ( ! b )
02032                 return;
02033 
02034         if ( b == yy_current_buffer )
02035                 yy_current_buffer = (YY_BUFFER_STATE) 0;
02036 
02037         if ( b->yy_is_our_buffer )
02038                 yy_flex_free( (void *) b->yy_ch_buf );
02039 
02040         yy_flex_free( (void *) b );
02041         }
02042 
02043 
02044 
02045 #ifdef YY_USE_PROTOS
02046 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
02047 #else
02048 void yy_init_buffer( b, file )
02049 YY_BUFFER_STATE b;
02050 FILE *file;
02051 #endif
02052 
02053 
02054         {
02055         yy_flush_buffer( b );
02056 
02057         b->yy_input_file = file;
02058         b->yy_fill_buffer = 1;
02059 
02060 #if YY_ALWAYS_INTERACTIVE
02061         b->yy_is_interactive = 1;
02062 #else
02063 #if YY_NEVER_INTERACTIVE
02064         b->yy_is_interactive = 0;
02065 #else
02066         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
02067 #endif
02068 #endif
02069         }
02070 
02071 
02072 #ifdef YY_USE_PROTOS
02073 void yy_flush_buffer( YY_BUFFER_STATE b )
02074 #else
02075 void yy_flush_buffer( b )
02076 YY_BUFFER_STATE b;
02077 #endif
02078 
02079         {
02080         if ( ! b )
02081                 return;
02082 
02083         b->yy_n_chars = 0;
02084 
02085         /* We always need two end-of-buffer characters.  The first causes
02086          * a transition to the end-of-buffer state.  The second causes
02087          * a jam in that state.
02088          */
02089         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
02090         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
02091 
02092         b->yy_buf_pos = &b->yy_ch_buf[0];
02093 
02094         b->yy_at_bol = 1;
02095         b->yy_buffer_status = YY_BUFFER_NEW;
02096 
02097         if ( b == yy_current_buffer )
02098                 yy_load_buffer_state();
02099         }
02100 
02101 
02102 #ifndef YY_NO_SCAN_BUFFER
02103 #ifdef YY_USE_PROTOS
02104 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
02105 #else
02106 YY_BUFFER_STATE yy_scan_buffer( base, size )
02107 char *base;
02108 yy_size_t size;
02109 #endif
02110         {
02111         YY_BUFFER_STATE b;
02112 
02113         if ( size < 2 ||
02114              base[size-2] != YY_END_OF_BUFFER_CHAR ||
02115              base[size-1] != YY_END_OF_BUFFER_CHAR )
02116                 /* They forgot to leave room for the EOB's. */
02117                 return 0;
02118 
02119         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
02120         if ( ! b )
02121                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
02122 
02123         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
02124         b->yy_buf_pos = b->yy_ch_buf = base;
02125         b->yy_is_our_buffer = 0;
02126         b->yy_input_file = 0;
02127         b->yy_n_chars = b->yy_buf_size;
02128         b->yy_is_interactive = 0;
02129         b->yy_at_bol = 1;
02130         b->yy_fill_buffer = 0;
02131         b->yy_buffer_status = YY_BUFFER_NEW;
02132 
02133         yy_switch_to_buffer( b );
02134 
02135         return b;
02136         }
02137 #endif
02138 
02139 
02140 #ifndef YY_NO_SCAN_STRING
02141 #ifdef YY_USE_PROTOS
02142 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
02143 #else
02144 YY_BUFFER_STATE yy_scan_string( yy_str )
02145 yyconst char *yy_str;
02146 #endif
02147         {
02148         int len;
02149         for ( len = 0; yy_str[len]; ++len )
02150                 ;
02151 
02152         return yy_scan_bytes( yy_str, len );
02153         }
02154 #endif
02155 
02156 
02157 #ifndef YY_NO_SCAN_BYTES
02158 #ifdef YY_USE_PROTOS
02159 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
02160 #else
02161 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
02162 yyconst char *bytes;
02163 int len;
02164 #endif
02165         {
02166         YY_BUFFER_STATE b;
02167         char *buf;
02168         yy_size_t n;
02169         int i;
02170 
02171         /* Get memory for full buffer, including space for trailing EOB's. */
02172         n = len + 2;
02173         buf = (char *) yy_flex_alloc( n );
02174         if ( ! buf )
02175                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
02176 
02177         for ( i = 0; i < len; ++i )
02178                 buf[i] = bytes[i];
02179 
02180         buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
02181 
02182         b = yy_scan_buffer( buf, n );
02183         if ( ! b )
02184                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
02185 
02186         /* It's okay to grow etc. this buffer, and we should throw it
02187          * away when we're done.
02188          */
02189         b->yy_is_our_buffer = 1;
02190 
02191         return b;
02192         }
02193 #endif
02194 
02195 
02196 #ifndef YY_NO_PUSH_STATE
02197 #ifdef YY_USE_PROTOS
02198 static void yy_push_state( int new_state )
02199 #else
02200 static void yy_push_state( new_state )
02201 int new_state;
02202 #endif
02203         {
02204         if ( yy_start_stack_ptr >= yy_start_stack_depth )
02205                 {
02206                 yy_size_t new_size;
02207 
02208                 yy_start_stack_depth += YY_START_STACK_INCR;
02209                 new_size = yy_start_stack_depth * sizeof( int );
02210 
02211                 if ( ! yy_start_stack )
02212                         yy_start_stack = (int *) yy_flex_alloc( new_size );
02213 
02214                 else
02215                         yy_start_stack = (int *) yy_flex_realloc(
02216                                         (void *) yy_start_stack, new_size );
02217 
02218                 if ( ! yy_start_stack )
02219                         YY_FATAL_ERROR(
02220                         "out of memory expanding start-condition stack" );
02221                 }
02222 
02223         yy_start_stack[yy_start_stack_ptr++] = YY_START;
02224 
02225         BEGIN(new_state);
02226         }
02227 #endif
02228 
02229 
02230 #ifndef YY_NO_POP_STATE
02231 static void yy_pop_state()
02232         {
02233         if ( --yy_start_stack_ptr < 0 )
02234                 YY_FATAL_ERROR( "start-condition stack underflow" );
02235 
02236         BEGIN(yy_start_stack[yy_start_stack_ptr]);
02237         }
02238 #endif
02239 
02240 
02241 #ifndef YY_NO_TOP_STATE
02242 static int yy_top_state()
02243         {
02244         return yy_start_stack[yy_start_stack_ptr - 1];
02245         }
02246 #endif
02247 
02248 #ifndef YY_EXIT_FAILURE
02249 #define YY_EXIT_FAILURE 2
02250 #endif
02251 
02252 #ifdef YY_USE_PROTOS
02253 static void yy_fatal_error( yyconst char msg[] )
02254 #else
02255 static void yy_fatal_error( msg )
02256 char msg[];
02257 #endif
02258         {
02259         (void) fprintf( stderr, "%s\n", msg );
02260         exit( YY_EXIT_FAILURE );
02261         }
02262 
02263 
02264 
02265 /* Redefine yyless() so it works in section 3 code. */
02266 
02267 #undef yyless
02268 #define yyless(n) \
02269         do \
02270                 { \
02271                 /* Undo effects of setting up yytext. */ \
02272                 yytext[yyleng] = yy_hold_char; \
02273                 yy_c_buf_p = yytext + n; \
02274                 yy_hold_char = *yy_c_buf_p; \
02275                 *yy_c_buf_p = '\0'; \
02276                 yyleng = n; \
02277                 } \
02278         while ( 0 )
02279 
02280 
02281 /* Internal utility routines. */
02282 
02283 #ifndef yytext_ptr
02284 #ifdef YY_USE_PROTOS
02285 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
02286 #else
02287 static void yy_flex_strncpy( s1, s2, n )
02288 char *s1;
02289 yyconst char *s2;
02290 int n;
02291 #endif
02292         {
02293         register int i;
02294         for ( i = 0; i < n; ++i )
02295                 s1[i] = s2[i];
02296         }
02297 #endif
02298 
02299 #ifdef YY_NEED_STRLEN
02300 #ifdef YY_USE_PROTOS
02301 static int yy_flex_strlen( yyconst char *s )
02302 #else
02303 static int yy_flex_strlen( s )
02304 yyconst char *s;
02305 #endif
02306         {
02307         register int n;
02308         for ( n = 0; s[n]; ++n )
02309                 ;
02310 
02311         return n;
02312         }
02313 #endif
02314 
02315 
02316 #ifdef YY_USE_PROTOS
02317 static void *yy_flex_alloc( yy_size_t size )
02318 #else
02319 static void *yy_flex_alloc( size )
02320 yy_size_t size;
02321 #endif
02322         {
02323         return (void *) malloc( size );
02324         }
02325 
02326 #ifdef YY_USE_PROTOS
02327 static void *yy_flex_realloc( void *ptr, yy_size_t size )
02328 #else
02329 static void *yy_flex_realloc( ptr, size )
02330 void *ptr;
02331 yy_size_t size;
02332 #endif
02333         {
02334         /* The cast to (char *) in the following accommodates both
02335          * implementations that use char* generic pointers, and those
02336          * that use void* generic pointers.  It works with the latter
02337          * because both ANSI C and C++ allow castless assignment from
02338          * any pointer type to void*, and deal with argument conversions
02339          * as though doing an assignment.
02340          */
02341         return (void *) realloc( (char *) ptr, size );
02342         }
02343 
02344 #ifdef YY_USE_PROTOS
02345 static void yy_flex_free( void *ptr )
02346 #else
02347 static void yy_flex_free( ptr )
02348 void *ptr;
02349 #endif
02350         {
02351         free( ptr );
02352         }
02353 
02354 #if YY_MAIN
02355 int main()
02356         {
02357         yylex();
02358         return 0;
02359         }
02360 #endif
02361 #line 552 "src/acpp/archc.lex"
02362 

Generated on Thu Jun 24 08:30:05 2004 for ArchC by doxygen 1.3.4