lib/AsmParser/Lexer.cpp

   1 #define yy_create_buffer llvmAsm_create_buffer
   2 #define yy_delete_buffer llvmAsm_delete_buffer
   3 #define yy_scan_buffer llvmAsm_scan_buffer
   4 #define yy_scan_string llvmAsm_scan_string
   5 #define yy_scan_bytes llvmAsm_scan_bytes
   6 #define yy_flex_debug llvmAsm_flex_debug
   7 #define yy_init_buffer llvmAsm_init_buffer
   8 #define yy_flush_buffer llvmAsm_flush_buffer
   9 #define yy_load_buffer_state llvmAsm_load_buffer_state
  10 #define yy_switch_to_buffer llvmAsm_switch_to_buffer
  11 #define yyin llvmAsmin
  12 #define yyleng llvmAsmleng
  13 #define yylex llvmAsmlex
  14 #define yyout llvmAsmout
  15 #define yyrestart llvmAsmrestart
  16 #define yytext llvmAsmtext
  17 #define yylineno llvmAsmlineno
  18
  19 #line 20 "Lexer.cpp"
  20 /* A lexical scanner generated by flex */
  21
  22 /* Scanner skeleton version:
  23  * $Header$
  24  */
  25
  26 #define FLEX_SCANNER
  27 #define YY_FLEX_MAJOR_VERSION 2
  28 #define YY_FLEX_MINOR_VERSION 5
  29
  30 #include <stdio.h>
  31
  32
  33 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
  34 #ifdef c_plusplus
  35 #ifndef __cplusplus
  36 #define __cplusplus
  37 #endif
  38 #endif
  39
  40
  41 #ifdef __cplusplus
  42
  43 #include <stdlib.h>
  44 #include <unistd.h>
  45
  46 /* Use prototypes in function declarations. */
  47 #define YY_USE_PROTOS
  48
  49 /* The "const" storage-class-modifier is valid. */
  50 #define YY_USE_CONST
  51
  52 #else   /* ! __cplusplus */
  53
  54 #if __STDC__
  55
  56 #define YY_USE_PROTOS
  57 #define YY_USE_CONST
  58
  59 #endif  /* __STDC__ */
  60 #endif  /* ! __cplusplus */
  61
  62 #ifdef __TURBOC__
  63  #pragma warn -rch
  64  #pragma warn -use
  65 #include <io.h>
  66 #include <stdlib.h>
  67 #define YY_USE_CONST
  68 #define YY_USE_PROTOS
  69 #endif
  70
  71 #ifdef YY_USE_CONST
  72 #define yyconst const
  73 #else
  74 #define yyconst
  75 #endif
  76
  77
  78 #ifdef YY_USE_PROTOS
  79 #define YY_PROTO(proto) proto
  80 #else
  81 #define YY_PROTO(proto) ()
  82 #endif
  83
  84 /* Returned upon end-of-file. */
  85 #define YY_NULL 0
  86
  87 /* Promotes a possibly negative, possibly signed char to an unsigned
  88  * integer for use as an array index.  If the signed char is negative,
  89  * we want to instead treat it as an 8-bit unsigned char, hence the
  90  * double cast.
  91  */
  92 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
  93
  94 /* Enter a start condition.  This macro really ought to take a parameter,
  95  * but we do it the disgusting crufty way forced on us by the ()-less
  96  * definition of BEGIN.
  97  */
  98 #define BEGIN yy_start = 1 + 2 *
  99
 100 /* Translate the current start state into a value that can be later handed
 101  * to BEGIN to return to the state.  The YYSTATE alias is for lex
 102  * compatibility.
 103  */
 104 #define YY_START ((yy_start - 1) / 2)
 105 #define YYSTATE YY_START
 106
 107 /* Action number for EOF rule of a given start state. */
 108 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
 109
 110 /* Special action meaning "start processing a new file". */
 111 #define YY_NEW_FILE yyrestart( yyin )
 112
 113 #define YY_END_OF_BUFFER_CHAR 0
 114
 115 /* Size of default input buffer. */
 116 #define YY_BUF_SIZE 16384
 117
 118 typedef struct yy_buffer_state *YY_BUFFER_STATE;
 119
 120 extern int yyleng;
 121 extern FILE *yyin, *yyout;
 122
 123 #define EOB_ACT_CONTINUE_SCAN 0
 124 #define EOB_ACT_END_OF_FILE 1
 125 #define EOB_ACT_LAST_MATCH 2
 126
 127 /* The funky do-while in the following #define is used to turn the definition
 128  * int a single C statement (which needs a semi-colon terminator).  This
 129  * avoids problems with code like:
 130  *
 131  *      if ( condition_holds )
 132  *              yyless( 5 );
 133  *      else
 134  *              do_something_else();
 135  *
 136  * Prior to using the do-while the compiler would get upset at the
 137  * "else" because it interpreted the "if" statement as being all
 138  * done when it reached the ';' after the yyless() call.
 139  */
 140
 141 /* Return all but the first 'n' matched characters back to the input stream. */
 142
 143 #define yyless(n) \
 144         do \
 145                 { \
 146                 /* Undo effects of setting up yytext. */ \
 147                 *yy_cp = yy_hold_char; \
 148                 YY_RESTORE_YY_MORE_OFFSET \
 149                 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
 150                 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
 151                 } \
 152         while ( 0 )
 153
 154 #define unput(c) yyunput( c, yytext_ptr )
 155
 156 /* The following is because we cannot portably get our hands on size_t
 157  * (without autoconf's help, which isn't available because we want
 158  * flex-generated scanners to compile on their own).
 159  */
 160 typedef unsigned int yy_size_t;
 161
 162
 163 struct yy_buffer_state
 164         {
 165         FILE *yy_input_file;
 166
 167         char *yy_ch_buf;                /* input buffer */
 168         char *yy_buf_pos;               /* current position in input buffer */
 169
 170         /* Size of input buffer in bytes, not including room for EOB
 171          * characters.
 172          */
 173         yy_size_t yy_buf_size;
 174
 175         /* Number of characters read into yy_ch_buf, not including EOB
 176          * characters.
 177          */
 178         int yy_n_chars;
 179
 180         /* Whether we "own" the buffer - i.e., we know we created it,
 181          * and can realloc() it to grow it, and should free() it to
 182          * delete it.
 183          */
 184         int yy_is_our_buffer;
 185
 186         /* Whether this is an "interactive" input source; if so, and
 187          * if we're using stdio for input, then we want to use getc()
 188          * instead of fread(), to make sure we stop fetching input after
 189          * each newline.
 190          */
 191         int yy_is_interactive;
 192
 193         /* Whether we're considered to be at the beginning of a line.
 194          * If so, '^' rules will be active on the next match, otherwise
 195          * not.
 196          */
 197         int yy_at_bol;
 198
 199         /* Whether to try to fill the input buffer when we reach the
 200          * end of it.
 201          */
 202         int yy_fill_buffer;
 203
 204         int yy_buffer_status;
 205 #define YY_BUFFER_NEW 0
 206 #define YY_BUFFER_NORMAL 1
 207         /* When an EOF's been seen but there's still some text to process
 208          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
 209          * shouldn't try reading from the input source any more.  We might
 210          * still have a bunch of tokens to match, though, because of
 211          * possible backing-up.
 212          *
 213          * When we actually see the EOF, we change the status to "new"
 214          * (via yyrestart()), so that the user can continue scanning by
 215          * just pointing yyin at a new input file.
 216          */
 217 #define YY_BUFFER_EOF_PENDING 2
 218         };
 219
 220 static YY_BUFFER_STATE yy_current_buffer = 0;
 221
 222 /* We provide macros for accessing buffer states in case in the
 223  * future we want to put the buffer states in a more general
 224  * "scanner state".
 225  */
 226 #define YY_CURRENT_BUFFER yy_current_buffer
 227
 228
 229 /* yy_hold_char holds the character lost when yytext is formed. */
 230 static char yy_hold_char;
 231
 232 static int yy_n_chars;          /* number of characters read into yy_ch_buf */
 233
 234
 235 int yyleng;
 236
 237 /* Points to current character in buffer. */
 238 static char *yy_c_buf_p = (char *) 0;
 239 static int yy_init = 1;         /* whether we need to initialize */
 240 static int yy_start = 0;        /* start state number */
 241
 242 /* Flag which is used to allow yywrap()'s to do buffer switches
 243  * instead of setting up a fresh yyin.  A bit of a hack ...
 244  */
 245 static int yy_did_buffer_switch_on_eof;
 246
 247 void yyrestart YY_PROTO(( FILE *input_file ));
 248
 249 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
 250 void yy_load_buffer_state YY_PROTO(( void ));
 251 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
 252 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
 253 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
 254 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
 255 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
 256
 257 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
 258 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
 259 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
 260
 261 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
 262 static inline void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
 263 static void yy_flex_free YY_PROTO(( void * ));
 264
 265 #define yy_new_buffer yy_create_buffer
 266
 267 #define yy_set_interactive(is_interactive) \
 268         { \
 269         if ( ! yy_current_buffer ) \
 270                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
 271         yy_current_buffer->yy_is_interactive = is_interactive; \
 272         }
 273
 274 #define yy_set_bol(at_bol) \
 275         { \
 276         if ( ! yy_current_buffer ) \
 277                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
 278         yy_current_buffer->yy_at_bol = at_bol; \
 279         }
 280
 281 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
 282
 283
 284 #define YY_USES_REJECT
 285
 286 #define yywrap() 1
 287 #define YY_SKIP_YYWRAP
 288 typedef unsigned char YY_CHAR;
 289 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
 290 typedef int yy_state_type;
 291 extern int yylineno;
 292 int yylineno = 1;
 293 extern char *yytext;
 294 #define yytext_ptr yytext
 295
 296 static yy_state_type yy_get_previous_state YY_PROTO(( void ));
 297 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
 298 static int yy_get_next_buffer YY_PROTO(( void ));
 299 static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
 300
 301 /* Done after the current pattern has been matched and before the
 302  * corresponding action - sets up yytext.
 303  */
 304 #define YY_DO_BEFORE_ACTION \
 305         yytext_ptr = yy_bp; \
 306         yyleng = (int) (yy_cp - yy_bp); \
 307         yy_hold_char = *yy_cp; \
 308         *yy_cp = '\0'; \
 309         yy_c_buf_p = yy_cp;
 310
 311 #define YY_NUM_RULES 59
 312 #define YY_END_OF_BUFFER 60
 313 static yyconst short int yy_acclist[115] =
 314     {   0,
 315        60,   58,   59,   57,   58,   59,   57,   59,   58,   59,
 316        58,   59,   58,   59,   58,   59,   52,   58,   59,    1,
 317        58,   59,   58,   59,   58,   59,   58,   59,   58,   59,
 318        58,   59,   58,   59,   58,   59,   58,   59,   58,   59,
 319        58,   59,   58,   59,   58,   59,   58,   59,   58,   59,
 320        58,   59,   58,   59,   58,   59,   50,   49,   54,   53,
 321        56,   52,    1,   41,   34,   51,   49,   55,   56,   23,
 322        26,    3,   14,   25,   22,   35,   27,   40,   38,   39,
 323        24,    9,   36,   37,   45,   46,   16,    4,   20,   15,
 324         8,    2,    5,   18,   21,   10,   29,   33,   31,   32,
 325
 326        30,   28,   12,   47,   11,   17,   44,   19,   43,   42,
 327        13,    6,   48,    7
 328     } ;
 329
 330 static yyconst short int yy_accept[201] =
 331     {   0,
 332         1,    1,    1,    2,    4,    7,    9,   11,   13,   15,
 333        17,   20,   23,   25,   27,   29,   31,   33,   35,   37,
 334        39,   41,   43,   45,   47,   49,   51,   53,   55,   57,
 335        57,   57,   58,   59,   59,   60,   61,   62,   63,   64,
 336        64,   64,   64,   64,   65,   65,   65,   65,   65,   65,
 337        65,   65,   65,   65,   65,   65,   65,   65,   65,   65,
 338        65,   65,   65,   65,   65,   65,   65,   65,   65,   66,
 339        66,   66,   66,   66,   66,   66,   66,   67,   68,   69,
 340        70,   71,   71,   71,   71,   71,   71,   71,   72,   72,
 341        73,   73,   73,   73,   73,   73,   74,   74,   74,   74,
 342
 343        74,   75,   76,   77,   78,   79,   79,   79,   80,   80,
 344        81,   81,   82,   82,   82,   82,   82,   82,   82,   82,
 345        82,   82,   82,   83,   84,   85,   85,   85,   85,   85,
 346        86,   86,   86,   86,   87,   88,   88,   88,   88,   88,
 347        88,   88,   88,   88,   88,   89,   90,   90,   91,   91,
 348        91,   92,   92,   93,   93,   93,   94,   95,   95,   95,
 349        96,   96,   97,   98,   99,  100,  101,  102,  103,  104,
 350       105,  105,  106,  107,  107,  108,  108,  109,  109,  109,
 351       110,  111,  112,  113,  113,  113,  113,  113,  113,  113,
 352       113,  113,  113,  113,  113,  113,  114,  114,  115,  115
 353
 354     } ;
 355
 356 static yyconst int yy_ec[256] =
 357     {   0,
 358         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
 359         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 360         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 361         1,    2,    1,    4,    1,    5,    6,    1,    1,    1,
 362         1,    1,    1,    1,    7,    8,    1,    9,    9,    9,
 363         9,    9,    9,    9,    9,    9,    9,   10,   11,    1,
 364         1,    1,    1,    1,    5,    5,    5,    5,    5,    5,
 365         5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
 366         5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
 367         1,    1,    1,    1,    5,    1,   12,   13,   14,   15,
 368
 369        16,   17,   18,   19,   20,    5,    5,   21,   22,   23,
 370        24,   25,   26,   27,   28,   29,   30,   31,   32,    5,
 371        33,    5,    1,    1,    1,    1,    1,    1,    1,    1,
 372         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 373         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 374         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 375         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 376         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 377         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 378         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 379
 380         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 381         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 382         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 383         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 384         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 385         1,    1,    1,    1,    1
 386     } ;
 387
 388 static yyconst int yy_meta[34] =
 389     {   0,
 390         1,    1,    2,    3,    4,    1,    5,    4,    4,    6,
 391         1,    4,    4,    4,    4,    4,    4,    4,    4,    4,
 392         4,    4,    4,    4,    4,    4,    4,    4,    4,    4,
 393         4,    4,    4
 394     } ;
 395
 396 static yyconst short int yy_base[205] =
 397     {   0,
 398         0,    0,  396,  397,  397,  397,    0,  385,   27,  385,
 399        29,    0,   25,   31,   32,   33,   38,   42,   35,   49,
 400        50,   54,   46,   57,   63,   75,   65,   98,   58,  389,
 401       382,  397,    0,  382,  381,  380,   68,   87,    0,   71,
 402        80,   92,   89,  378,   93,   73,   96,   70,  102,   99,
 403       105,  106,  113,   40,  114,  115,  121,  120,  124,  122,
 404       126,  125,  127,  128,  129,  138,  139,  145,  377,  148,
 405       149,  130,  154,  151,  157,  159,  397,    0,  377,  161,
 406       375,  156,  162,  163,  171,  158,  173,  374,  175,  373,
 407       176,  179,  180,  183,  185,  372,  187,  190,  191,  192,
 408
 409       371,  370,  369,  368,  367,  188,  208,  366,  198,  365,
 410       200,  364,  201,  204,  205,  206,  209,  213,  218,  197,
 411       223,  222,  363,  362,  361,  229,  230,  233,  224,  360,
 412       234,  236,  237,  359,  358,  238,  240,  244,  247,  249,
 413       250,  251,  257,  254,  357,  356,  259,  355,  261,  262,
 414       354,  271,  353,  264,  272,  352,  351,  274,  275,  350,
 415       282,  349,  348,  347,  346,  345,  344,  343,  342,  341,
 416       267,  336,  331,  277,  326,  283,  319,  285,  284,  317,
 417       315,  311,  310,  288,  291,  292,  293,  295,  298,  301,
 418       299,  302,  303,  306,  308,  309,  307,  212,  397,  333,
 419
 420       336,  339,  344,   89
 421     } ;
 422
 423 static yyconst short int yy_def[205] =
 424     {   0,
 425       199,    1,  199,  199,  199,  199,  200,  201,  202,  199,
 426       201,  203,  201,  201,  201,  201,  201,  201,  201,  201,
 427       201,  201,  201,  201,  201,  201,  201,  201,  201,  200,
 428       201,  199,  204,  199,  199,  199,  201,  201,  203,  201,
 429       201,  201,  201,  201,  201,  201,  201,  201,  201,  201,
 430       201,  201,  201,  201,  201,  201,  201,  201,  201,  201,
 431       201,  201,  201,  201,  201,  201,  201,  201,  201,  201,
 432       201,  201,  201,  201,  201,  201,  199,  204,  199,  201,
 433       201,  201,  201,  201,  201,  201,  201,  201,  201,  201,
 434       201,  201,  201,  201,  201,  201,  201,  201,  201,  201,
 435
 436       201,  201,  201,  201,  201,  201,  201,  201,  201,  201,
 437       201,  201,  201,  201,  201,  201,  201,  201,  201,  201,
 438       201,  201,  201,  201,  201,  201,  201,  201,  201,  201,
 439       201,  201,  201,  201,  201,  201,  201,  201,  201,  201,
 440       201,  201,  201,  201,  201,  201,  201,  201,  201,  201,
 441       201,  201,  201,  201,  201,  201,  201,  201,  201,  201,
 442       201,  201,  201,  201,  201,  201,  201,  201,  201,  201,
 443       201,  201,  201,  201,  201,  201,  201,  201,  201,  201,
 444       201,  201,  201,  201,  201,  201,  201,  201,  201,  201,
 445       201,  201,  201,  201,  201,  201,  201,  201,    0,  199,
 446
 447       199,  199,  199,  199
 448     } ;
 449
 450 static yyconst short int yy_nxt[431] =
 451     {   0,
 452         4,    5,    6,    7,    8,    9,   10,    8,   11,    4,
 453        12,   13,   14,   15,   16,   17,   18,   19,    8,   20,
 454        21,   22,   23,    8,   24,    8,   25,   26,   27,   28,
 455        29,    8,    8,   34,   32,   35,   37,   38,   32,   40,
 456        32,   32,   32,   45,   32,   41,   42,   32,   46,   32,
 457        53,   32,   47,   50,   43,   32,   48,   44,   32,   32,
 458        49,   56,   51,   32,   95,   58,   32,   32,   52,   60,
 459        54,   55,   32,   57,   32,   61,   80,   32,   62,   32,
 460        32,   76,   32,   59,   32,   81,   87,   63,   69,   32,
 461        64,   70,   78,   65,   37,   38,   32,   71,   32,   89,
 462
 463        82,   32,   32,   66,   67,   32,   68,   32,   32,   83,
 464        72,   32,   84,   85,   32,   32,   90,   73,   74,   91,
 465        86,   93,   32,   32,   32,   75,   88,   97,   92,   32,
 466        32,   32,   98,   32,   32,   32,   32,   32,   32,   32,
 467       100,   94,   96,   99,  101,  103,  104,   32,   32,  108,
 468       102,  112,  109,  105,   32,  110,  107,   32,   32,  106,
 469        32,  111,  116,   32,  113,   32,   32,   32,   32,   80,
 470        32,   32,   32,  115,  118,  119,  117,  114,  120,  121,
 471        32,  122,   32,  123,   32,   32,  125,  127,   32,   32,
 472       129,  124,   32,  126,   32,  130,   32,   32,  131,   32,
 473
 474        32,   32,  133,  128,  134,  132,   32,   32,  135,   32,
 475        32,  151,  136,   32,   32,   32,  137,   32,   32,  145,
 476       146,   32,   32,  138,  142,  139,  143,   32,  140,  144,
 477       141,   32,   32,   32,  147,  149,  152,  148,   32,   32,
 478       154,  150,   32,   32,  153,   32,   32,   32,  156,   32,
 479       155,  159,  157,   32,  158,  162,   32,  160,   32,   32,
 480        32,  161,  164,   32,  166,  168,   32,  171,   32,  163,
 481        32,   32,  170,   32,  172,  165,   32,  167,  173,  169,
 482        32,   32,  175,   32,   32,  181,   32,  177,  174,  178,
 483       176,   32,   32,   32,   32,  180,  179,   32,  183,  185,
 484
 485        32,   32,   32,  186,   32,  182,  184,   32,   32,  191,
 486        32,   32,   32,  187,  188,   32,   32,   32,   32,   32,
 487        32,  189,  195,  190,   32,  192,   32,  193,   32,  198,
 488       194,  197,  196,   30,   30,   32,   30,   30,   30,   31,
 489        32,   31,   33,   33,   39,   32,   39,   39,   39,   39,
 490        32,   32,   32,   32,   32,   32,   32,   32,   32,   32,
 491        32,   32,   32,   32,   32,   32,   32,   32,   32,   32,
 492        32,   32,   32,   32,   32,   32,   32,   32,   32,   32,
 493        32,   32,   32,   32,   32,   79,   32,   32,   36,   35,
 494        79,   32,   77,   36,   32,  199,    3,  199,  199,  199,
 495
 496       199,  199,  199,  199,  199,  199,  199,  199,  199,  199,
 497       199,  199,  199,  199,  199,  199,  199,  199,  199,  199,
 498       199,  199,  199,  199,  199,  199,  199,  199,  199,  199
 499     } ;
 500
 501 static yyconst short int yy_chk[431] =
 502     {   0,
 503         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 504         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 505         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 506         1,    1,    1,    9,   13,    9,   11,   11,   11,   13,
 507        14,   15,   16,   15,   19,   13,   14,   17,   16,   54,
 508        19,   18,   16,   18,   14,   23,   16,   14,   20,   21,
 509        17,   21,   18,   22,   54,   22,   24,   29,   18,   23,
 510        20,   20,   25,   21,   27,   24,   37,   37,   25,   48,
 511        40,   29,   46,   22,   26,   40,   46,   26,   27,   41,
 512        26,   27,  204,   26,   38,   38,   38,   27,   43,   48,
 513
 514        41,   42,   45,   26,   26,   47,   26,   28,   50,   42,
 515        28,   49,   43,   45,   51,   52,   49,   28,   28,   50,
 516        45,   52,   53,   55,   56,   28,   47,   56,   51,   58,
 517        57,   60,   57,   59,   62,   61,   63,   64,   65,   72,
 518        58,   53,   55,   57,   59,   61,   62,   66,   67,   65,
 519        60,   67,   65,   62,   68,   65,   64,   70,   71,   63,
 520        74,   66,   72,   73,   68,   82,   75,   86,   76,   80,
 521        80,   83,   84,   71,   74,   75,   73,   70,   76,   82,
 522        85,   83,   87,   84,   89,   91,   86,   89,   92,   93,
 523        92,   85,   94,   87,   95,   93,   97,  106,   94,   98,
 524
 525        99,  100,   97,   91,   98,   95,  120,  109,   99,  111,
 526       113,  120,  100,  114,  115,  116,  106,  107,  117,  114,
 527       115,  198,  118,  107,  109,  107,  111,  119,  107,  113,
 528       107,  122,  121,  129,  116,  118,  121,  117,  126,  127,
 529       126,  119,  128,  131,  122,  132,  133,  136,  128,  137,
 530       127,  132,  129,  138,  131,  137,  139,  133,  140,  141,
 531       142,  136,  139,  144,  140,  141,  143,  144,  147,  138,
 532       149,  150,  143,  154,  147,  139,  171,  140,  149,  142,
 533       152,  155,  152,  158,  159,  171,  174,  155,  150,  158,
 534       154,  161,  176,  179,  178,  161,  159,  184,  176,  179,
 535
 536       185,  186,  187,  184,  188,  174,  178,  189,  191,  189,
 537       190,  192,  193,  185,  186,  194,  197,  195,  196,  183,
 538       182,  187,  193,  188,  181,  190,  180,  191,  177,  197,
 539       192,  195,  194,  200,  200,  175,  200,  200,  200,  201,
 540       173,  201,  202,  202,  203,  172,  203,  203,  203,  203,
 541       170,  169,  168,  167,  166,  165,  164,  163,  162,  160,
 542       157,  156,  153,  151,  148,  146,  145,  135,  134,  130,
 543       125,  124,  123,  112,  110,  108,  105,  104,  103,  102,
 544       101,   96,   90,   88,   81,   79,   69,   44,   36,   35,
 545        34,   31,   30,   10,    8,    3,  199,  199,  199,  199,
 546
 547       199,  199,  199,  199,  199,  199,  199,  199,  199,  199,
 548       199,  199,  199,  199,  199,  199,  199,  199,  199,  199,
 549       199,  199,  199,  199,  199,  199,  199,  199,  199,  199
 550     } ;
 551
 552 static yy_state_type yy_state_buf[YY_BUF_SIZE + 2], *yy_state_ptr;
 553 static char *yy_full_match;
 554 static int yy_lp;
 555 #define REJECT \
 556 { \
 557 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */ \
 558 yy_cp = yy_full_match; /* restore poss. backed-over text */ \
 559 ++yy_lp; \
 560 goto find_rule; \
 561 }
 562 #define yymore() yymore_used_but_not_detected
 563 #define YY_MORE_ADJ 0
 564 #define YY_RESTORE_YY_MORE_OFFSET
 565 char *yytext;
 566 #line 1 "Lexer.l"
 567 #define INITIAL 0
 568 /*===-- Lexer.l - Scanner for llvm assembly files ----------------*- C++ -*--=//
 569 //
 570 //  This file implements the flex scanner for LLVM assembly languages files.
 571 //
 572 //===------------------------------------------------------------------------=*/
 573 #define YY_NEVER_INTERACTIVE 1
 574 #line 21 "Lexer.l"
 575 #include "ParserInternals.h"
 576 #include "llvm/BasicBlock.h"
 577 #include "llvm/Method.h"
 578 #include "llvm/Module.h"
 579 #include <list>
 580 #include "llvmAsmParser.h"
 581
 582 #define RET_TOK(type, Enum, sym) \
 583   llvmAsmlval.type = Instruction::Enum; return sym
 584
 585
 586 // TODO: All of the static identifiers are figured out by the lexer,
 587 // these should be hashed.
 588
 589
 590 // atoull - Convert an ascii string of decimal digits into the unsigned long
 591 // long representation... this does not have to do input error checking,
 592 // because we know that the input will be matched by a suitable regex...
 593 //
 594 uint64_t atoull(const char *Buffer) {
 595   uint64_t Result = 0;
 596   for (; *Buffer; Buffer++) {
 597     uint64_t OldRes = Result;
 598     Result *= 10;
 599     Result += *Buffer-'0';
 600     if (Result < OldRes) {  // Uh, oh, overflow detected!!!
 601       ThrowException("constant bigger than 64 bits detected!");
 602     }
 603   }
 604   return Result;
 605 }
 606
 607
 608 #define YY_NEVER_INTERACTIVE 1
 609 /* Comments start with a ; and go till end of line */
 610 /* Variable(Value) identifiers start with a % sign */
 611 /* Label identifiers end with a colon */
 612 /* Quoted names can contain any character except " and \ */
 613 /* [PN]Integer: match positive and negative literal integer values that
 614  * are preceeded by a '%' character.  These represent unnamed variable slots.
 615  */
 616 /* E[PN]Integer: match positive and negative literal integer values */
 617 /* FPConstant - A Floating point constant.
 618    TODO: Expand lexer to support 10e50 FP constant notation */
 619 #line 620 "Lexer.cpp"
 620
 621 /* Macros after this point can all be overridden by user definitions in
 622  * section 1.
 623  */
 624
 625 #ifndef YY_SKIP_YYWRAP
 626 #ifdef __cplusplus
 627 extern "C" int yywrap YY_PROTO(( void ));
 628 #else
 629 extern int yywrap YY_PROTO(( void ));
 630 #endif
 631 #endif
 632
 633 #ifndef YY_NO_UNPUT
 634 static inline void yyunput YY_PROTO(( int c, char *buf_ptr ));
 635 #endif
 636
 637 #ifndef yytext_ptr
 638 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
 639 #endif
 640
 641 #ifdef YY_NEED_STRLEN
 642 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
 643 #endif
 644
 645 #ifndef YY_NO_INPUT
 646 #ifdef __cplusplus
 647 static int yyinput YY_PROTO(( void ));
 648 #else
 649 static int input YY_PROTO(( void ));
 650 #endif
 651 #endif
 652
 653 #if YY_STACK_USED
 654 static int yy_start_stack_ptr = 0;
 655 static int yy_start_stack_depth = 0;
 656 static int *yy_start_stack = 0;
 657 #ifndef YY_NO_PUSH_STATE
 658 static void yy_push_state YY_PROTO(( int new_state ));
 659 #endif
 660 #ifndef YY_NO_POP_STATE
 661 static void yy_pop_state YY_PROTO(( void ));
 662 #endif
 663 #ifndef YY_NO_TOP_STATE
 664 static int yy_top_state YY_PROTO(( void ));
 665 #endif
 666
 667 #else
 668 #define YY_NO_PUSH_STATE 1
 669 #define YY_NO_POP_STATE 1
 670 #define YY_NO_TOP_STATE 1
 671 #endif
 672
 673 #ifdef YY_MALLOC_DECL
 674 YY_MALLOC_DECL
 675 #else
 676 #if __STDC__
 677 #ifndef __cplusplus
 678 #include <stdlib.h>
 679 #endif
 680 #else
 681 /* Just try to get by without declaring the routines.  This will fail
 682  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
 683  * or sizeof(void*) != sizeof(int).
 684  */
 685 #endif
 686 #endif
 687
 688 /* Amount of stuff to slurp up with each read. */
 689 #ifndef YY_READ_BUF_SIZE
 690 #define YY_READ_BUF_SIZE 8192
 691 #endif
 692
 693 /* Copy whatever the last rule matched to the standard output. */
 694
 695 #ifndef ECHO
 696 /* This used to be an fputs(), but since the string might contain NUL's,
 697  * we now use fwrite().
 698  */
 699 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
 700 #endif
 701
 702 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
 703  * is returned in "result".
 704  */
 705 #ifndef YY_INPUT
 706 #define YY_INPUT(buf,result,max_size) \
 707         if ( yy_current_buffer->yy_is_interactive ) \
 708                 { \
 709                 int c = '*', n; \
 710                 for ( n = 0; n < max_size && \
 711                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
 712                         buf[n] = (char) c; \
 713                 if ( c == '\n' ) \
 714                         buf[n++] = (char) c; \
 715                 if ( c == EOF && ferror( yyin ) ) \
 716                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
 717                 result = n; \
 718                 } \
 719         else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
 720                   && ferror( yyin ) ) \
 721                 YY_FATAL_ERROR( "input in flex scanner failed" );
 722 #endif
 723
 724 /* No semi-colon after return; correct usage is to write "yyterminate();" -
 725  * we don't want an extra ';' after the "return" because that will cause
 726  * some compilers to complain about unreachable statements.
 727  */
 728 #ifndef yyterminate
 729 #define yyterminate() return YY_NULL
 730 #endif
 731
 732 /* Number of entries by which start-condition stack grows. */
 733 #ifndef YY_START_STACK_INCR
 734 #define YY_START_STACK_INCR 25
 735 #endif
 736
 737 /* Report a fatal error. */
 738 #ifndef YY_FATAL_ERROR
 739 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
 740 #endif
 741
 742 /* Default declaration of generated scanner - a define so the user can
 743  * easily add parameters.
 744  */
 745 #ifndef YY_DECL
 746 #define YY_DECL int yylex YY_PROTO(( void ))
 747 #endif
 748
 749 /* Code executed at the beginning of each rule, after yytext and yyleng
 750  * have been set up.
 751  */
 752 #ifndef YY_USER_ACTION
 753 #define YY_USER_ACTION
 754 #endif
 755
 756 /* Code executed at the end of each rule. */
 757 #ifndef YY_BREAK
 758 #define YY_BREAK break;
 759 #endif
 760
 761 #define YY_RULE_SETUP \
 762         YY_USER_ACTION
 763
 764 YY_DECL
 765         {
 766         register yy_state_type yy_current_state;
 767         register char *yy_cp, *yy_bp;
 768         register int yy_act;
 769
 770 #line 87 "Lexer.l"
 771
 772
 773 #line 774 "Lexer.cpp"
 774
 775         if ( yy_init )
 776                 {
 777                 yy_init = 0;
 778
 779 #ifdef YY_USER_INIT
 780                 YY_USER_INIT;
 781 #endif
 782
 783                 if ( ! yy_start )
 784                         yy_start = 1;   /* first start state */
 785
 786                 if ( ! yyin )
 787                         yyin = stdin;
 788
 789                 if ( ! yyout )
 790                         yyout = stdout;
 791
 792                 if ( ! yy_current_buffer )
 793                         yy_current_buffer =
 794                                 yy_create_buffer( yyin, YY_BUF_SIZE );
 795
 796                 yy_load_buffer_state();
 797                 }
 798
 799         while ( 1 )             /* loops until end-of-file is reached */
 800                 {
 801                 yy_cp = yy_c_buf_p;
 802
 803                 /* Support of yytext. */
 804                 *yy_cp = yy_hold_char;
 805
 806                 /* yy_bp points to the position in yy_ch_buf of the start of
 807                  * the current run.
 808                  */
 809                 yy_bp = yy_cp;
 810
 811                 yy_current_state = yy_start;
 812                 yy_state_ptr = yy_state_buf;
 813                 *yy_state_ptr++ = yy_current_state;
 814 yy_match:
 815                 do
 816                         {
 817                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
 818                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
 819                                 {
 820                                 yy_current_state = (int) yy_def[yy_current_state];
 821                                 if ( yy_current_state >= 200 )
 822                                         yy_c = yy_meta[(unsigned int) yy_c];
 823                                 }
 824                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
 825                         *yy_state_ptr++ = yy_current_state;
 826                         ++yy_cp;
 827                         }
 828                 while ( yy_current_state != 199 );
 829
 830 yy_find_action:
 831                 yy_current_state = *--yy_state_ptr;
 832                 yy_lp = yy_accept[yy_current_state];
 833                 for ( ; ; ) /* until we find what rule we matched */
 834                         {
 835                         if ( yy_lp && yy_lp < yy_accept[yy_current_state + 1] )
 836                                 {
 837                                 yy_act = yy_acclist[yy_lp];
 838                                         {
 839                                         yy_full_match = yy_cp;
 840                                         break;
 841                                         }
 842                                 }
 843                         --yy_cp;
 844                         yy_current_state = *--yy_state_ptr;
 845                         yy_lp = yy_accept[yy_current_state];
 846                         }
 847
 848                 YY_DO_BEFORE_ACTION;
 849
 850                 if ( yy_act != YY_END_OF_BUFFER )
 851                         {
 852                         int yyl;
 853                         for ( yyl = 0; yyl < yyleng; ++yyl )
 854                                 if ( yytext[yyl] == '\n' )
 855                                         ++yylineno;
 856                         }
 857
 858 do_action:      /* This label is used only to access EOF actions. */
 859
 860
 861                 switch ( yy_act )
 862         { /* beginning of action switch */
 863 case 1:
 864 YY_RULE_SETUP
 865 #line 89 "Lexer.l"
 866 { /* Ignore comments for now */ }
 867         YY_BREAK
 868 case 2:
 869 YY_RULE_SETUP
 870 #line 91 "Lexer.l"
 871 { return BEGINTOK; }
 872         YY_BREAK
 873 case 3:
 874 YY_RULE_SETUP
 875 #line 92 "Lexer.l"
 876 { return END; }
 877         YY_BREAK
 878 case 4:
 879 YY_RULE_SETUP
 880 #line 93 "Lexer.l"
 881 { return TRUE;  }
 882         YY_BREAK
 883 case 5:
 884 YY_RULE_SETUP
 885 #line 94 "Lexer.l"
 886 { return FALSE; }
 887         YY_BREAK
 888 case 6:
 889 YY_RULE_SETUP
 890 #line 95 "Lexer.l"
 891 { return DECLARE; }
 892         YY_BREAK
 893 case 7:
 894 YY_RULE_SETUP
 895 #line 96 "Lexer.l"
 896 { return IMPLEMENTATION; }
 897         YY_BREAK
 898 case 8:
 899 YY_RULE_SETUP
 900 #line 98 "Lexer.l"
 901 { llvmAsmlval.TypeVal = Type::VoidTy  ; return VOID;   }
 902         YY_BREAK
 903 case 9:
 904 YY_RULE_SETUP
 905 #line 99 "Lexer.l"
 906 { llvmAsmlval.TypeVal = Type::BoolTy  ; return BOOL;   }
 907         YY_BREAK
 908 case 10:
 909 YY_RULE_SETUP
 910 #line 100 "Lexer.l"
 911 { llvmAsmlval.TypeVal = Type::SByteTy ; return SBYTE;  }
 912         YY_BREAK
 913 case 11:
 914 YY_RULE_SETUP
 915 #line 101 "Lexer.l"
 916 { llvmAsmlval.TypeVal = Type::UByteTy ; return UBYTE;  }
 917         YY_BREAK
 918 case 12:
 919 YY_RULE_SETUP
 920 #line 102 "Lexer.l"
 921 { llvmAsmlval.TypeVal = Type::ShortTy ; return SHORT;  }
 922         YY_BREAK
 923 case 13:
 924 YY_RULE_SETUP
 925 #line 103 "Lexer.l"
 926 { llvmAsmlval.TypeVal = Type::UShortTy; return USHORT; }
 927         YY_BREAK
 928 case 14:
 929 YY_RULE_SETUP
 930 #line 104 "Lexer.l"
 931 { llvmAsmlval.TypeVal = Type::IntTy   ; return INT;    }
 932         YY_BREAK
 933 case 15:
 934 YY_RULE_SETUP
 935 #line 105 "Lexer.l"
 936 { llvmAsmlval.TypeVal = Type::UIntTy  ; return UINT;   }
 937         YY_BREAK
 938 case 16:
 939 YY_RULE_SETUP
 940 #line 106 "Lexer.l"
 941 { llvmAsmlval.TypeVal = Type::LongTy  ; return LONG;   }
 942         YY_BREAK
 943 case 17:
 944 YY_RULE_SETUP
 945 #line 107 "Lexer.l"
 946 { llvmAsmlval.TypeVal = Type::ULongTy ; return ULONG;  }
 947         YY_BREAK
 948 case 18:
 949 YY_RULE_SETUP
 950 #line 108 "Lexer.l"
 951 { llvmAsmlval.TypeVal = Type::FloatTy ; return FLOAT;  }
 952         YY_BREAK
 953 case 19:
 954 YY_RULE_SETUP
 955 #line 109 "Lexer.l"
 956 { llvmAsmlval.TypeVal = Type::DoubleTy; return DOUBLE; }
 957         YY_BREAK
 958 case 20:
 959 YY_RULE_SETUP
 960 #line 111 "Lexer.l"
 961 { llvmAsmlval.TypeVal = Type::TypeTy  ; return TYPE;   }
 962         YY_BREAK
 963 case 21:
 964 YY_RULE_SETUP
 965 #line 113 "Lexer.l"
 966 { llvmAsmlval.TypeVal = Type::LabelTy ; return LABEL;  }
 967         YY_BREAK
 968 case 22:
 969 YY_RULE_SETUP
 970 #line 116 "Lexer.l"
 971 { RET_TOK(UnaryOpVal, Not, NOT); }
 972         YY_BREAK
 973 case 23:
 974 YY_RULE_SETUP
 975 #line 118 "Lexer.l"
 976 { RET_TOK(BinaryOpVal, Add, ADD); }
 977         YY_BREAK
 978 case 24:
 979 YY_RULE_SETUP
 980 #line 119 "Lexer.l"
 981 { RET_TOK(BinaryOpVal, Sub, SUB); }
 982         YY_BREAK
 983 case 25:
 984 YY_RULE_SETUP
 985 #line 120 "Lexer.l"
 986 { RET_TOK(BinaryOpVal, Mul, MUL); }
 987         YY_BREAK
 988 case 26:
 989 YY_RULE_SETUP
 990 #line 121 "Lexer.l"
 991 { RET_TOK(BinaryOpVal, Div, DIV); }
 992         YY_BREAK
 993 case 27:
 994 YY_RULE_SETUP
 995 #line 122 "Lexer.l"
 996 { RET_TOK(BinaryOpVal, Rem, REM); }
 997         YY_BREAK
 998 case 28:
 999 YY_RULE_SETUP
1000 #line 123 "Lexer.l"
1001 { RET_TOK(BinaryOpVal, SetNE, SETNE); }
1002         YY_BREAK
1003 case 29:
1004 YY_RULE_SETUP
1005 #line 124 "Lexer.l"
1006 { RET_TOK(BinaryOpVal, SetEQ, SETEQ); }
1007         YY_BREAK
1008 case 30:
1009 YY_RULE_SETUP
1010 #line 125 "Lexer.l"
1011 { RET_TOK(BinaryOpVal, SetLT, SETLT); }
1012         YY_BREAK
1013 case 31:
1014 YY_RULE_SETUP
1015 #line 126 "Lexer.l"
1016 { RET_TOK(BinaryOpVal, SetGT, SETGT); }
1017         YY_BREAK
1018 case 32:
1019 YY_RULE_SETUP
1020 #line 127 "Lexer.l"
1021 { RET_TOK(BinaryOpVal, SetLE, SETLE); }
1022         YY_BREAK
1023 case 33:
1024 YY_RULE_SETUP
1025 #line 128 "Lexer.l"
1026 { RET_TOK(BinaryOpVal, SetGE, SETGE); }
1027         YY_BREAK
1028 case 34:
1029 YY_RULE_SETUP
1030 #line 130 "Lexer.l"
1031 { return TO; }
1032         YY_BREAK
1033 case 35:
1034 YY_RULE_SETUP
1035 #line 131 "Lexer.l"
1036 { RET_TOK(OtherOpVal, PHINode, PHI); }
1037         YY_BREAK
1038 case 36:
1039 YY_RULE_SETUP
1040 #line 132 "Lexer.l"
1041 { RET_TOK(OtherOpVal, Call, CALL); }
1042         YY_BREAK
1043 case 37:
1044 YY_RULE_SETUP
1045 #line 133 "Lexer.l"
1046 { RET_TOK(OtherOpVal, Cast, CAST); }
1047         YY_BREAK
1048 case 38:
1049 YY_RULE_SETUP
1050 #line 134 "Lexer.l"
1051 { RET_TOK(OtherOpVal, Shl, SHL); }
1052         YY_BREAK
1053 case 39:
1054 YY_RULE_SETUP
1055 #line 135 "Lexer.l"
1056 { RET_TOK(OtherOpVal, Shr, SHR); }
1057         YY_BREAK
1058 case 40:
1059 YY_RULE_SETUP
1060 #line 137 "Lexer.l"
1061 { RET_TOK(TermOpVal, Ret, RET); }
1062         YY_BREAK
1063 case 41:
1064 YY_RULE_SETUP
1065 #line 138 "Lexer.l"
1066 { RET_TOK(TermOpVal, Br, BR); }
1067         YY_BREAK
1068 case 42:
1069 YY_RULE_SETUP
1070 #line 139 "Lexer.l"
1071 { RET_TOK(TermOpVal, Switch, SWITCH); }
1072         YY_BREAK
1073 case 43:
1074 YY_RULE_SETUP
1075 #line 142 "Lexer.l"
1076 { RET_TOK(MemOpVal, Malloc, MALLOC); }
1077         YY_BREAK
1078 case 44:
1079 YY_RULE_SETUP
1080 #line 143 "Lexer.l"
1081 { RET_TOK(MemOpVal, Alloca, ALLOCA); }
1082         YY_BREAK
1083 case 45:
1084 YY_RULE_SETUP
1085 #line 144 "Lexer.l"
1086 { RET_TOK(MemOpVal, Free, FREE); }
1087         YY_BREAK
1088 case 46:
1089 YY_RULE_SETUP
1090 #line 145 "Lexer.l"
1091 { RET_TOK(MemOpVal, Load, LOAD); }
1092         YY_BREAK
1093 case 47:
1094 YY_RULE_SETUP
1095 #line 146 "Lexer.l"
1096 { RET_TOK(MemOpVal, Store, STORE); }
1097         YY_BREAK
1098 case 48:
1099 YY_RULE_SETUP
1100 #line 147 "Lexer.l"
1101 { RET_TOK(MemOpVal, GetElementPtr, GETELEMENTPTR); }
1102         YY_BREAK
1103 case 49:
1104 YY_RULE_SETUP
1105 #line 150 "Lexer.l"
1106 { llvmAsmlval.StrVal = strdup(yytext+1); return VAR_ID; }
1107         YY_BREAK
1108 case 50:
1109 YY_RULE_SETUP
1110 #line 151 "Lexer.l"
1111 {
1112                   yytext[strlen(yytext)-1] = 0;  // nuke colon
1113                   llvmAsmlval.StrVal = strdup(yytext);
1114                   return LABELSTR;
1115                 }
1116         YY_BREAK
1117 case 51:
1118 YY_RULE_SETUP
1119 #line 157 "Lexer.l"
1120 {
1121                   yytext[strlen(yytext)-1] = 0;           // nuke end quote
1122                   llvmAsmlval.StrVal = strdup(yytext+1);  // Nuke start quote
1123                   return STRINGCONSTANT;
1124                 }
1125         YY_BREAK
1126 case 52:
1127 YY_RULE_SETUP
1128 #line 164 "Lexer.l"
1129 { llvmAsmlval.UInt64Val = atoull(yytext); return EUINT64VAL; }
1130         YY_BREAK
1131 case 53:
1132 YY_RULE_SETUP
1133 #line 165 "Lexer.l"
1134 {
1135                   uint64_t Val = atoull(yytext+1);
1136                   // +1:  we have bigger negative range
1137                   if (Val > (uint64_t)INT64_MAX+1)
1138                     ThrowException("Constant too large for signed 64 bits!");
1139                   llvmAsmlval.SInt64Val = -Val;
1140                   return ESINT64VAL;
1141                 }
1142         YY_BREAK
1143 case 54:
1144 YY_RULE_SETUP
1145 #line 175 "Lexer.l"
1146 { llvmAsmlval.UIntVal = atoull(yytext+1); return UINTVAL; }
1147         YY_BREAK
1148 case 55:
1149 YY_RULE_SETUP
1150 #line 176 "Lexer.l"
1151 {
1152                   uint64_t Val = atoull(yytext+2);
1153                   // +1:  we have bigger negative range
1154                   if (Val > (uint64_t)INT32_MAX+1)
1155                     ThrowException("Constant too large for signed 32 bits!");
1156                   llvmAsmlval.SIntVal = -Val;
1157                   return SINTVAL;
1158                 }
1159         YY_BREAK
1160 case 56:
1161 YY_RULE_SETUP
1162 #line 185 "Lexer.l"
1163 { llvmAsmlval.FPVal = atof(yytext); return FPVAL; }
1164         YY_BREAK
1165 case 57:
1166 YY_RULE_SETUP
1167 #line 187 "Lexer.l"
1168 { /* Ignore whitespace */ }
1169         YY_BREAK
1170 case 58:
1171 YY_RULE_SETUP
1172 #line 188 "Lexer.l"
1173 { /*printf("'%s'", yytext);*/ return yytext[0]; }
1174         YY_BREAK
1175 case 59:
1176 YY_RULE_SETUP
1177 #line 190 "Lexer.l"
1178 YY_FATAL_ERROR( "flex scanner jammed" );
1179         YY_BREAK
1180 #line 1182 "Lexer.cpp"
1181                         case YY_STATE_EOF(INITIAL):
1182                                 yyterminate();
1183
1184         case YY_END_OF_BUFFER:
1185                 {
1186                 /* Amount of text matched not including the EOB char. */
1187                 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
1188
1189                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1190                 *yy_cp = yy_hold_char;
1191                 YY_RESTORE_YY_MORE_OFFSET
1192
1193                 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
1194                         {
1195                         /* We're scanning a new file or input source.  It's
1196                          * possible that this happened because the user
1197                          * just pointed yyin at a new source and called
1198                          * yylex().  If so, then we have to assure
1199                          * consistency between yy_current_buffer and our
1200                          * globals.  Here is the right place to do so, because
1201                          * this is the first action (other than possibly a
1202                          * back-up) that will match for the new input source.
1203                          */
1204                         yy_n_chars = yy_current_buffer->yy_n_chars;
1205                         yy_current_buffer->yy_input_file = yyin;
1206                         yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
1207                         }
1208
1209                 /* Note that here we test for yy_c_buf_p "<=" to the position
1210                  * of the first EOB in the buffer, since yy_c_buf_p will
1211                  * already have been incremented past the NUL character
1212                  * (since all states make transitions on EOB to the
1213                  * end-of-buffer state).  Contrast this with the test
1214                  * in input().
1215                  */
1216                 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1217                         { /* This was really a NUL. */
1218                         yy_state_type yy_next_state;
1219
1220                         yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
1221
1222                         yy_current_state = yy_get_previous_state();
1223
1224                         /* Okay, we're now positioned to make the NUL
1225                          * transition.  We couldn't have
1226                          * yy_get_previous_state() go ahead and do it
1227                          * for us because it doesn't know how to deal
1228                          * with the possibility of jamming (and we don't
1229                          * want to build jamming into it because then it
1230                          * will run more slowly).
1231                          */
1232
1233                         yy_next_state = yy_try_NUL_trans( yy_current_state );
1234
1235                         yy_bp = yytext_ptr + YY_MORE_ADJ;
1236
1237                         if ( yy_next_state )
1238                                 {
1239                                 /* Consume the NUL. */
1240                                 yy_cp = ++yy_c_buf_p;
1241                                 yy_current_state = yy_next_state;
1242                                 goto yy_match;
1243                                 }
1244
1245                         else
1246                                 {
1247                                 yy_cp = yy_c_buf_p;
1248                                 goto yy_find_action;
1249                                 }
1250                         }
1251
1252                 else switch ( yy_get_next_buffer() )
1253                         {
1254                         case EOB_ACT_END_OF_FILE:
1255                                 {
1256                                 yy_did_buffer_switch_on_eof = 0;
1257
1258                                 if ( yywrap() )
1259                                         {
1260                                         /* Note: because we've taken care in
1261                                          * yy_get_next_buffer() to have set up
1262                                          * yytext, we can now set up
1263                                          * yy_c_buf_p so that if some total
1264                                          * hoser (like flex itself) wants to
1265                                          * call the scanner after we return the
1266                                          * YY_NULL, it'll still work - another
1267                                          * YY_NULL will get returned.
1268                                          */
1269                                         yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
1270
1271                                         yy_act = YY_STATE_EOF(YY_START);
1272                                         goto do_action;
1273                                         }
1274
1275                                 else
1276                                         {
1277                                         if ( ! yy_did_buffer_switch_on_eof )
1278                                                 YY_NEW_FILE;
1279                                         }
1280                                 break;
1281                                 }
1282
1283                         case EOB_ACT_CONTINUE_SCAN:
1284                                 yy_c_buf_p =
1285                                         yytext_ptr + yy_amount_of_matched_text;
1286
1287                                 yy_current_state = yy_get_previous_state();
1288
1289                                 yy_cp = yy_c_buf_p;
1290                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
1291                                 goto yy_match;
1292
1293                         case EOB_ACT_LAST_MATCH:
1294                                 yy_c_buf_p =
1295                                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
1296
1297                                 yy_current_state = yy_get_previous_state();
1298
1299                                 yy_cp = yy_c_buf_p;
1300                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
1301                                 goto yy_find_action;
1302                         }
1303                 break;
1304                 }
1305
1306         default:
1307                 YY_FATAL_ERROR(
1308                         "fatal flex scanner internal error--no action found" );
1309         } /* end of action switch */
1310                 } /* end of scanning one token */
1311         } /* end of yylex */
1312
1313
1314 /* yy_get_next_buffer - try to read in a new buffer
1315  *
1316  * Returns a code representing an action:
1317  *      EOB_ACT_LAST_MATCH -
1318  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1319  *      EOB_ACT_END_OF_FILE - end of file
1320  */
1321
1322 static int yy_get_next_buffer()
1323         {
1324         register char *dest = yy_current_buffer->yy_ch_buf;
1325         register char *source = yytext_ptr;
1326         register int number_to_move, i;
1327         int ret_val;
1328
1329         if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
1330                 YY_FATAL_ERROR(
1331                 "fatal flex scanner internal error--end of buffer missed" );
1332
1333         if ( yy_current_buffer->yy_fill_buffer == 0 )
1334                 { /* Don't try to fill the buffer, so this is an EOF. */
1335                 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
1336                         {
1337                         /* We matched a single character, the EOB, so
1338                          * treat this as a final EOF.
1339                          */
1340                         return EOB_ACT_END_OF_FILE;
1341                         }
1342
1343                 else
1344                         {
1345                         /* We matched some text prior to the EOB, first
1346                          * process it.
1347                          */
1348                         return EOB_ACT_LAST_MATCH;
1349                         }
1350                 }
1351
1352         /* Try to read more data. */
1353
1354         /* First move last chars to start of buffer. */
1355         number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
1356
1357         for ( i = 0; i < number_to_move; ++i )
1358                 *(dest++) = *(source++);
1359
1360         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1361                 /* don't do the read, it's not guaranteed to return an EOF,
1362                  * just force an EOF
1363                  */
1364                 yy_current_buffer->yy_n_chars = yy_n_chars = 0;
1365
1366         else
1367                 {
1368                 int num_to_read =
1369                         yy_current_buffer->yy_buf_size - number_to_move - 1;
1370
1371                 while ( num_to_read <= 0 )
1372                         { /* Not enough room in the buffer - grow it. */
1373 #ifdef YY_USES_REJECT
1374                         YY_FATAL_ERROR(
1375 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
1376 #else
1377
1378                         /* just a shorter name for the current buffer */
1379                         YY_BUFFER_STATE b = yy_current_buffer;
1380
1381                         int yy_c_buf_p_offset =
1382                                 (int) (yy_c_buf_p - b->yy_ch_buf);
1383
1384                         if ( b->yy_is_our_buffer )
1385                                 {
1386                                 int new_size = b->yy_buf_size * 2;
1387
1388                                 if ( new_size <= 0 )
1389                                         b->yy_buf_size += b->yy_buf_size / 8;
1390                                 else
1391                                         b->yy_buf_size *= 2;
1392
1393                                 b->yy_ch_buf = (char *)
1394                                         /* Include room in for 2 EOB chars. */
1395                                         yy_flex_realloc( (void *) b->yy_ch_buf,
1396                                                          b->yy_buf_size + 2 );
1397                                 }
1398                         else
1399                                 /* Can't grow it, we don't own it. */
1400                                 b->yy_ch_buf = 0;
1401
1402                         if ( ! b->yy_ch_buf )
1403                                 YY_FATAL_ERROR(
1404                                 "fatal error - scanner input buffer overflow" );
1405
1406                         yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1407
1408                         num_to_read = yy_current_buffer->yy_buf_size -
1409                                                 number_to_move - 1;
1410 #endif
1411                         }
1412
1413                 if ( num_to_read > YY_READ_BUF_SIZE )
1414                         num_to_read = YY_READ_BUF_SIZE;
1415
1416                 /* Read in more data. */
1417                 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
1418                         yy_n_chars, num_to_read );
1419
1420                 yy_current_buffer->yy_n_chars = yy_n_chars;
1421                 }
1422
1423         if ( yy_n_chars == 0 )
1424                 {
1425                 if ( number_to_move == YY_MORE_ADJ )
1426                         {
1427                         ret_val = EOB_ACT_END_OF_FILE;
1428                         yyrestart( yyin );
1429                         }
1430
1431                 else
1432                         {
1433                         ret_val = EOB_ACT_LAST_MATCH;
1434                         yy_current_buffer->yy_buffer_status =
1435                                 YY_BUFFER_EOF_PENDING;
1436                         }
1437                 }
1438
1439         else
1440                 ret_val = EOB_ACT_CONTINUE_SCAN;
1441
1442         yy_n_chars += number_to_move;
1443         yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1444         yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1445
1446         yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
1447
1448         return ret_val;
1449         }
1450
1451
1452 /* yy_get_previous_state - get the state just before the EOB char was reached */
1453
1454 static yy_state_type yy_get_previous_state()
1455         {
1456         register yy_state_type yy_current_state;
1457         register char *yy_cp;
1458
1459         yy_current_state = yy_start;
1460         yy_state_ptr = yy_state_buf;
1461         *yy_state_ptr++ = yy_current_state;
1462
1463         for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
1464                 {
1465                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1466                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1467                         {
1468                         yy_current_state = (int) yy_def[yy_current_state];
1469                         if ( yy_current_state >= 200 )
1470                                 yy_c = yy_meta[(unsigned int) yy_c];
1471                         }
1472                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1473                 *yy_state_ptr++ = yy_current_state;
1474                 }
1475
1476         return yy_current_state;
1477         }
1478
1479
1480 /* yy_try_NUL_trans - try to make a transition on the NUL character
1481  *
1482  * synopsis
1483  *      next_state = yy_try_NUL_trans( current_state );
1484  */
1485
1486 #ifdef YY_USE_PROTOS
1487 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
1488 #else
1489 static yy_state_type yy_try_NUL_trans( yy_current_state )
1490 yy_state_type yy_current_state;
1491 #endif
1492         {
1493         register int yy_is_jam;
1494
1495         register YY_CHAR yy_c = 1;
1496         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1497                 {
1498                 yy_current_state = (int) yy_def[yy_current_state];
1499                 if ( yy_current_state >= 200 )
1500                         yy_c = yy_meta[(unsigned int) yy_c];
1501                 }
1502         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1503         yy_is_jam = (yy_current_state == 199);
1504         if ( ! yy_is_jam )
1505                 *yy_state_ptr++ = yy_current_state;
1506
1507         return yy_is_jam ? 0 : yy_current_state;
1508         }
1509
1510
1511 #ifndef YY_NO_UNPUT
1512 #ifdef YY_USE_PROTOS
1513 static inline void yyunput( int c, register char *yy_bp )
1514 #else
1515 static inline void yyunput( c, yy_bp )
1516 int c;
1517 register char *yy_bp;
1518 #endif
1519         {
1520         register char *yy_cp = yy_c_buf_p;
1521
1522         /* undo effects of setting up yytext */
1523         *yy_cp = yy_hold_char;
1524
1525         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1526                 { /* need to shift things up to make room */
1527                 /* +2 for EOB chars. */
1528                 register int number_to_move = yy_n_chars + 2;
1529                 register char *dest = &yy_current_buffer->yy_ch_buf[
1530                                         yy_current_buffer->yy_buf_size + 2];
1531                 register char *source =
1532                                 &yy_current_buffer->yy_ch_buf[number_to_move];
1533
1534                 while ( source > yy_current_buffer->yy_ch_buf )
1535                         *--dest = *--source;
1536
1537                 yy_cp += (int) (dest - source);
1538                 yy_bp += (int) (dest - source);
1539                 yy_current_buffer->yy_n_chars =
1540                         yy_n_chars = yy_current_buffer->yy_buf_size;
1541
1542                 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1543                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
1544                 }
1545
1546         *--yy_cp = (char) c;
1547
1548         if ( c == '\n' )
1549                 --yylineno;
1550
1551         yytext_ptr = yy_bp;
1552         yy_hold_char = *yy_cp;
1553         yy_c_buf_p = yy_cp;
1554         }
1555 #endif  /* ifndef YY_NO_UNPUT */
1556
1557
1558 #ifdef __cplusplus
1559 static int yyinput()
1560 #else
1561 static int input()
1562 #endif
1563         {
1564         int c;
1565
1566         *yy_c_buf_p = yy_hold_char;
1567
1568         if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1569                 {
1570                 /* yy_c_buf_p now points to the character we want to return.
1571                  * If this occurs *before* the EOB characters, then it's a
1572                  * valid NUL; if not, then we've hit the end of the buffer.
1573                  */
1574                 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1575                         /* This was really a NUL. */
1576                         *yy_c_buf_p = '\0';
1577
1578                 else
1579                         { /* need more input */
1580                         int offset = yy_c_buf_p - yytext_ptr;
1581                         ++yy_c_buf_p;
1582
1583                         switch ( yy_get_next_buffer() )
1584                                 {
1585                                 case EOB_ACT_LAST_MATCH:
1586                                         /* This happens because yy_g_n_b()
1587                                          * sees that we've accumulated a
1588                                          * token and flags that we need to
1589                                          * try matching the token before
1590                                          * proceeding.  But for input(),
1591                                          * there's no matching to consider.
1592                                          * So convert the EOB_ACT_LAST_MATCH
1593                                          * to EOB_ACT_END_OF_FILE.
1594                                          */
1595
1596                                         /* Reset buffer status. */
1597                                         yyrestart( yyin );
1598
1599                                         /* fall through */
1600
1601                                 case EOB_ACT_END_OF_FILE:
1602                                         {
1603                                         if ( yywrap() )
1604                                                 return EOF;
1605
1606                                         if ( ! yy_did_buffer_switch_on_eof )
1607                                                 YY_NEW_FILE;
1608 #ifdef __cplusplus
1609                                         return yyinput();
1610 #else
1611                                         return input();
1612 #endif
1613                                         }
1614
1615                                 case EOB_ACT_CONTINUE_SCAN:
1616                                         yy_c_buf_p = yytext_ptr + offset;
1617                                         break;
1618                                 }
1619                         }
1620                 }
1621
1622         c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */
1623         *yy_c_buf_p = '\0';     /* preserve yytext */
1624         yy_hold_char = *++yy_c_buf_p;
1625
1626         if ( c == '\n' )
1627                 ++yylineno;
1628
1629         return c;
1630         }
1631
1632
1633 #ifdef YY_USE_PROTOS
1634 void yyrestart( FILE *input_file )
1635 #else
1636 void yyrestart( input_file )
1637 FILE *input_file;
1638 #endif
1639         {
1640         if ( ! yy_current_buffer )
1641                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
1642
1643         yy_init_buffer( yy_current_buffer, input_file );
1644         yy_load_buffer_state();
1645         }
1646
1647
1648 #ifdef YY_USE_PROTOS
1649 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
1650 #else
1651 void yy_switch_to_buffer( new_buffer )
1652 YY_BUFFER_STATE new_buffer;
1653 #endif
1654         {
1655         if ( yy_current_buffer == new_buffer )
1656                 return;
1657
1658         if ( yy_current_buffer )
1659                 {
1660                 /* Flush out information for old buffer. */
1661                 *yy_c_buf_p = yy_hold_char;
1662                 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
1663                 yy_current_buffer->yy_n_chars = yy_n_chars;
1664                 }
1665
1666         yy_current_buffer = new_buffer;
1667         yy_load_buffer_state();
1668
1669         /* We don't actually know whether we did this switch during
1670          * EOF (yywrap()) processing, but the only time this flag
1671          * is looked at is after yywrap() is called, so it's safe
1672          * to go ahead and always set it.
1673          */
1674         yy_did_buffer_switch_on_eof = 1;
1675         }
1676
1677
1678 #ifdef YY_USE_PROTOS
1679 void yy_load_buffer_state( void )
1680 #else
1681 void yy_load_buffer_state()
1682 #endif
1683         {
1684         yy_n_chars = yy_current_buffer->yy_n_chars;
1685         yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
1686         yyin = yy_current_buffer->yy_input_file;
1687         yy_hold_char = *yy_c_buf_p;
1688         }
1689
1690
1691 #ifdef YY_USE_PROTOS
1692 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
1693 #else
1694 YY_BUFFER_STATE yy_create_buffer( file, size )
1695 FILE *file;
1696 int size;
1697 #endif
1698         {
1699         YY_BUFFER_STATE b;
1700
1701         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1702         if ( ! b )
1703                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1704
1705         b->yy_buf_size = size;
1706
1707         /* yy_ch_buf has to be 2 characters longer than the size given because
1708          * we need to put in 2 end-of-buffer characters.
1709          */
1710         b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
1711         if ( ! b->yy_ch_buf )
1712                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1713
1714         b->yy_is_our_buffer = 1;
1715
1716         yy_init_buffer( b, file );
1717
1718         return b;
1719         }
1720
1721
1722 #ifdef YY_USE_PROTOS
1723 void yy_delete_buffer( YY_BUFFER_STATE b )
1724 #else
1725 void yy_delete_buffer( b )
1726 YY_BUFFER_STATE b;
1727 #endif
1728         {
1729         if ( ! b )
1730                 return;
1731
1732         if ( b == yy_current_buffer )
1733                 yy_current_buffer = (YY_BUFFER_STATE) 0;
1734
1735         if ( b->yy_is_our_buffer )
1736                 yy_flex_free( (void *) b->yy_ch_buf );
1737
1738         yy_flex_free( (void *) b );
1739         }
1740
1741
1742 #ifndef YY_ALWAYS_INTERACTIVE
1743 #ifndef YY_NEVER_INTERACTIVE
1744 extern int isatty YY_PROTO(( int ));
1745 #endif
1746 #endif
1747
1748 #ifdef YY_USE_PROTOS
1749 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
1750 #else
1751 void yy_init_buffer( b, file )
1752 YY_BUFFER_STATE b;
1753 FILE *file;
1754 #endif
1755
1756
1757         {
1758         yy_flush_buffer( b );
1759
1760         b->yy_input_file = file;
1761         b->yy_fill_buffer = 1;
1762
1763 #if YY_ALWAYS_INTERACTIVE
1764         b->yy_is_interactive = 1;
1765 #else
1766 #if YY_NEVER_INTERACTIVE
1767         b->yy_is_interactive = 0;
1768 #else
1769         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1770 #endif
1771 #endif
1772         }
1773
1774
1775 #ifdef YY_USE_PROTOS
1776 void yy_flush_buffer( YY_BUFFER_STATE b )
1777 #else
1778 void yy_flush_buffer( b )
1779 YY_BUFFER_STATE b;
1780 #endif
1781
1782         {
1783         if ( ! b )
1784                 return;
1785
1786         b->yy_n_chars = 0;
1787
1788         /* We always need two end-of-buffer characters.  The first causes
1789          * a transition to the end-of-buffer state.  The second causes
1790          * a jam in that state.
1791          */
1792         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1793         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1794
1795         b->yy_buf_pos = &b->yy_ch_buf[0];
1796
1797         b->yy_at_bol = 1;
1798         b->yy_buffer_status = YY_BUFFER_NEW;
1799
1800         if ( b == yy_current_buffer )
1801                 yy_load_buffer_state();
1802         }
1803
1804
1805 #ifndef YY_NO_SCAN_BUFFER
1806 #ifdef YY_USE_PROTOS
1807 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
1808 #else
1809 YY_BUFFER_STATE yy_scan_buffer( base, size )
1810 char *base;
1811 yy_size_t size;
1812 #endif
1813         {
1814         YY_BUFFER_STATE b;
1815
1816         if ( size < 2 ||
1817              base[size-2] != YY_END_OF_BUFFER_CHAR ||
1818              base[size-1] != YY_END_OF_BUFFER_CHAR )
1819                 /* They forgot to leave room for the EOB's. */
1820                 return 0;
1821
1822         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1823         if ( ! b )
1824                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1825
1826         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
1827         b->yy_buf_pos = b->yy_ch_buf = base;
1828         b->yy_is_our_buffer = 0;
1829         b->yy_input_file = 0;
1830         b->yy_n_chars = b->yy_buf_size;
1831         b->yy_is_interactive = 0;
1832         b->yy_at_bol = 1;
1833         b->yy_fill_buffer = 0;
1834         b->yy_buffer_status = YY_BUFFER_NEW;
1835
1836         yy_switch_to_buffer( b );
1837
1838         return b;
1839         }
1840 #endif
1841
1842
1843 #ifndef YY_NO_SCAN_STRING
1844 #ifdef YY_USE_PROTOS
1845 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
1846 #else
1847 YY_BUFFER_STATE yy_scan_string( yy_str )
1848 yyconst char *yy_str;
1849 #endif
1850         {
1851         int len;
1852         for ( len = 0; yy_str[len]; ++len )
1853                 ;
1854
1855         return yy_scan_bytes( yy_str, len );
1856         }
1857 #endif
1858
1859
1860 #ifndef YY_NO_SCAN_BYTES
1861 #ifdef YY_USE_PROTOS
1862 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
1863 #else
1864 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
1865 yyconst char *bytes;
1866 int len;
1867 #endif
1868         {
1869         YY_BUFFER_STATE b;
1870         char *buf;
1871         yy_size_t n;
1872         int i;
1873
1874         /* Get memory for full buffer, including space for trailing EOB's. */
1875         n = len + 2;
1876         buf = (char *) yy_flex_alloc( n );
1877         if ( ! buf )
1878                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1879
1880         for ( i = 0; i < len; ++i )
1881                 buf[i] = bytes[i];
1882
1883         buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
1884
1885         b = yy_scan_buffer( buf, n );
1886         if ( ! b )
1887                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1888
1889         /* It's okay to grow etc. this buffer, and we should throw it
1890          * away when we're done.
1891          */
1892         b->yy_is_our_buffer = 1;
1893
1894         return b;
1895         }
1896 #endif
1897
1898
1899 #ifndef YY_NO_PUSH_STATE
1900 #ifdef YY_USE_PROTOS
1901 static void yy_push_state( int new_state )
1902 #else
1903 static void yy_push_state( new_state )
1904 int new_state;
1905 #endif
1906         {
1907         if ( yy_start_stack_ptr >= yy_start_stack_depth )
1908                 {
1909                 yy_size_t new_size;
1910
1911                 yy_start_stack_depth += YY_START_STACK_INCR;
1912                 new_size = yy_start_stack_depth * sizeof( int );
1913
1914                 if ( ! yy_start_stack )
1915                         yy_start_stack = (int *) yy_flex_alloc( new_size );
1916
1917                 else
1918                         yy_start_stack = (int *) yy_flex_realloc(
1919                                         (void *) yy_start_stack, new_size );
1920
1921                 if ( ! yy_start_stack )
1922                         YY_FATAL_ERROR(
1923                         "out of memory expanding start-condition stack" );
1924                 }
1925
1926         yy_start_stack[yy_start_stack_ptr++] = YY_START;
1927
1928         BEGIN(new_state);
1929         }
1930 #endif
1931
1932
1933 #ifndef YY_NO_POP_STATE
1934 static void yy_pop_state()
1935         {
1936         if ( --yy_start_stack_ptr < 0 )
1937                 YY_FATAL_ERROR( "start-condition stack underflow" );
1938
1939         BEGIN(yy_start_stack[yy_start_stack_ptr]);
1940         }
1941 #endif
1942
1943
1944 #ifndef YY_NO_TOP_STATE
1945 static int yy_top_state()
1946         {
1947         return yy_start_stack[yy_start_stack_ptr - 1];
1948         }
1949 #endif
1950
1951 #ifndef YY_EXIT_FAILURE
1952 #define YY_EXIT_FAILURE 2
1953 #endif
1954
1955 #ifdef YY_USE_PROTOS
1956 static void yy_fatal_error( yyconst char msg[] )
1957 #else
1958 static void yy_fatal_error( msg )
1959 char msg[];
1960 #endif
1961         {
1962         (void) fprintf( stderr, "%s\n", msg );
1963         exit( YY_EXIT_FAILURE );
1964         }
1965
1966
1967
1968 /* Redefine yyless() so it works in section 3 code. */
1969
1970 #undef yyless
1971 #define yyless(n) \
1972         do \
1973                 { \
1974                 /* Undo effects of setting up yytext. */ \
1975                 yytext[yyleng] = yy_hold_char; \
1976                 yy_c_buf_p = yytext + n; \
1977                 yy_hold_char = *yy_c_buf_p; \
1978                 *yy_c_buf_p = '\0'; \
1979                 yyleng = n; \
1980                 } \
1981         while ( 0 )
1982
1983
1984 /* Internal utility routines. */
1985
1986 #ifndef yytext_ptr
1987 #ifdef YY_USE_PROTOS
1988 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
1989 #else
1990 static void yy_flex_strncpy( s1, s2, n )
1991 char *s1;
1992 yyconst char *s2;
1993 int n;
1994 #endif
1995         {
1996         register int i;
1997         for ( i = 0; i < n; ++i )
1998                 s1[i] = s2[i];
1999         }
2000 #endif
2001
2002 #ifdef YY_NEED_STRLEN
2003 #ifdef YY_USE_PROTOS
2004 static int yy_flex_strlen( yyconst char *s )
2005 #else
2006 static int yy_flex_strlen( s )
2007 yyconst char *s;
2008 #endif
2009         {
2010         register int n;
2011         for ( n = 0; s[n]; ++n )
2012                 ;
2013
2014         return n;
2015         }
2016 #endif
2017
2018
2019 #ifdef YY_USE_PROTOS
2020 static void *yy_flex_alloc( yy_size_t size )
2021 #else
2022 static void *yy_flex_alloc( size )
2023 yy_size_t size;
2024 #endif
2025         {
2026         return (void *) malloc( size );
2027         }
2028
2029 #ifdef YY_USE_PROTOS
2030 static inline void *yy_flex_realloc( void *ptr, yy_size_t size )
2031 #else
2032 static inline void *yy_flex_realloc( ptr, size )
2033 void *ptr;
2034 yy_size_t size;
2035 #endif
2036         {
2037         /* The cast to (char *) in the following accommodates both
2038          * implementations that use char* generic pointers, and those
2039          * that use void* generic pointers.  It works with the latter
2040          * because both ANSI C and C++ allow castless assignment from
2041          * any pointer type to void*, and deal with argument conversions
2042          * as though doing an assignment.
2043          */
2044         return (void *) realloc( (char *) ptr, size );
2045         }
2046
2047 #ifdef YY_USE_PROTOS
2048 static void yy_flex_free( void *ptr )
2049 #else
2050 static void yy_flex_free( ptr )
2051 void *ptr;
2052 #endif
2053         {
2054         free( ptr );
2055         }
2056
2057 #if YY_MAIN
2058 int main()
2059         {
2060         yylex();
2061         return 0;
2062         }
2063 #endif
2064 #line 190 "Lexer.l"
2065