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*64)
 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 102
 312 #define YY_END_OF_BUFFER 103
 313 static yyconst short int yy_acclist[180] =
 314     {   0,
 315       103,  101,  102,  100,  101,  102,  100,  102,  101,  102,
 316       101,  102,  101,  102,  101,  102,  101,  102,  101,  102,
 317        93,  101,  102,   93,  101,  102,    1,  101,  102,  101,
 318       102,  101,  102,  101,  102,  101,  102,  101,  102,  101,
 319       102,  101,  102,  101,  102,  101,  102,  101,  102,  101,
 320       102,  101,  102,  101,  102,  101,  102,  101,  102,  101,
 321       102,  101,  102,  101,  102,  101,  102,  101,  102,  101,
 322       102,   92,   90,   89,   89,   96,   94,   98,   93,    1,
 323        77,   34,   59,   20,   92,   89,   89,   97,   98,   17,
 324        98,   99,   53,   58,   30,   35,   56,    3,   44,   55,
 325
 326        22,   67,   57,   76,   71,   72,   54,   60,   91,   98,
 327        98,   39,   68,   69,   84,   85,   46,   19,   95,   23,
 328         4,   51,   45,   38,   11,   98,   32,    2,    5,   48,
 329        50,   40,   62,   66,   64,   65,   63,   61,   42,   86,
 330        41,   47,   18,   74,   83,   37,   49,   27,   21,   36,
 331         7,   79,   29,   82,   52,   70,   78,   24,   25,   80,
 332        43,   75,   73,    6,   26,   33,    8,   14,    9,   10,
 333        31,   12,   28,   81,   87,   13,   88,   15,   16
 334     } ;
 335
 336 static yyconst short int yy_accept[417] =
 337     {   0,
 338         1,    1,    1,    2,    4,    7,    9,   11,   13,   15,
 339        17,   19,   21,   24,   27,   30,   32,   34,   36,   38,
 340        40,   42,   44,   46,   48,   50,   52,   54,   56,   58,
 341        60,   62,   64,   66,   68,   70,   72,   72,   73,   73,
 342        74,   75,   76,   77,   77,   78,   78,   79,   80,   80,
 343        81,   81,   81,   81,   81,   81,   81,   81,   82,   82,
 344        83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
 345        83,   83,   83,   83,   83,   83,   83,   83,   83,   83,
 346        83,   83,   84,   84,   84,   84,   84,   84,   84,   84,
 347        84,   84,   84,   84,   85,   85,   85,   85,   85,   85,
 348
 349        85,   85,   85,   85,   85,   85,   85,   86,   87,   89,
 350        90,   91,   92,   92,   93,   94,   94,   94,   95,   95,
 351        95,   96,   96,   96,   96,   97,   97,   97,   97,   97,
 352        98,   98,   99,   99,   99,   99,   99,   99,   99,   99,
 353        99,   99,  100,  100,  100,  100,  100,  100,  100,  100,
 354       101,  102,  102,  102,  103,  103,  104,  105,  105,  105,
 355       105,  105,  105,  106,  106,  107,  107,  108,  108,  108,
 356       108,  108,  108,  108,  108,  108,  108,  108,  108,  108,
 357       108,  108,  108,  108,  108,  108,  108,  108,  109,  109,
 358       110,  111,  111,  111,  111,  112,  112,  112,  112,  112,
 359
 360       113,  114,  115,  115,  115,  115,  115,  115,  115,  115,
 361       115,  115,  115,  115,  115,  116,  116,  116,  116,  116,
 362       116,  116,  116,  116,  117,  118,  118,  119,  119,  119,
 363       120,  120,  120,  120,  120,  120,  120,  120,  120,  120,
 364       120,  121,  121,  121,  122,  123,  123,  124,  124,  124,
 365       124,  124,  124,  124,  124,  124,  124,  125,  125,  126,
 366       126,  127,  128,  128,  128,  129,  129,  129,  129,  129,
 367       129,  129,  129,  129,  129,  130,  130,  131,  131,  131,
 368       131,  131,  131,  132,  132,  132,  132,  132,  132,  133,
 369       133,  133,  134,  135,  136,  137,  138,  139,  140,  141,
 370
 371       141,  141,  141,  142,  143,  144,  144,  144,  144,  144,
 372       144,  145,  145,  145,  145,  146,  146,  147,  147,  147,
 373       147,  148,  149,  150,  150,  150,  151,  151,  152,  152,
 374       152,  153,  153,  154,  155,  156,  156,  156,  157,  158,
 375       159,  160,  160,  160,  161,  162,  163,  164,  164,  164,
 376       164,  164,  165,  166,  166,  166,  166,  166,  166,  166,
 377       166,  167,  167,  167,  167,  167,  167,  168,  169,  169,
 378       169,  169,  170,  171,  171,  171,  171,  172,  172,  173,
 379       173,  173,  173,  173,  173,  173,  173,  173,  173,  173,
 380       173,  173,  173,  173,  173,  173,  173,  174,  174,  175,
 381
 382       175,  175,  175,  175,  175,  175,  175,  176,  176,  177,
 383       177,  178,  179,  179,  180,  180
 384     } ;
 385
 386 static yyconst int yy_ec[256] =
 387     {   0,
 388         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
 389         1,    1,    2,    1,    1,    1,    1,    1,    1,    1,
 390         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 391         1,    2,    1,    4,    1,    5,    6,    1,    1,    1,
 392         1,    1,    7,    1,    8,    9,    1,   10,   11,   11,
 393        11,   11,   11,   11,   11,   11,   11,   12,   13,    1,
 394         1,    1,    1,    1,   14,   14,   14,   14,   15,   14,
 395         5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
 396         5,    5,    5,    5,    5,    5,    5,    5,    5,    5,
 397         1,    1,    1,    1,   16,    1,   17,   18,   19,   20,
 398
 399        21,   22,   23,   24,   25,    5,   26,   27,   28,   29,
 400        30,   31,   32,   33,   34,   35,   36,   37,   38,   39,
 401        40,   41,    1,    1,    1,    1,    1,    1,    1,    1,
 402         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 403         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 404         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 405         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 406         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 407         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 408         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 409
 410         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 411         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 412         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 413         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 414         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 415         1,    1,    1,    1,    1
 416     } ;
 417
 418 static yyconst int yy_meta[42] =
 419     {   0,
 420         1,    1,    2,    1,    3,    1,    1,    3,    3,    3,
 421         3,    4,    1,    3,    3,    3,    3,    3,    3,    3,
 422         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
 423         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
 424         3
 425     } ;
 426
 427 static yyconst short int yy_base[421] =
 428     {   0,
 429         0,    0,  872,  873,  873,  873,  867,  858,   34,   36,
 430        38,   42,   46,   50,    0,   51,   54,   53,   56,   61,
 431        76,   77,   79,   80,   82,   83,   84,   90,   31,  111,
 432        94,  140,  113,   55,  110,  116,  865,  873,  856,  873,
 433         0,  128,  131,  144,  150,  124,  160,  167,  172,    0,
 434       136,  139,  168,  100,   41,  145,  114,  855,  173,  183,
 435       184,  185,  161,  187,  189,  191,  193,  133,  194,  196,
 436       200,  202,  205,  206,  209,  217,   89,  210,  213,  216,
 437        57,  854,  207,  224,  223,  227,  229,  233,  243,  235,
 438       238,  242,  247,  853,  249,  250,  251,  259,  245,  267,
 439
 440       265,  266,  272,  281,  274,  278,  852,    0,  291,  293,
 441       851,  305,  311,    0,  850,  241,  282,  849,  312,  284,
 442       848,  298,  301,  294,  847,  315,  318,  319,  320,  846,
 443       322,  324,  327,  329,  325,  326,  339,  332,  333,  345,
 444       331,  343,  330,  353,  354,  355,  356,  358,  357,  845,
 445       844,  359,  360,  843,  365,  842,  841,  385,  363,  366,
 446       361,  396,  840,  376,  839,  377,  838,  379,  385,  399,
 447       401,  403,  406,  381,  408,  409,  414,  416,  418,  417,
 448       419,  424,  421,  425,  367,  435,  422,  837,  428,  873,
 449       440,  449,  452,  454,  457,  441,  459,  460,  461,  836,
 450
 451       835,  834,  462,  463,  465,  467,  464,  468,  471,  472,
 452       476,  474,  475,  484,  833,  485,  487,  488,  489,  491,
 453       494,  495,  496,  832,  831,  498,  830,  499,  501,    0,
 454       503,  502,  514,  506,  508,  518,  519,  520,  525,  522,
 455       829,  530,  532,  828,  827,  533,  826,  535,  538,  536,
 456       540,  537,  544,  550,  551,  552,  825,  553,  824,  555,
 457       558,  823,  558,  559,  822,  566,  564,  560,  572,  561,
 458       574,  575,  577,  580,  821,  582,  820,  583,  584,  585,
 459       586,  588,  819,  590,  593,  604,  596,  600,  818,  595,
 460       606,  817,  816,  815,  814,  813,  812,  811,  810,  608,
 461
 462       610,  612,  809,  808,  807,  614,  615,  616,  617,  619,
 463       806,  618,  623,  625,  805,  626,  804,  627,  634,  628,
 464       803,  802,  801,  646,  631,  800,  632,  799,  638,  652,
 465       798,  649,  797,  796,  795,  645,  653,  794,  793,  792,
 466       791,  655,  659,  790,  789,  786,  777,  658,  661,  660,
 467       662,  776,  774,  663,  667,  672,  665,  664,  675,  669,
 468       772,  683,  687,  680,  686,  690,  771,  770,  693,  694,
 469       695,  769,  767,  697,  698,  696,  765,  699,  764,  705,
 470       700,  715,  703,  704,  706,  719,  722,  707,  716,  725,
 471       727,  728,  729,  731,  730,  733,  762,  736,  760,  735,
 472
 473       741,  742,  743,  747,  749,  750,  759,  751,  752,  757,
 474       635,  504,  754,  432,  873,  790,  792,  382,  796,  380
 475     } ;
 476
 477 static yyconst short int yy_def[421] =
 478     {   0,
 479       415,    1,  415,  415,  415,  415,  416,  417,  418,  415,
 480       417,  417,  417,  417,  419,  417,  417,  417,  417,  417,
 481       417,  417,  417,  417,  417,  417,  417,  417,  417,  417,
 482       417,  417,  417,  417,  417,  417,  416,  415,  417,  415,
 483       420,  420,  415,  415,  417,  417,  417,  417,  417,  419,
 484       417,  417,  417,  417,  417,  417,  417,  417,  417,  417,
 485       417,  417,  417,  417,  417,  417,  417,  417,  417,  417,
 486       417,  417,  417,  417,  417,  417,  417,  417,  417,  417,
 487       417,  417,  417,  417,  417,  417,  417,  417,  417,  417,
 488       417,  417,  417,  417,  417,  417,  417,  417,  417,  417,
 489
 490       417,  417,  417,  417,  417,  417,  415,  420,  420,  415,
 491       417,  417,  417,   49,  417,  417,  417,  417,  417,  417,
 492       417,  417,  417,  417,  417,  417,  417,  417,  417,  417,
 493       417,  417,  417,  417,  417,  417,  417,  417,  417,  417,
 494       417,  417,  417,  417,  417,  417,  417,  417,  417,  417,
 495       417,  417,  417,  417,  417,  417,  417,   49,  417,  417,
 496       417,  417,  417,  417,  417,  417,  417,  417,  417,  417,
 497       417,  417,  417,  417,  417,  417,  417,  417,  417,  417,
 498       417,  417,  417,  417,  417,  417,  417,  417,  417,  415,
 499       415,  415,  415,  417,  417,  417,  417,  417,  417,  417,
 500
 501       417,  417,  417,  417,  417,  417,  417,  417,  417,  417,
 502       417,  417,  417,  417,  417,  417,  417,  417,  417,  417,
 503       417,  417,  417,  417,  417,  417,  417,  417,  417,  158,
 504       417,  417,  417,  417,  417,  417,  417,  417,  417,  417,
 505       417,  417,  417,  417,  417,  417,  417,  417,  417,  417,
 506       417,  417,  417,  417,  417,  417,  417,  417,  417,  417,
 507       415,  417,  417,  417,  417,  417,  417,  417,  417,  417,
 508       417,  417,  417,  417,  417,  417,  417,  417,  417,  417,
 509       417,  417,  417,  417,  417,  417,  417,  417,  417,  417,
 510       417,  417,  417,  417,  417,  417,  417,  417,  417,  417,
 511
 512       417,  417,  417,  417,  417,  417,  417,  417,  417,  417,
 513       417,  417,  417,  417,  417,  417,  417,  417,  417,  417,
 514       417,  417,  417,  417,  417,  417,  417,  417,  417,  417,
 515       417,  417,  417,  417,  417,  417,  417,  417,  417,  417,
 516       417,  417,  417,  417,  417,  417,  417,  417,  417,  417,
 517       417,  417,  417,  417,  417,  417,  417,  417,  417,  417,
 518       417,  417,  417,  417,  417,  417,  417,  417,  417,  417,
 519       417,  417,  417,  417,  417,  417,  417,  417,  417,  417,
 520       417,  417,  417,  417,  417,  417,  417,  417,  417,  417,
 521       417,  417,  417,  417,  417,  417,  417,  417,  417,  417,
 522
 523       417,  417,  417,  417,  417,  417,  417,  417,  417,  417,
 524       417,  417,  417,  417,    0,  415,  415,  415,  415,  415
 525     } ;
 526
 527 static yyconst short int yy_nxt[915] =
 528     {   0,
 529         4,    5,    6,    7,    8,    9,   10,   11,   12,   13,
 530        14,    4,   15,    8,    8,    8,   16,   17,   18,   19,
 531        20,   21,   22,    8,   23,    8,   24,   25,   26,   27,
 532        28,    8,   29,   30,   31,   32,   33,   34,   35,    8,
 533        36,   42,   40,   43,   43,   44,   44,   45,   45,   40,
 534        46,   85,   40,   40,   47,   48,   48,   40,   47,   48,
 535        48,   40,   40,  120,   40,   40,   40,   40,   40,   59,
 536        51,   60,   40,  153,   55,  104,   62,   52,   56,   53,
 537        63,   54,   61,   57,   49,   64,   58,   40,   40,   65,
 538        40,   40,   67,   40,   40,   40,   74,   70,   77,   66,
 539
 540        40,   40,   68,   71,   75,   40,   72,   73,   69,   76,
 541        93,   40,   79,   83,   81,  149,   82,   78,   80,   84,
 542        86,   40,   40,   94,   40,   40,   95,   40,   87,  102,
 543       119,   88,  111,   96,   89,   40,  106,  109,  109,  105,
 544        43,   43,  103,  122,   40,   90,   91,   40,   92,   86,
 545        40,   40,  110,   44,   44,  115,   40,   97,   47,   45,
 546        45,   40,  137,  116,   98,  117,   99,  121,  100,  112,
 547       112,   40,   40,  101,  113,   47,   48,   48,   40,   40,
 548       113,  114,  114,   40,   40,  114,  114,  118,  114,  114,
 549       114,  114,  114,  114,   40,   40,   40,  130,   40,  123,
 550
 551        40,  125,   40,  128,   40,   40,  124,   40,  132,  133,
 552       126,   40,  127,   40,  138,  129,   40,   40,   40,  135,
 553        40,   40,  131,  144,   40,  134,  136,   40,   40,  140,
 554       139,  154,  141,  147,   40,   40,  150,  145,   40,  142,
 555        40,  143,  152,  146,   40,  148,   40,  151,  155,   40,
 556       156,  160,   40,   40,   40,  167,   40,  157,   40,  161,
 557        40,   40,   40,  196,  166,  158,  168,  162,  159,  163,
 558        40,  169,  164,  171,  176,  165,   40,   40,   40,  170,
 559       173,  182,  183,   40,  172,   40,  177,  175,  181,   40,
 560       174,  178,   40,   40,  184,   40,  185,  187,  186,  179,
 561
 562       109,  109,  191,  191,  180,   40,  188,  192,  199,   40,
 563       189,  197,   40,  192,  112,  112,   40,  193,  194,  113,
 564       195,  195,   40,   40,  200,  113,   40,  201,  202,   40,
 565        40,   40,  198,   40,  203,   40,   40,   40,   40,  207,
 566        40,   40,   40,   40,   40,  205,  206,  209,  208,  210,
 567        40,  204,  215,  216,   40,  214,   40,  218,  212,  220,
 568       213,  211,  217,  219,   40,   40,   40,   40,   40,   40,
 569        40,   40,   40,  221,   40,  224,   40,   40,   40,  222,
 570       225,  233,  108,  226,   41,  227,  257,   40,   40,  223,
 571        40,  228,   40,  229,  230,  230,   40,  231,  230,  230,
 572
 573       232,  230,  230,  230,  230,  230,  230,   40,  238,  239,
 574        40,  241,   40,  240,   40,  246,  234,   40,  235,   40,
 575        40,  242,  236,  244,  237,   40,  245,   40,   40,   40,
 576        40,  243,   40,   40,  249,   40,   40,  248,  251,   40,
 577       254,  252,  247,   40,  250,  256,   40,  259,  253,  191,
 578       191,  258,   40,  255,  192,  193,  193,  260,  261,  261,
 579       192,  261,  261,  195,  195,   40,  195,  195,   40,  262,
 580        40,   40,   40,   40,   40,   40,   40,  263,   40,   40,
 581       266,  268,   40,   40,  271,   40,   40,   40,  264,  265,
 582       270,  269,  274,  276,  275,   40,   40,  267,   40,   40,
 583
 584        40,  272,   40,  279,  273,   40,   40,   40,  280,   40,
 585        40,  278,   40,   40,   40,   40,  282,   40,  277,   40,
 586       283,  281,  285,  289,  284,   40,  290,  286,  293,   40,
 587        40,   40,  291,   40,  287,  288,   40,  292,  295,  297,
 588       300,   40,  294,   40,   40,  299,   40,   40,   40,   40,
 589       301,   40,  296,  303,  298,   40,  307,  304,  302,  305,
 590       306,   40,   40,   40,   40,  308,   40,  261,  261,   40,
 591        40,   40,   40,  311,  315,   40,  309,   40,  316,  314,
 592       318,  321,  310,   40,  317,   40,   40,  313,   40,  320,
 593       312,   40,  319,   40,   40,   40,   40,   40,  325,   40,
 594
 595       326,   40,  322,  327,   40,  324,   40,   40,  331,  323,
 596       328,   40,  329,  333,  330,   40,  335,   40,  332,   40,
 597       336,   40,  334,   40,  337,   40,   40,   40,   40,   40,
 598        40,  339,  341,  343,   40,  344,   40,   40,   40,   40,
 599       338,  346,   40,   40,  340,   40,   40,  348,  342,   40,
 600       350,  345,  347,  349,  352,  351,   40,   40,  357,  356,
 601        40,  353,  354,   40,   40,  355,   40,  359,  358,   40,
 602        40,   40,   40,   40,   40,   40,   40,  360,   40,  362,
 603        40,  361,  363,   40,  364,  365,   40,  369,  366,  368,
 604       372,   40,  370,  371,   40,  373,  367,   40,   40,  375,
 605
 606       377,   40,  374,  376,   40,   40,   40,   40,   40,   40,
 607        40,   40,  379,  385,   40,   40,   40,   40,   40,  380,
 608       378,  383,  381,  386,  384,  387,   40,   40,  391,  382,
 609        40,  389,  392,   40,  388,  393,   40,  395,   40,   40,
 610        40,   40,   40,  390,   40,  397,   40,   40,  399,  394,
 611       396,  401,   40,   40,   40,  400,  404,  403,   40,  405,
 612        40,   40,   40,   40,  402,   40,  409,  398,   40,  406,
 613        40,   40,  408,   40,  407,   40,   40,  413,   40,  412,
 614        40,   40,   40,   40,  411,   40,  414,   40,   40,  410,
 615        37,   37,   37,   37,   39,   39,   50,   40,   50,   50,
 616
 617        40,   40,   40,   40,   40,   40,   40,   40,   40,   40,
 618        40,   40,   40,   40,   40,   40,   40,   40,   40,   40,
 619        40,   40,   40,   40,   40,   40,   40,   40,   40,   40,
 620        40,   40,   40,   40,   40,   40,   40,   40,   40,   40,
 621        40,   40,   40,   40,   40,   40,   40,   40,   40,   40,
 622        40,   40,   40,   40,   40,   40,   40,   40,   40,   40,
 623        40,   40,   40,  190,   40,   40,   40,   40,  107,   40,
 624        38,  415,    3,  415,  415,  415,  415,  415,  415,  415,
 625       415,  415,  415,  415,  415,  415,  415,  415,  415,  415,
 626       415,  415,  415,  415,  415,  415,  415,  415,  415,  415,
 627
 628       415,  415,  415,  415,  415,  415,  415,  415,  415,  415,
 629       415,  415,  415,  415
 630     } ;
 631
 632 static yyconst short int yy_chk[915] =
 633     {   0,
 634         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 635         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 636         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 637         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
 638         1,    9,   29,    9,    9,   10,   10,   11,   11,   11,
 639        12,   29,   55,   12,   13,   13,   13,   13,   14,   14,
 640        14,   14,   16,   55,   18,   17,   34,   19,   81,   18,
 641        16,   18,   20,   81,   17,   34,   19,   16,   17,   16,
 642        19,   16,   18,   17,   13,   19,   17,   21,   22,   20,
 643        23,   24,   21,   25,   26,   27,   24,   22,   25,   20,
 644
 645        77,   28,   21,   22,   24,   31,   23,   23,   21,   24,
 646        31,   54,   26,   28,   27,   77,   27,   25,   26,   28,
 647        30,   35,   30,   31,   33,   57,   31,   36,   30,   33,
 648        54,   30,   46,   31,   30,   46,   36,   42,   42,   35,
 649        43,   43,   33,   57,   68,   30,   30,   51,   30,   32,
 650        52,   32,   44,   44,   44,   51,   56,   32,   45,   45,
 651        45,   45,   68,   52,   32,   52,   32,   56,   32,   47,
 652        47,   47,   63,   32,   47,   48,   48,   48,   48,   53,
 653        47,   49,   49,   49,   59,   49,   49,   53,   49,   49,
 654        49,   49,   49,   49,   60,   61,   62,   63,   64,   59,
 655
 656        65,   60,   66,   62,   67,   69,   59,   70,   65,   66,
 657        61,   71,   61,   72,   69,   62,   73,   74,   83,   67,
 658        75,   78,   64,   74,   79,   66,   67,   80,   76,   71,
 659        70,   83,   72,   76,   85,   84,   78,   75,   86,   73,
 660        87,   73,   80,   75,   88,   76,   90,   79,   84,   91,
 661        85,   88,  116,   92,   89,   91,   99,   85,   93,   88,
 662        95,   96,   97,  116,   90,   86,   92,   88,   87,   89,
 663        98,   93,   89,   95,   99,   89,  101,  102,  100,   93,
 664        96,  102,  102,  103,   95,  105,  100,   98,  101,  106,
 665        97,  100,  104,  117,  102,  120,  103,  104,  103,  100,
 666
 667       109,  109,  110,  110,  100,  124,  105,  110,  120,  122,
 668       106,  117,  123,  110,  112,  112,  112,  113,  113,  112,
 669       113,  113,  113,  119,  122,  112,  126,  123,  124,  127,
 670       128,  129,  119,  131,  126,  132,  135,  136,  133,  131,
 671       134,  143,  141,  138,  139,  128,  129,  133,  132,  134,
 672       137,  127,  138,  139,  142,  137,  140,  141,  135,  143,
 673       136,  134,  140,  142,  144,  145,  146,  147,  149,  148,
 674       152,  153,  161,  144,  159,  147,  155,  160,  185,  145,
 675       148,  161,  420,  149,  418,  152,  185,  164,  166,  146,
 676       168,  153,  174,  155,  158,  158,  169,  159,  158,  158,
 677
 678       160,  158,  158,  158,  158,  158,  158,  162,  164,  166,
 679       170,  169,  171,  168,  172,  174,  162,  173,  162,  175,
 680       176,  170,  162,  172,  162,  177,  173,  178,  180,  179,
 681       181,  171,  183,  187,  177,  182,  184,  176,  179,  189,
 682       182,  180,  175,  414,  178,  184,  186,  187,  181,  191,
 683       191,  186,  196,  183,  191,  192,  192,  189,  192,  192,
 684       191,  193,  193,  194,  194,  194,  195,  195,  195,  196,
 685       197,  198,  199,  203,  204,  207,  205,  197,  206,  208,
 686       203,  205,  209,  210,  208,  212,  213,  211,  198,  199,
 687       207,  206,  211,  213,  212,  214,  216,  204,  217,  218,
 688
 689       219,  209,  220,  217,  210,  221,  222,  223,  218,  226,
 690       228,  216,  229,  232,  231,  412,  220,  234,  214,  235,
 691       221,  219,  223,  231,  222,  233,  232,  226,  235,  236,
 692       237,  238,  233,  240,  228,  229,  239,  234,  236,  237,
 693       240,  242,  235,  243,  246,  239,  248,  250,  252,  249,
 694       242,  251,  236,  246,  238,  253,  251,  248,  243,  249,
 695       250,  254,  255,  256,  258,  252,  260,  261,  261,  263,
 696       264,  268,  270,  255,  263,  267,  253,  266,  264,  260,
 697       267,  270,  254,  269,  266,  271,  272,  258,  273,  269,
 698       256,  274,  268,  276,  278,  279,  280,  281,  274,  282,
 699
 700       276,  284,  271,  278,  285,  273,  290,  287,  282,  272,
 701       279,  288,  280,  285,  281,  286,  287,  291,  284,  300,
 702       288,  301,  286,  302,  290,  306,  307,  308,  309,  312,
 703       310,  300,  302,  307,  313,  308,  314,  316,  318,  320,
 704       291,  310,  325,  327,  301,  319,  411,  313,  306,  329,
 705       316,  309,  312,  314,  319,  318,  336,  324,  329,  327,
 706       332,  320,  324,  330,  337,  325,  342,  332,  330,  348,
 707       343,  350,  349,  351,  354,  358,  357,  336,  355,  342,
 708       360,  337,  343,  356,  348,  349,  359,  355,  350,  354,
 709       358,  364,  356,  357,  362,  359,  351,  365,  363,  362,
 710
 711       364,  366,  360,  363,  369,  370,  371,  376,  374,  375,
 712       378,  381,  366,  376,  383,  384,  380,  385,  388,  369,
 713       365,  374,  370,  378,  375,  380,  382,  389,  384,  371,
 714       386,  382,  385,  387,  381,  386,  390,  388,  391,  392,
 715       393,  395,  394,  383,  396,  390,  400,  398,  392,  387,
 716       389,  394,  401,  402,  403,  393,  398,  396,  404,  400,
 717       405,  406,  408,  409,  395,  413,  404,  391,  410,  401,
 718       407,  399,  403,  397,  402,  379,  377,  410,  373,  408,
 719       372,  368,  367,  361,  406,  353,  413,  352,  347,  405,
 720       416,  416,  416,  416,  417,  417,  419,  346,  419,  419,
 721
 722       345,  344,  341,  340,  339,  338,  335,  334,  333,  331,
 723       328,  326,  323,  322,  321,  317,  315,  311,  305,  304,
 724       303,  299,  298,  297,  296,  295,  294,  293,  292,  289,
 725       283,  277,  275,  265,  262,  259,  257,  247,  245,  244,
 726       241,  227,  225,  224,  215,  202,  201,  200,  188,  167,
 727       165,  163,  157,  156,  154,  151,  150,  130,  125,  121,
 728       118,  115,  111,  107,   94,   82,   58,   39,   37,    8,
 729         7,    3,  415,  415,  415,  415,  415,  415,  415,  415,
 730       415,  415,  415,  415,  415,  415,  415,  415,  415,  415,
 731       415,  415,  415,  415,  415,  415,  415,  415,  415,  415,
 732
 733       415,  415,  415,  415,  415,  415,  415,  415,  415,  415,
 734       415,  415,  415,  415
 735     } ;
 736
 737 static yy_state_type yy_state_buf[YY_BUF_SIZE + 2], *yy_state_ptr;
 738 static char *yy_full_match;
 739 static int yy_lp;
 740 #define REJECT \
 741 { \
 742 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */ \
 743 yy_cp = yy_full_match; /* restore poss. backed-over text */ \
 744 ++yy_lp; \
 745 goto find_rule; \
 746 }
 747 #define yymore() yymore_used_but_not_detected
 748 #define YY_MORE_ADJ 0
 749 #define YY_RESTORE_YY_MORE_OFFSET
 750 char *yytext;
 751 #line 1 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
 752 #define INITIAL 0
 753 /*===-- Lexer.l - Scanner for llvm assembly files --------------*- C++ -*--===//
 754 //
 755 //                     The LLVM Compiler Infrastructure
 756 //
 757 // This file was developed by the LLVM research group and is distributed under
 758 // the University of Illinois Open Source License. See LICENSE.TXT for details.
 759 //
 760 //===----------------------------------------------------------------------===//
 761 //
 762 //  This file implements the flex scanner for LLVM assembly languages files.
 763 //
 764 //===----------------------------------------------------------------------===*/
 765 #define YY_NEVER_INTERACTIVE 1
 766 #line 28 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
 767 #include "ParserInternals.h"
 768 #include "llvm/Module.h"
 769 #include <list>
 770 #include "llvmAsmParser.h"
 771 #include <cctype>
 772 #include <cstdlib>
 773
 774 void set_scan_file(FILE * F){
 775   yy_switch_to_buffer(yy_create_buffer( F, YY_BUF_SIZE ) );
 776 }
 777 void set_scan_string (const char * str) {
 778   yy_scan_string (str);
 779 }
 780
 781 #define RET_TOK(type, Enum, sym) \
 782   llvmAsmlval.type = Instruction::Enum; return sym
 783
 784 namespace llvm {
 785
 786 // TODO: All of the static identifiers are figured out by the lexer,
 787 // these should be hashed to reduce the lexer size
 788
 789
 790 // atoull - Convert an ascii string of decimal digits into the unsigned long
 791 // long representation... this does not have to do input error checking,
 792 // because we know that the input will be matched by a suitable regex...
 793 //
 794 static uint64_t atoull(const char *Buffer) {
 795   uint64_t Result = 0;
 796   for (; *Buffer; Buffer++) {
 797     uint64_t OldRes = Result;
 798     Result *= 10;
 799     Result += *Buffer-'0';
 800     if (Result < OldRes)   // Uh, oh, overflow detected!!!
 801       ThrowException("constant bigger than 64 bits detected!");
 802   }
 803   return Result;
 804 }
 805
 806 static uint64_t HexIntToVal(const char *Buffer) {
 807   uint64_t Result = 0;
 808   for (; *Buffer; ++Buffer) {
 809     uint64_t OldRes = Result;
 810     Result *= 16;
 811     char C = *Buffer;
 812     if (C >= '0' && C <= '9')
 813       Result += C-'0';
 814     else if (C >= 'A' && C <= 'F')
 815       Result += C-'A'+10;
 816     else if (C >= 'a' && C <= 'f')
 817       Result += C-'a'+10;
 818
 819     if (Result < OldRes)   // Uh, oh, overflow detected!!!
 820       ThrowException("constant bigger than 64 bits detected!");
 821   }
 822   return Result;
 823 }
 824
 825
 826 // HexToFP - Convert the ascii string in hexidecimal format to the floating
 827 // point representation of it.
 828 //
 829 static double HexToFP(const char *Buffer) {
 830   // Behave nicely in the face of C TBAA rules... see:
 831   // http://www.nullstone.com/htmls/category/aliastyp.htm
 832   union {
 833     uint64_t UI;
 834     double FP;
 835   } UIntToFP;
 836   UIntToFP.UI = HexIntToVal(Buffer);
 837
 838   assert(sizeof(double) == sizeof(uint64_t) &&
 839          "Data sizes incompatible on this target!");
 840   return UIntToFP.FP;   // Cast Hex constant to double
 841 }
 842
 843
 844 // UnEscapeLexed - Run through the specified buffer and change \xx codes to the
 845 // appropriate character.  If AllowNull is set to false, a \00 value will cause
 846 // an exception to be thrown.
 847 //
 848 // If AllowNull is set to true, the return value of the function points to the
 849 // last character of the string in memory.
 850 //
 851 char *UnEscapeLexed(char *Buffer, bool AllowNull) {
 852   char *BOut = Buffer;
 853   for (char *BIn = Buffer; *BIn; ) {
 854     if (BIn[0] == '\\' && isxdigit(BIn[1]) && isxdigit(BIn[2])) {
 855       char Tmp = BIn[3]; BIn[3] = 0;     // Terminate string
 856       *BOut = (char)strtol(BIn+1, 0, 16);  // Convert to number
 857       if (!AllowNull && !*BOut)
 858         ThrowException("String literal cannot accept \\00 escape!");
 859
 860       BIn[3] = Tmp;                  // Restore character
 861       BIn += 3;                      // Skip over handled chars
 862       ++BOut;
 863     } else {
 864       *BOut++ = *BIn++;
 865     }
 866   }
 867
 868   return BOut;
 869 }
 870
 871 } // End llvm namespace
 872
 873 using namespace llvm;
 874
 875 #define YY_NEVER_INTERACTIVE 1
 876 /* Comments start with a ; and go till end of line */
 877 /* Variable(Value) identifiers start with a % sign */
 878 /* Label identifiers end with a colon */
 879 /* Quoted names can contain any character except " and \ */
 880 /* [PN]Integer: match positive and negative literal integer values that
 881  * are preceeded by a '%' character.  These represent unnamed variable slots.
 882  */
 883 /* E[PN]Integer: match positive and negative literal integer values */
 884 /* FPConstant - A Floating point constant.
 885  */
 886 /* HexFPConstant - Floating point constant represented in IEEE format as a
 887  *  hexadecimal number for when exponential notation is not precise enough.
 888  */
 889 /* HexIntConstant - Hexadecimal constant generated by the CFE to avoid forcing
 890  * it to deal with 64 bit numbers.
 891  */
 892 #line 893 "Lexer.cpp"
 893
 894 /* Macros after this point can all be overridden by user definitions in
 895  * section 1.
 896  */
 897
 898 #ifndef YY_SKIP_YYWRAP
 899 #ifdef __cplusplus
 900 extern "C" int yywrap YY_PROTO(( void ));
 901 #else
 902 extern int yywrap YY_PROTO(( void ));
 903 #endif
 904 #endif
 905
 906 #ifndef YY_NO_UNPUT
 907 static inline void yyunput YY_PROTO(( int c, char *buf_ptr ));
 908 #endif
 909
 910 #ifndef yytext_ptr
 911 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
 912 #endif
 913
 914 #ifdef YY_NEED_STRLEN
 915 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
 916 #endif
 917
 918 #ifndef YY_NO_INPUT
 919 #ifdef __cplusplus
 920 static int yyinput YY_PROTO(( void ));
 921 #else
 922 static int input YY_PROTO(( void ));
 923 #endif
 924 #endif
 925
 926 #if YY_STACK_USED
 927 static int yy_start_stack_ptr = 0;
 928 static int yy_start_stack_depth = 0;
 929 static int *yy_start_stack = 0;
 930 #ifndef YY_NO_PUSH_STATE
 931 static void yy_push_state YY_PROTO(( int new_state ));
 932 #endif
 933 #ifndef YY_NO_POP_STATE
 934 static void yy_pop_state YY_PROTO(( void ));
 935 #endif
 936 #ifndef YY_NO_TOP_STATE
 937 static int yy_top_state YY_PROTO(( void ));
 938 #endif
 939
 940 #else
 941 #define YY_NO_PUSH_STATE 1
 942 #define YY_NO_POP_STATE 1
 943 #define YY_NO_TOP_STATE 1
 944 #endif
 945
 946 #ifdef YY_MALLOC_DECL
 947 YY_MALLOC_DECL
 948 #else
 949 #if __STDC__
 950 #ifndef __cplusplus
 951 #include <stdlib.h>
 952 #endif
 953 #else
 954 /* Just try to get by without declaring the routines.  This will fail
 955  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
 956  * or sizeof(void*) != sizeof(int).
 957  */
 958 #endif
 959 #endif
 960
 961 /* Amount of stuff to slurp up with each read. */
 962 #ifndef YY_READ_BUF_SIZE
 963 #define YY_READ_BUF_SIZE 8192
 964 #endif
 965
 966 /* Copy whatever the last rule matched to the standard output. */
 967
 968 #ifndef ECHO
 969 /* This used to be an fputs(), but since the string might contain NUL's,
 970  * we now use fwrite().
 971  */
 972 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
 973 #endif
 974
 975 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
 976  * is returned in "result".
 977  */
 978 #ifndef YY_INPUT
 979 #define YY_INPUT(buf,result,max_size) \
 980         if ( yy_current_buffer->yy_is_interactive ) \
 981                 { \
 982                 int c = '*', n; \
 983                 for ( n = 0; n < max_size && \
 984                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
 985                         buf[n] = (char) c; \
 986                 if ( c == '\n' ) \
 987                         buf[n++] = (char) c; \
 988                 if ( c == EOF && ferror( yyin ) ) \
 989                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
 990                 result = n; \
 991                 } \
 992         else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
 993                   && ferror( yyin ) ) \
 994                 YY_FATAL_ERROR( "input in flex scanner failed" );
 995 #endif
 996
 997 /* No semi-colon after return; correct usage is to write "yyterminate();" -
 998  * we don't want an extra ';' after the "return" because that will cause
 999  * some compilers to complain about unreachable statements.
1000  */
1001 #ifndef yyterminate
1002 #define yyterminate() return YY_NULL
1003 #endif
1004
1005 /* Number of entries by which start-condition stack grows. */
1006 #ifndef YY_START_STACK_INCR
1007 #define YY_START_STACK_INCR 25
1008 #endif
1009
1010 /* Report a fatal error. */
1011 #ifndef YY_FATAL_ERROR
1012 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
1013 #endif
1014
1015 /* Default declaration of generated scanner - a define so the user can
1016  * easily add parameters.
1017  */
1018 #ifndef YY_DECL
1019 #define YY_DECL int yylex YY_PROTO(( void ))
1020 #endif
1021
1022 /* Code executed at the beginning of each rule, after yytext and yyleng
1023  * have been set up.
1024  */
1025 #ifndef YY_USER_ACTION
1026 #define YY_USER_ACTION
1027 #endif
1028
1029 /* Code executed at the end of each rule. */
1030 #ifndef YY_BREAK
1031 #define YY_BREAK break;
1032 #endif
1033
1034 #define YY_RULE_SETUP \
1035         YY_USER_ACTION
1036
1037 YY_DECL
1038         {
1039         register yy_state_type yy_current_state;
1040         register char *yy_cp, *yy_bp;
1041         register int yy_act;
1042
1043 #line 179 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1044
1045
1046 #line 1047 "Lexer.cpp"
1047
1048         if ( yy_init )
1049                 {
1050                 yy_init = 0;
1051
1052 #ifdef YY_USER_INIT
1053                 YY_USER_INIT;
1054 #endif
1055
1056                 if ( ! yy_start )
1057                         yy_start = 1;   /* first start state */
1058
1059                 if ( ! yyin )
1060                         yyin = stdin;
1061
1062                 if ( ! yyout )
1063                         yyout = stdout;
1064
1065                 if ( ! yy_current_buffer )
1066                         yy_current_buffer =
1067                                 yy_create_buffer( yyin, YY_BUF_SIZE );
1068
1069                 yy_load_buffer_state();
1070                 }
1071
1072         while ( 1 )             /* loops until end-of-file is reached */
1073                 {
1074                 yy_cp = yy_c_buf_p;
1075
1076                 /* Support of yytext. */
1077                 *yy_cp = yy_hold_char;
1078
1079                 /* yy_bp points to the position in yy_ch_buf of the start of
1080                  * the current run.
1081                  */
1082                 yy_bp = yy_cp;
1083
1084                 yy_current_state = yy_start;
1085                 yy_state_ptr = yy_state_buf;
1086                 *yy_state_ptr++ = yy_current_state;
1087 yy_match:
1088                 do
1089                         {
1090                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
1091                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1092                                 {
1093                                 yy_current_state = (int) yy_def[yy_current_state];
1094                                 if ( yy_current_state >= 416 )
1095                                         yy_c = yy_meta[(unsigned int) yy_c];
1096                                 }
1097                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1098                         *yy_state_ptr++ = yy_current_state;
1099                         ++yy_cp;
1100                         }
1101                 while ( yy_current_state != 415 );
1102
1103 yy_find_action:
1104                 yy_current_state = *--yy_state_ptr;
1105                 yy_lp = yy_accept[yy_current_state];
1106 find_rule: /* we branch to this label when backing up */
1107                 for ( ; ; ) /* until we find what rule we matched */
1108                         {
1109                         if ( yy_lp && yy_lp < yy_accept[yy_current_state + 1] )
1110                                 {
1111                                 yy_act = yy_acclist[yy_lp];
1112                                         {
1113                                         yy_full_match = yy_cp;
1114                                         break;
1115                                         }
1116                                 }
1117                         --yy_cp;
1118                         yy_current_state = *--yy_state_ptr;
1119                         yy_lp = yy_accept[yy_current_state];
1120                         }
1121
1122                 YY_DO_BEFORE_ACTION;
1123
1124                 if ( yy_act != YY_END_OF_BUFFER )
1125                         {
1126                         int yyl;
1127                         for ( yyl = 0; yyl < yyleng; ++yyl )
1128                                 if ( yytext[yyl] == '\n' )
1129                                         ++yylineno;
1130                         }
1131
1132 do_action:      /* This label is used only to access EOF actions. */
1133
1134
1135                 switch ( yy_act )
1136         { /* beginning of action switch */
1137 case 1:
1138 YY_RULE_SETUP
1139 #line 181 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1140 { /* Ignore comments for now */ }
1141         YY_BREAK
1142 case 2:
1143 YY_RULE_SETUP
1144 #line 183 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1145 { return BEGINTOK; }
1146         YY_BREAK
1147 case 3:
1148 YY_RULE_SETUP
1149 #line 184 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1150 { return ENDTOK; }
1151         YY_BREAK
1152 case 4:
1153 YY_RULE_SETUP
1154 #line 185 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1155 { return TRUETOK;  }
1156         YY_BREAK
1157 case 5:
1158 YY_RULE_SETUP
1159 #line 186 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1160 { return FALSETOK; }
1161         YY_BREAK
1162 case 6:
1163 YY_RULE_SETUP
1164 #line 187 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1165 { return DECLARE; }
1166         YY_BREAK
1167 case 7:
1168 YY_RULE_SETUP
1169 #line 188 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1170 { return GLOBAL; }
1171         YY_BREAK
1172 case 8:
1173 YY_RULE_SETUP
1174 #line 189 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1175 { return CONSTANT; }
1176         YY_BREAK
1177 case 9:
1178 YY_RULE_SETUP
1179 #line 190 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1180 { return INTERNAL; }
1181         YY_BREAK
1182 case 10:
1183 YY_RULE_SETUP
1184 #line 191 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1185 { return LINKONCE; }
1186         YY_BREAK
1187 case 11:
1188 YY_RULE_SETUP
1189 #line 192 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1190 { return WEAK; }
1191         YY_BREAK
1192 case 12:
1193 YY_RULE_SETUP
1194 #line 193 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1195 { return APPENDING; }
1196         YY_BREAK
1197 case 13:
1198 YY_RULE_SETUP
1199 #line 194 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1200 { return EXTERNAL; }    /* Deprecated, turn into external */
1201         YY_BREAK
1202 case 14:
1203 YY_RULE_SETUP
1204 #line 195 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1205 { return EXTERNAL; }
1206         YY_BREAK
1207 case 15:
1208 YY_RULE_SETUP
1209 #line 196 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1210 { return IMPLEMENTATION; }
1211         YY_BREAK
1212 case 16:
1213 YY_RULE_SETUP
1214 #line 197 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1215 { return ZEROINITIALIZER; }
1216         YY_BREAK
1217 case 17:
1218 YY_RULE_SETUP
1219 #line 198 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1220 { return DOTDOTDOT; }
1221         YY_BREAK
1222 case 18:
1223 YY_RULE_SETUP
1224 #line 199 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1225 { return UNDEF; }
1226         YY_BREAK
1227 case 19:
1228 YY_RULE_SETUP
1229 #line 200 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1230 { return NULL_TOK; }
1231         YY_BREAK
1232 case 20:
1233 YY_RULE_SETUP
1234 #line 201 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1235 { return TO; }
1236         YY_BREAK
1237 case 21:
1238 YY_RULE_SETUP
1239 #line 202 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1240 { RET_TOK(TermOpVal, Unwind, UNWIND); }
1241         YY_BREAK
1242 case 22:
1243 YY_RULE_SETUP
1244 #line 203 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1245 { return NOT; }  /* Deprecated, turned into XOR */
1246         YY_BREAK
1247 case 23:
1248 YY_RULE_SETUP
1249 #line 204 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1250 { return TAIL; }
1251         YY_BREAK
1252 case 24:
1253 YY_RULE_SETUP
1254 #line 205 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1255 { return TARGET; }
1256         YY_BREAK
1257 case 25:
1258 YY_RULE_SETUP
1259 #line 206 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1260 { return TRIPLE; }
1261         YY_BREAK
1262 case 26:
1263 YY_RULE_SETUP
1264 #line 207 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1265 { return DEPLIBS; }
1266         YY_BREAK
1267 case 27:
1268 YY_RULE_SETUP
1269 #line 208 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1270 { return ENDIAN; }
1271         YY_BREAK
1272 case 28:
1273 YY_RULE_SETUP
1274 #line 209 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1275 { return POINTERSIZE; }
1276         YY_BREAK
1277 case 29:
1278 YY_RULE_SETUP
1279 #line 210 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1280 { return LITTLE; }
1281         YY_BREAK
1282 case 30:
1283 YY_RULE_SETUP
1284 #line 211 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1285 { return BIG; }
1286         YY_BREAK
1287 case 31:
1288 YY_RULE_SETUP
1289 #line 212 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1290 { return VOLATILE; }
1291         YY_BREAK
1292 case 32:
1293 YY_RULE_SETUP
1294 #line 213 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1295 { return ALIGN;  }
1296         YY_BREAK
1297 case 33:
1298 YY_RULE_SETUP
1299 #line 214 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1300 { return SECTION; }
1301         YY_BREAK
1302 case 34:
1303 YY_RULE_SETUP
1304 #line 216 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1305 { return CC_TOK; }
1306         YY_BREAK
1307 case 35:
1308 YY_RULE_SETUP
1309 #line 217 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1310 { return CCC_TOK; }
1311         YY_BREAK
1312 case 36:
1313 YY_RULE_SETUP
1314 #line 218 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1315 { return FASTCC_TOK; }
1316         YY_BREAK
1317 case 37:
1318 YY_RULE_SETUP
1319 #line 219 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1320 { return COLDCC_TOK; }
1321         YY_BREAK
1322 case 38:
1323 YY_RULE_SETUP
1324 #line 221 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1325 { llvmAsmlval.PrimType = Type::VoidTy  ; return VOID;   }
1326         YY_BREAK
1327 case 39:
1328 YY_RULE_SETUP
1329 #line 222 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1330 { llvmAsmlval.PrimType = Type::BoolTy  ; return BOOL;   }
1331         YY_BREAK
1332 case 40:
1333 YY_RULE_SETUP
1334 #line 223 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1335 { llvmAsmlval.PrimType = Type::SByteTy ; return SBYTE;  }
1336         YY_BREAK
1337 case 41:
1338 YY_RULE_SETUP
1339 #line 224 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1340 { llvmAsmlval.PrimType = Type::UByteTy ; return UBYTE;  }
1341         YY_BREAK
1342 case 42:
1343 YY_RULE_SETUP
1344 #line 225 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1345 { llvmAsmlval.PrimType = Type::ShortTy ; return SHORT;  }
1346         YY_BREAK
1347 case 43:
1348 YY_RULE_SETUP
1349 #line 226 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1350 { llvmAsmlval.PrimType = Type::UShortTy; return USHORT; }
1351         YY_BREAK
1352 case 44:
1353 YY_RULE_SETUP
1354 #line 227 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1355 { llvmAsmlval.PrimType = Type::IntTy   ; return INT;    }
1356         YY_BREAK
1357 case 45:
1358 YY_RULE_SETUP
1359 #line 228 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1360 { llvmAsmlval.PrimType = Type::UIntTy  ; return UINT;   }
1361         YY_BREAK
1362 case 46:
1363 YY_RULE_SETUP
1364 #line 229 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1365 { llvmAsmlval.PrimType = Type::LongTy  ; return LONG;   }
1366         YY_BREAK
1367 case 47:
1368 YY_RULE_SETUP
1369 #line 230 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1370 { llvmAsmlval.PrimType = Type::ULongTy ; return ULONG;  }
1371         YY_BREAK
1372 case 48:
1373 YY_RULE_SETUP
1374 #line 231 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1375 { llvmAsmlval.PrimType = Type::FloatTy ; return FLOAT;  }
1376         YY_BREAK
1377 case 49:
1378 YY_RULE_SETUP
1379 #line 232 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1380 { llvmAsmlval.PrimType = Type::DoubleTy; return DOUBLE; }
1381         YY_BREAK
1382 case 50:
1383 YY_RULE_SETUP
1384 #line 233 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1385 { llvmAsmlval.PrimType = Type::LabelTy ; return LABEL;  }
1386         YY_BREAK
1387 case 51:
1388 YY_RULE_SETUP
1389 #line 234 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1390 { return TYPE;   }
1391         YY_BREAK
1392 case 52:
1393 YY_RULE_SETUP
1394 #line 235 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1395 { return OPAQUE; }
1396         YY_BREAK
1397 case 53:
1398 YY_RULE_SETUP
1399 #line 237 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1400 { RET_TOK(BinaryOpVal, Add, ADD); }
1401         YY_BREAK
1402 case 54:
1403 YY_RULE_SETUP
1404 #line 238 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1405 { RET_TOK(BinaryOpVal, Sub, SUB); }
1406         YY_BREAK
1407 case 55:
1408 YY_RULE_SETUP
1409 #line 239 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1410 { RET_TOK(BinaryOpVal, Mul, MUL); }
1411         YY_BREAK
1412 case 56:
1413 YY_RULE_SETUP
1414 #line 240 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1415 { RET_TOK(BinaryOpVal, Div, DIV); }
1416         YY_BREAK
1417 case 57:
1418 YY_RULE_SETUP
1419 #line 241 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1420 { RET_TOK(BinaryOpVal, Rem, REM); }
1421         YY_BREAK
1422 case 58:
1423 YY_RULE_SETUP
1424 #line 242 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1425 { RET_TOK(BinaryOpVal, And, AND); }
1426         YY_BREAK
1427 case 59:
1428 YY_RULE_SETUP
1429 #line 243 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1430 { RET_TOK(BinaryOpVal, Or , OR ); }
1431         YY_BREAK
1432 case 60:
1433 YY_RULE_SETUP
1434 #line 244 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1435 { RET_TOK(BinaryOpVal, Xor, XOR); }
1436         YY_BREAK
1437 case 61:
1438 YY_RULE_SETUP
1439 #line 245 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1440 { RET_TOK(BinaryOpVal, SetNE, SETNE); }
1441         YY_BREAK
1442 case 62:
1443 YY_RULE_SETUP
1444 #line 246 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1445 { RET_TOK(BinaryOpVal, SetEQ, SETEQ); }
1446         YY_BREAK
1447 case 63:
1448 YY_RULE_SETUP
1449 #line 247 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1450 { RET_TOK(BinaryOpVal, SetLT, SETLT); }
1451         YY_BREAK
1452 case 64:
1453 YY_RULE_SETUP
1454 #line 248 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1455 { RET_TOK(BinaryOpVal, SetGT, SETGT); }
1456         YY_BREAK
1457 case 65:
1458 YY_RULE_SETUP
1459 #line 249 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1460 { RET_TOK(BinaryOpVal, SetLE, SETLE); }
1461         YY_BREAK
1462 case 66:
1463 YY_RULE_SETUP
1464 #line 250 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1465 { RET_TOK(BinaryOpVal, SetGE, SETGE); }
1466         YY_BREAK
1467 case 67:
1468 YY_RULE_SETUP
1469 #line 252 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1470 { RET_TOK(OtherOpVal, PHI, PHI_TOK); }
1471         YY_BREAK
1472 case 68:
1473 YY_RULE_SETUP
1474 #line 253 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1475 { RET_TOK(OtherOpVal, Call, CALL); }
1476         YY_BREAK
1477 case 69:
1478 YY_RULE_SETUP
1479 #line 254 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1480 { RET_TOK(OtherOpVal, Cast, CAST); }
1481         YY_BREAK
1482 case 70:
1483 YY_RULE_SETUP
1484 #line 255 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1485 { RET_TOK(OtherOpVal, Select, SELECT); }
1486         YY_BREAK
1487 case 71:
1488 YY_RULE_SETUP
1489 #line 256 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1490 { RET_TOK(OtherOpVal, Shl, SHL); }
1491         YY_BREAK
1492 case 72:
1493 YY_RULE_SETUP
1494 #line 257 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1495 { RET_TOK(OtherOpVal, Shr, SHR); }
1496         YY_BREAK
1497 case 73:
1498 YY_RULE_SETUP
1499 #line 258 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1500 { return VANEXT_old; }
1501         YY_BREAK
1502 case 74:
1503 YY_RULE_SETUP
1504 #line 259 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1505 { return VAARG_old; }
1506         YY_BREAK
1507 case 75:
1508 YY_RULE_SETUP
1509 #line 260 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1510 { RET_TOK(OtherOpVal, VAArg , VAARG); }
1511         YY_BREAK
1512 case 76:
1513 YY_RULE_SETUP
1514 #line 261 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1515 { RET_TOK(TermOpVal, Ret, RET); }
1516         YY_BREAK
1517 case 77:
1518 YY_RULE_SETUP
1519 #line 262 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1520 { RET_TOK(TermOpVal, Br, BR); }
1521         YY_BREAK
1522 case 78:
1523 YY_RULE_SETUP
1524 #line 263 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1525 { RET_TOK(TermOpVal, Switch, SWITCH); }
1526         YY_BREAK
1527 case 79:
1528 YY_RULE_SETUP
1529 #line 264 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1530 { RET_TOK(TermOpVal, Invoke, INVOKE); }
1531         YY_BREAK
1532 case 80:
1533 YY_RULE_SETUP
1534 #line 265 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1535 { RET_TOK(TermOpVal, Unwind, UNWIND); }
1536         YY_BREAK
1537 case 81:
1538 YY_RULE_SETUP
1539 #line 266 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1540 { RET_TOK(TermOpVal, Unreachable, UNREACHABLE); }
1541         YY_BREAK
1542 case 82:
1543 YY_RULE_SETUP
1544 #line 268 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1545 { RET_TOK(MemOpVal, Malloc, MALLOC); }
1546         YY_BREAK
1547 case 83:
1548 YY_RULE_SETUP
1549 #line 269 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1550 { RET_TOK(MemOpVal, Alloca, ALLOCA); }
1551         YY_BREAK
1552 case 84:
1553 YY_RULE_SETUP
1554 #line 270 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1555 { RET_TOK(MemOpVal, Free, FREE); }
1556         YY_BREAK
1557 case 85:
1558 YY_RULE_SETUP
1559 #line 271 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1560 { RET_TOK(MemOpVal, Load, LOAD); }
1561         YY_BREAK
1562 case 86:
1563 YY_RULE_SETUP
1564 #line 272 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1565 { RET_TOK(MemOpVal, Store, STORE); }
1566         YY_BREAK
1567 case 87:
1568 YY_RULE_SETUP
1569 #line 273 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1570 { RET_TOK(MemOpVal, GetElementPtr, GETELEMENTPTR); }
1571         YY_BREAK
1572 case 88:
1573 YY_RULE_SETUP
1574 #line 275 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1575 { RET_TOK(OtherOpVal, ExtractElement, EXTRACTELEMENT); }
1576         YY_BREAK
1577 case 89:
1578 YY_RULE_SETUP
1579 #line 278 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1580 {
1581                   UnEscapeLexed(yytext+1);
1582                   llvmAsmlval.StrVal = strdup(yytext+1);             // Skip %
1583                   return VAR_ID;
1584                 }
1585         YY_BREAK
1586 case 90:
1587 YY_RULE_SETUP
1588 #line 283 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1589 {
1590                   yytext[strlen(yytext)-1] = 0;  // nuke colon
1591                   UnEscapeLexed(yytext);
1592                   llvmAsmlval.StrVal = strdup(yytext);
1593                   return LABELSTR;
1594                 }
1595         YY_BREAK
1596 case 91:
1597 YY_RULE_SETUP
1598 #line 289 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1599 {
1600                   yytext[strlen(yytext)-2] = 0;  // nuke colon, end quote
1601                   UnEscapeLexed(yytext+1);
1602                   llvmAsmlval.StrVal = strdup(yytext+1);
1603                   return LABELSTR;
1604                 }
1605         YY_BREAK
1606 case 92:
1607 YY_RULE_SETUP
1608 #line 296 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1609 { // Note that we cannot unescape a string constant here!  The
1610                    // string constant might contain a \00 which would not be
1611                    // understood by the string stuff.  It is valid to make a
1612                    // [sbyte] c"Hello World\00" constant, for example.
1613                    //
1614                    yytext[strlen(yytext)-1] = 0;           // nuke end quote
1615                    llvmAsmlval.StrVal = strdup(yytext+1);  // Nuke start quote
1616                    return STRINGCONSTANT;
1617                  }
1618         YY_BREAK
1619 case 93:
1620 YY_RULE_SETUP
1621 #line 307 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1622 { llvmAsmlval.UInt64Val = atoull(yytext); return EUINT64VAL; }
1623         YY_BREAK
1624 case 94:
1625 YY_RULE_SETUP
1626 #line 308 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1627 {
1628                   uint64_t Val = atoull(yytext+1);
1629                   // +1:  we have bigger negative range
1630                   if (Val > (uint64_t)INT64_MAX+1)
1631                     ThrowException("Constant too large for signed 64 bits!");
1632                   llvmAsmlval.SInt64Val = -Val;
1633                   return ESINT64VAL;
1634                 }
1635         YY_BREAK
1636 case 95:
1637 YY_RULE_SETUP
1638 #line 316 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1639 {
1640                    llvmAsmlval.UInt64Val = HexIntToVal(yytext+3);
1641                    return yytext[0] == 's' ? ESINT64VAL : EUINT64VAL;
1642                  }
1643         YY_BREAK
1644 case 96:
1645 YY_RULE_SETUP
1646 #line 321 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1647 {
1648                   uint64_t Val = atoull(yytext+1);
1649                   if ((unsigned)Val != Val)
1650                     ThrowException("Invalid value number (too large)!");
1651                   llvmAsmlval.UIntVal = unsigned(Val);
1652                   return UINTVAL;
1653                 }
1654         YY_BREAK
1655 case 97:
1656 YY_RULE_SETUP
1657 #line 328 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1658 {
1659                   uint64_t Val = atoull(yytext+2);
1660                   // +1:  we have bigger negative range
1661                   if (Val > (uint64_t)INT32_MAX+1)
1662                     ThrowException("Constant too large for signed 32 bits!");
1663                   llvmAsmlval.SIntVal = (int)-Val;
1664                   return SINTVAL;
1665                 }
1666         YY_BREAK
1667 case 98:
1668 YY_RULE_SETUP
1669 #line 337 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1670 { llvmAsmlval.FPVal = atof(yytext); return FPVAL; }
1671         YY_BREAK
1672 case 99:
1673 YY_RULE_SETUP
1674 #line 338 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1675 { llvmAsmlval.FPVal = HexToFP(yytext); return FPVAL; }
1676         YY_BREAK
1677 case YY_STATE_EOF(INITIAL):
1678 #line 340 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1679 {
1680                   /* Make sure to free the internal buffers for flex when we are
1681                    * done reading our input!
1682                    */
1683                   yy_delete_buffer(YY_CURRENT_BUFFER);
1684                   return EOF;
1685                 }
1686         YY_BREAK
1687 case 100:
1688 YY_RULE_SETUP
1689 #line 348 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1690 { /* Ignore whitespace */ }
1691         YY_BREAK
1692 case 101:
1693 YY_RULE_SETUP
1694 #line 349 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1695 { return yytext[0]; }
1696         YY_BREAK
1697 case 102:
1698 YY_RULE_SETUP
1699 #line 351 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
1700 YY_FATAL_ERROR( "flex scanner jammed" );
1701         YY_BREAK
1702 #line 1703 "Lexer.cpp"
1703
1704         case YY_END_OF_BUFFER:
1705                 {
1706                 /* Amount of text matched not including the EOB char. */
1707                 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
1708
1709                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1710                 *yy_cp = yy_hold_char;
1711                 YY_RESTORE_YY_MORE_OFFSET
1712
1713                 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
1714                         {
1715                         /* We're scanning a new file or input source.  It's
1716                          * possible that this happened because the user
1717                          * just pointed yyin at a new source and called
1718                          * yylex().  If so, then we have to assure
1719                          * consistency between yy_current_buffer and our
1720                          * globals.  Here is the right place to do so, because
1721                          * this is the first action (other than possibly a
1722                          * back-up) that will match for the new input source.
1723                          */
1724                         yy_n_chars = yy_current_buffer->yy_n_chars;
1725                         yy_current_buffer->yy_input_file = yyin;
1726                         yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
1727                         }
1728
1729                 /* Note that here we test for yy_c_buf_p "<=" to the position
1730                  * of the first EOB in the buffer, since yy_c_buf_p will
1731                  * already have been incremented past the NUL character
1732                  * (since all states make transitions on EOB to the
1733                  * end-of-buffer state).  Contrast this with the test
1734                  * in input().
1735                  */
1736                 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1737                         { /* This was really a NUL. */
1738                         yy_state_type yy_next_state;
1739
1740                         yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
1741
1742                         yy_current_state = yy_get_previous_state();
1743
1744                         /* Okay, we're now positioned to make the NUL
1745                          * transition.  We couldn't have
1746                          * yy_get_previous_state() go ahead and do it
1747                          * for us because it doesn't know how to deal
1748                          * with the possibility of jamming (and we don't
1749                          * want to build jamming into it because then it
1750                          * will run more slowly).
1751                          */
1752
1753                         yy_next_state = yy_try_NUL_trans( yy_current_state );
1754
1755                         yy_bp = yytext_ptr + YY_MORE_ADJ;
1756
1757                         if ( yy_next_state )
1758                                 {
1759                                 /* Consume the NUL. */
1760                                 yy_cp = ++yy_c_buf_p;
1761                                 yy_current_state = yy_next_state;
1762                                 goto yy_match;
1763                                 }
1764
1765                         else
1766                                 {
1767                                 yy_cp = yy_c_buf_p;
1768                                 goto yy_find_action;
1769                                 }
1770                         }
1771
1772                 else switch ( yy_get_next_buffer() )
1773                         {
1774                         case EOB_ACT_END_OF_FILE:
1775                                 {
1776                                 yy_did_buffer_switch_on_eof = 0;
1777
1778                                 if ( yywrap() )
1779                                         {
1780                                         /* Note: because we've taken care in
1781                                          * yy_get_next_buffer() to have set up
1782                                          * yytext, we can now set up
1783                                          * yy_c_buf_p so that if some total
1784                                          * hoser (like flex itself) wants to
1785                                          * call the scanner after we return the
1786                                          * YY_NULL, it'll still work - another
1787                                          * YY_NULL will get returned.
1788                                          */
1789                                         yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
1790
1791                                         yy_act = YY_STATE_EOF(YY_START);
1792                                         goto do_action;
1793                                         }
1794
1795                                 else
1796                                         {
1797                                         if ( ! yy_did_buffer_switch_on_eof )
1798                                                 YY_NEW_FILE;
1799                                         }
1800                                 break;
1801                                 }
1802
1803                         case EOB_ACT_CONTINUE_SCAN:
1804                                 yy_c_buf_p =
1805                                         yytext_ptr + yy_amount_of_matched_text;
1806
1807                                 yy_current_state = yy_get_previous_state();
1808
1809                                 yy_cp = yy_c_buf_p;
1810                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
1811                                 goto yy_match;
1812
1813                         case EOB_ACT_LAST_MATCH:
1814                                 yy_c_buf_p =
1815                                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
1816
1817                                 yy_current_state = yy_get_previous_state();
1818
1819                                 yy_cp = yy_c_buf_p;
1820                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
1821                                 goto yy_find_action;
1822                         }
1823                 break;
1824                 }
1825
1826         default:
1827                 YY_FATAL_ERROR(
1828                         "fatal flex scanner internal error--no action found" );
1829         } /* end of action switch */
1830                 } /* end of scanning one token */
1831         } /* end of yylex */
1832
1833
1834 /* yy_get_next_buffer - try to read in a new buffer
1835  *
1836  * Returns a code representing an action:
1837  *      EOB_ACT_LAST_MATCH -
1838  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1839  *      EOB_ACT_END_OF_FILE - end of file
1840  */
1841
1842 static int yy_get_next_buffer()
1843         {
1844         register char *dest = yy_current_buffer->yy_ch_buf;
1845         register char *source = yytext_ptr;
1846         register int number_to_move, i;
1847         int ret_val;
1848
1849         if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
1850                 YY_FATAL_ERROR(
1851                 "fatal flex scanner internal error--end of buffer missed" );
1852
1853         if ( yy_current_buffer->yy_fill_buffer == 0 )
1854                 { /* Don't try to fill the buffer, so this is an EOF. */
1855                 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
1856                         {
1857                         /* We matched a single character, the EOB, so
1858                          * treat this as a final EOF.
1859                          */
1860                         return EOB_ACT_END_OF_FILE;
1861                         }
1862
1863                 else
1864                         {
1865                         /* We matched some text prior to the EOB, first
1866                          * process it.
1867                          */
1868                         return EOB_ACT_LAST_MATCH;
1869                         }
1870                 }
1871
1872         /* Try to read more data. */
1873
1874         /* First move last chars to start of buffer. */
1875         number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
1876
1877         for ( i = 0; i < number_to_move; ++i )
1878                 *(dest++) = *(source++);
1879
1880         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1881                 /* don't do the read, it's not guaranteed to return an EOF,
1882                  * just force an EOF
1883                  */
1884                 yy_current_buffer->yy_n_chars = yy_n_chars = 0;
1885
1886         else
1887                 {
1888                 int num_to_read =
1889                         yy_current_buffer->yy_buf_size - number_to_move - 1;
1890
1891                 while ( num_to_read <= 0 )
1892                         { /* Not enough room in the buffer - grow it. */
1893 #ifdef YY_USES_REJECT
1894                         YY_FATAL_ERROR(
1895 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
1896 #else
1897
1898                         /* just a shorter name for the current buffer */
1899                         YY_BUFFER_STATE b = yy_current_buffer;
1900
1901                         int yy_c_buf_p_offset =
1902                                 (int) (yy_c_buf_p - b->yy_ch_buf);
1903
1904                         if ( b->yy_is_our_buffer )
1905                                 {
1906                                 int new_size = b->yy_buf_size * 2;
1907
1908                                 if ( new_size <= 0 )
1909                                         b->yy_buf_size += b->yy_buf_size / 8;
1910                                 else
1911                                         b->yy_buf_size *= 2;
1912
1913                                 b->yy_ch_buf = (char *)
1914                                         /* Include room in for 2 EOB chars. */
1915                                         yy_flex_realloc( (void *) b->yy_ch_buf,
1916                                                          b->yy_buf_size + 2 );
1917                                 }
1918                         else
1919                                 /* Can't grow it, we don't own it. */
1920                                 b->yy_ch_buf = 0;
1921
1922                         if ( ! b->yy_ch_buf )
1923                                 YY_FATAL_ERROR(
1924                                 "fatal error - scanner input buffer overflow" );
1925
1926                         yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1927
1928                         num_to_read = yy_current_buffer->yy_buf_size -
1929                                                 number_to_move - 1;
1930 #endif
1931                         }
1932
1933                 if ( num_to_read > YY_READ_BUF_SIZE )
1934                         num_to_read = YY_READ_BUF_SIZE;
1935
1936                 /* Read in more data. */
1937                 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
1938                         yy_n_chars, num_to_read );
1939
1940                 yy_current_buffer->yy_n_chars = yy_n_chars;
1941                 }
1942
1943         if ( yy_n_chars == 0 )
1944                 {
1945                 if ( number_to_move == YY_MORE_ADJ )
1946                         {
1947                         ret_val = EOB_ACT_END_OF_FILE;
1948                         yyrestart( yyin );
1949                         }
1950
1951                 else
1952                         {
1953                         ret_val = EOB_ACT_LAST_MATCH;
1954                         yy_current_buffer->yy_buffer_status =
1955                                 YY_BUFFER_EOF_PENDING;
1956                         }
1957                 }
1958
1959         else
1960                 ret_val = EOB_ACT_CONTINUE_SCAN;
1961
1962         yy_n_chars += number_to_move;
1963         yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1964         yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1965
1966         yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
1967
1968         return ret_val;
1969         }
1970
1971
1972 /* yy_get_previous_state - get the state just before the EOB char was reached */
1973
1974 static yy_state_type yy_get_previous_state()
1975         {
1976         register yy_state_type yy_current_state;
1977         register char *yy_cp;
1978
1979         yy_current_state = yy_start;
1980         yy_state_ptr = yy_state_buf;
1981         *yy_state_ptr++ = yy_current_state;
1982
1983         for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
1984                 {
1985                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1986                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1987                         {
1988                         yy_current_state = (int) yy_def[yy_current_state];
1989                         if ( yy_current_state >= 416 )
1990                                 yy_c = yy_meta[(unsigned int) yy_c];
1991                         }
1992                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1993                 *yy_state_ptr++ = yy_current_state;
1994                 }
1995
1996         return yy_current_state;
1997         }
1998
1999
2000 /* yy_try_NUL_trans - try to make a transition on the NUL character
2001  *
2002  * synopsis
2003  *      next_state = yy_try_NUL_trans( current_state );
2004  */
2005
2006 #ifdef YY_USE_PROTOS
2007 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
2008 #else
2009 static yy_state_type yy_try_NUL_trans( yy_current_state )
2010 yy_state_type yy_current_state;
2011 #endif
2012         {
2013         register int yy_is_jam;
2014
2015         register YY_CHAR yy_c = 1;
2016         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2017                 {
2018                 yy_current_state = (int) yy_def[yy_current_state];
2019                 if ( yy_current_state >= 416 )
2020                         yy_c = yy_meta[(unsigned int) yy_c];
2021                 }
2022         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2023         yy_is_jam = (yy_current_state == 415);
2024         if ( ! yy_is_jam )
2025                 *yy_state_ptr++ = yy_current_state;
2026
2027         return yy_is_jam ? 0 : yy_current_state;
2028         }
2029
2030
2031 #ifndef YY_NO_UNPUT
2032 #ifdef YY_USE_PROTOS
2033 static inline void yyunput( int c, register char *yy_bp )
2034 #else
2035 static inline void yyunput( c, yy_bp )
2036 int c;
2037 register char *yy_bp;
2038 #endif
2039         {
2040         register char *yy_cp = yy_c_buf_p;
2041
2042         /* undo effects of setting up yytext */
2043         *yy_cp = yy_hold_char;
2044
2045         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
2046                 { /* need to shift things up to make room */
2047                 /* +2 for EOB chars. */
2048                 register int number_to_move = yy_n_chars + 2;
2049                 register char *dest = &yy_current_buffer->yy_ch_buf[
2050                                         yy_current_buffer->yy_buf_size + 2];
2051                 register char *source =
2052                                 &yy_current_buffer->yy_ch_buf[number_to_move];
2053
2054                 while ( source > yy_current_buffer->yy_ch_buf )
2055                         *--dest = *--source;
2056
2057                 yy_cp += (int) (dest - source);
2058                 yy_bp += (int) (dest - source);
2059                 yy_current_buffer->yy_n_chars =
2060                         yy_n_chars = yy_current_buffer->yy_buf_size;
2061
2062                 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
2063                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
2064                 }
2065
2066         *--yy_cp = (char) c;
2067
2068         if ( c == '\n' )
2069                 --yylineno;
2070
2071         yytext_ptr = yy_bp;
2072         yy_hold_char = *yy_cp;
2073         yy_c_buf_p = yy_cp;
2074         }
2075 #endif  /* ifndef YY_NO_UNPUT */
2076
2077
2078 #ifdef __cplusplus
2079 static int yyinput()
2080 #else
2081 static int input()
2082 #endif
2083         {
2084         int c;
2085
2086         *yy_c_buf_p = yy_hold_char;
2087
2088         if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
2089                 {
2090                 /* yy_c_buf_p now points to the character we want to return.
2091                  * If this occurs *before* the EOB characters, then it's a
2092                  * valid NUL; if not, then we've hit the end of the buffer.
2093                  */
2094                 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
2095                         /* This was really a NUL. */
2096                         *yy_c_buf_p = '\0';
2097
2098                 else
2099                         { /* need more input */
2100                         int offset = yy_c_buf_p - yytext_ptr;
2101                         ++yy_c_buf_p;
2102
2103                         switch ( yy_get_next_buffer() )
2104                                 {
2105                                 case EOB_ACT_LAST_MATCH:
2106                                         /* This happens because yy_g_n_b()
2107                                          * sees that we've accumulated a
2108                                          * token and flags that we need to
2109                                          * try matching the token before
2110                                          * proceeding.  But for input(),
2111                                          * there's no matching to consider.
2112                                          * So convert the EOB_ACT_LAST_MATCH
2113                                          * to EOB_ACT_END_OF_FILE.
2114                                          */
2115
2116                                         /* Reset buffer status. */
2117                                         yyrestart( yyin );
2118
2119                                         /* fall through */
2120
2121                                 case EOB_ACT_END_OF_FILE:
2122                                         {
2123                                         if ( yywrap() )
2124                                                 return EOF;
2125
2126                                         if ( ! yy_did_buffer_switch_on_eof )
2127                                                 YY_NEW_FILE;
2128 #ifdef __cplusplus
2129                                         return yyinput();
2130 #else
2131                                         return input();
2132 #endif
2133                                         }
2134
2135                                 case EOB_ACT_CONTINUE_SCAN:
2136                                         yy_c_buf_p = yytext_ptr + offset;
2137                                         break;
2138                                 }
2139                         }
2140                 }
2141
2142         c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */
2143         *yy_c_buf_p = '\0';     /* preserve yytext */
2144         yy_hold_char = *++yy_c_buf_p;
2145
2146         if ( c == '\n' )
2147                 ++yylineno;
2148
2149         return c;
2150         }
2151
2152
2153 #ifdef YY_USE_PROTOS
2154 void yyrestart( FILE *input_file )
2155 #else
2156 void yyrestart( input_file )
2157 FILE *input_file;
2158 #endif
2159         {
2160         if ( ! yy_current_buffer )
2161                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
2162
2163         yy_init_buffer( yy_current_buffer, input_file );
2164         yy_load_buffer_state();
2165         }
2166
2167
2168 #ifdef YY_USE_PROTOS
2169 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
2170 #else
2171 void yy_switch_to_buffer( new_buffer )
2172 YY_BUFFER_STATE new_buffer;
2173 #endif
2174         {
2175         if ( yy_current_buffer == new_buffer )
2176                 return;
2177
2178         if ( yy_current_buffer )
2179                 {
2180                 /* Flush out information for old buffer. */
2181                 *yy_c_buf_p = yy_hold_char;
2182                 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
2183                 yy_current_buffer->yy_n_chars = yy_n_chars;
2184                 }
2185
2186         yy_current_buffer = new_buffer;
2187         yy_load_buffer_state();
2188
2189         /* We don't actually know whether we did this switch during
2190          * EOF (yywrap()) processing, but the only time this flag
2191          * is looked at is after yywrap() is called, so it's safe
2192          * to go ahead and always set it.
2193          */
2194         yy_did_buffer_switch_on_eof = 1;
2195         }
2196
2197
2198 #ifdef YY_USE_PROTOS
2199 void yy_load_buffer_state( void )
2200 #else
2201 void yy_load_buffer_state()
2202 #endif
2203         {
2204         yy_n_chars = yy_current_buffer->yy_n_chars;
2205         yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
2206         yyin = yy_current_buffer->yy_input_file;
2207         yy_hold_char = *yy_c_buf_p;
2208         }
2209
2210
2211 #ifdef YY_USE_PROTOS
2212 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
2213 #else
2214 YY_BUFFER_STATE yy_create_buffer( file, size )
2215 FILE *file;
2216 int size;
2217 #endif
2218         {
2219         YY_BUFFER_STATE b;
2220
2221         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
2222         if ( ! b )
2223                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2224
2225         b->yy_buf_size = size;
2226
2227         /* yy_ch_buf has to be 2 characters longer than the size given because
2228          * we need to put in 2 end-of-buffer characters.
2229          */
2230         b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
2231         if ( ! b->yy_ch_buf )
2232                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2233
2234         b->yy_is_our_buffer = 1;
2235
2236         yy_init_buffer( b, file );
2237
2238         return b;
2239         }
2240
2241
2242 #ifdef YY_USE_PROTOS
2243 void yy_delete_buffer( YY_BUFFER_STATE b )
2244 #else
2245 void yy_delete_buffer( b )
2246 YY_BUFFER_STATE b;
2247 #endif
2248         {
2249         if ( ! b )
2250                 return;
2251
2252         if ( b == yy_current_buffer )
2253                 yy_current_buffer = (YY_BUFFER_STATE) 0;
2254
2255         if ( b->yy_is_our_buffer )
2256                 yy_flex_free( (void *) b->yy_ch_buf );
2257
2258         yy_flex_free( (void *) b );
2259         }
2260
2261
2262 #ifndef YY_ALWAYS_INTERACTIVE
2263 #ifndef YY_NEVER_INTERACTIVE
2264 extern int isatty YY_PROTO(( int ));
2265 #endif
2266 #endif
2267
2268 #ifdef YY_USE_PROTOS
2269 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
2270 #else
2271 void yy_init_buffer( b, file )
2272 YY_BUFFER_STATE b;
2273 FILE *file;
2274 #endif
2275
2276
2277         {
2278         yy_flush_buffer( b );
2279
2280         b->yy_input_file = file;
2281         b->yy_fill_buffer = 1;
2282
2283 #if YY_ALWAYS_INTERACTIVE
2284         b->yy_is_interactive = 1;
2285 #else
2286 #if YY_NEVER_INTERACTIVE
2287         b->yy_is_interactive = 0;
2288 #else
2289         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
2290 #endif
2291 #endif
2292         }
2293
2294
2295 #ifdef YY_USE_PROTOS
2296 void yy_flush_buffer( YY_BUFFER_STATE b )
2297 #else
2298 void yy_flush_buffer( b )
2299 YY_BUFFER_STATE b;
2300 #endif
2301
2302         {
2303         if ( ! b )
2304                 return;
2305
2306         b->yy_n_chars = 0;
2307
2308         /* We always need two end-of-buffer characters.  The first causes
2309          * a transition to the end-of-buffer state.  The second causes
2310          * a jam in that state.
2311          */
2312         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2313         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2314
2315         b->yy_buf_pos = &b->yy_ch_buf[0];
2316
2317         b->yy_at_bol = 1;
2318         b->yy_buffer_status = YY_BUFFER_NEW;
2319
2320         if ( b == yy_current_buffer )
2321                 yy_load_buffer_state();
2322         }
2323
2324
2325 #ifndef YY_NO_SCAN_BUFFER
2326 #ifdef YY_USE_PROTOS
2327 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
2328 #else
2329 YY_BUFFER_STATE yy_scan_buffer( base, size )
2330 char *base;
2331 yy_size_t size;
2332 #endif
2333         {
2334         YY_BUFFER_STATE b;
2335
2336         if ( size < 2 ||
2337              base[size-2] != YY_END_OF_BUFFER_CHAR ||
2338              base[size-1] != YY_END_OF_BUFFER_CHAR )
2339                 /* They forgot to leave room for the EOB's. */
2340                 return 0;
2341
2342         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
2343         if ( ! b )
2344                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
2345
2346         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
2347         b->yy_buf_pos = b->yy_ch_buf = base;
2348         b->yy_is_our_buffer = 0;
2349         b->yy_input_file = 0;
2350         b->yy_n_chars = b->yy_buf_size;
2351         b->yy_is_interactive = 0;
2352         b->yy_at_bol = 1;
2353         b->yy_fill_buffer = 0;
2354         b->yy_buffer_status = YY_BUFFER_NEW;
2355
2356         yy_switch_to_buffer( b );
2357
2358         return b;
2359         }
2360 #endif
2361
2362
2363 #ifndef YY_NO_SCAN_STRING
2364 #ifdef YY_USE_PROTOS
2365 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
2366 #else
2367 YY_BUFFER_STATE yy_scan_string( yy_str )
2368 yyconst char *yy_str;
2369 #endif
2370         {
2371         int len;
2372         for ( len = 0; yy_str[len]; ++len )
2373                 ;
2374
2375         return yy_scan_bytes( yy_str, len );
2376         }
2377 #endif
2378
2379
2380 #ifndef YY_NO_SCAN_BYTES
2381 #ifdef YY_USE_PROTOS
2382 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
2383 #else
2384 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
2385 yyconst char *bytes;
2386 int len;
2387 #endif
2388         {
2389         YY_BUFFER_STATE b;
2390         char *buf;
2391         yy_size_t n;
2392         int i;
2393
2394         /* Get memory for full buffer, including space for trailing EOB's. */
2395         n = len + 2;
2396         buf = (char *) yy_flex_alloc( n );
2397         if ( ! buf )
2398                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
2399
2400         for ( i = 0; i < len; ++i )
2401                 buf[i] = bytes[i];
2402
2403         buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
2404
2405         b = yy_scan_buffer( buf, n );
2406         if ( ! b )
2407                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2408
2409         /* It's okay to grow etc. this buffer, and we should throw it
2410          * away when we're done.
2411          */
2412         b->yy_is_our_buffer = 1;
2413
2414         return b;
2415         }
2416 #endif
2417
2418
2419 #ifndef YY_NO_PUSH_STATE
2420 #ifdef YY_USE_PROTOS
2421 static void yy_push_state( int new_state )
2422 #else
2423 static void yy_push_state( new_state )
2424 int new_state;
2425 #endif
2426         {
2427         if ( yy_start_stack_ptr >= yy_start_stack_depth )
2428                 {
2429                 yy_size_t new_size;
2430
2431                 yy_start_stack_depth += YY_START_STACK_INCR;
2432                 new_size = yy_start_stack_depth * sizeof( int );
2433
2434                 if ( ! yy_start_stack )
2435                         yy_start_stack = (int *) yy_flex_alloc( new_size );
2436
2437                 else
2438                         yy_start_stack = (int *) yy_flex_realloc(
2439                                         (void *) yy_start_stack, new_size );
2440
2441                 if ( ! yy_start_stack )
2442                         YY_FATAL_ERROR(
2443                         "out of memory expanding start-condition stack" );
2444                 }
2445
2446         yy_start_stack[yy_start_stack_ptr++] = YY_START;
2447
2448         BEGIN(new_state);
2449         }
2450 #endif
2451
2452
2453 #ifndef YY_NO_POP_STATE
2454 static void yy_pop_state()
2455         {
2456         if ( --yy_start_stack_ptr < 0 )
2457                 YY_FATAL_ERROR( "start-condition stack underflow" );
2458
2459         BEGIN(yy_start_stack[yy_start_stack_ptr]);
2460         }
2461 #endif
2462
2463
2464 #ifndef YY_NO_TOP_STATE
2465 static int yy_top_state()
2466         {
2467         return yy_start_stack[yy_start_stack_ptr - 1];
2468         }
2469 #endif
2470
2471 #ifndef YY_EXIT_FAILURE
2472 #define YY_EXIT_FAILURE 2
2473 #endif
2474
2475 #ifdef YY_USE_PROTOS
2476 static void yy_fatal_error( yyconst char msg[] )
2477 #else
2478 static void yy_fatal_error( msg )
2479 char msg[];
2480 #endif
2481         {
2482         (void) fprintf( stderr, "%s\n", msg );
2483         exit( YY_EXIT_FAILURE );
2484         }
2485
2486
2487
2488 /* Redefine yyless() so it works in section 3 code. */
2489
2490 #undef yyless
2491 #define yyless(n) \
2492         do \
2493                 { \
2494                 /* Undo effects of setting up yytext. */ \
2495                 yytext[yyleng] = yy_hold_char; \
2496                 yy_c_buf_p = yytext + n; \
2497                 yy_hold_char = *yy_c_buf_p; \
2498                 *yy_c_buf_p = '\0'; \
2499                 yyleng = n; \
2500                 } \
2501         while ( 0 )
2502
2503
2504 /* Internal utility routines. */
2505
2506 #ifndef yytext_ptr
2507 #ifdef YY_USE_PROTOS
2508 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
2509 #else
2510 static void yy_flex_strncpy( s1, s2, n )
2511 char *s1;
2512 yyconst char *s2;
2513 int n;
2514 #endif
2515         {
2516         register int i;
2517         for ( i = 0; i < n; ++i )
2518                 s1[i] = s2[i];
2519         }
2520 #endif
2521
2522 #ifdef YY_NEED_STRLEN
2523 #ifdef YY_USE_PROTOS
2524 static int yy_flex_strlen( yyconst char *s )
2525 #else
2526 static int yy_flex_strlen( s )
2527 yyconst char *s;
2528 #endif
2529         {
2530         register int n;
2531         for ( n = 0; s[n]; ++n )
2532                 ;
2533
2534         return n;
2535         }
2536 #endif
2537
2538
2539 #ifdef YY_USE_PROTOS
2540 static void *yy_flex_alloc( yy_size_t size )
2541 #else
2542 static void *yy_flex_alloc( size )
2543 yy_size_t size;
2544 #endif
2545         {
2546         return (void *) malloc( size );
2547         }
2548
2549 #ifdef YY_USE_PROTOS
2550 static inline void *yy_flex_realloc( void *ptr, yy_size_t size )
2551 #else
2552 static inline void *yy_flex_realloc( ptr, size )
2553 void *ptr;
2554 yy_size_t size;
2555 #endif
2556         {
2557         /* The cast to (char *) in the following accommodates both
2558          * implementations that use char* generic pointers, and those
2559          * that use void* generic pointers.  It works with the latter
2560          * because both ANSI C and C++ allow castless assignment from
2561          * any pointer type to void*, and deal with argument conversions
2562          * as though doing an assignment.
2563          */
2564         return (void *) realloc( (char *) ptr, size );
2565         }
2566
2567 #ifdef YY_USE_PROTOS
2568 static void yy_flex_free( void *ptr )
2569 #else
2570 static void yy_flex_free( ptr )
2571 void *ptr;
2572 #endif
2573         {
2574         free( ptr );
2575         }
2576
2577 #if YY_MAIN
2578 int main()
2579         {
2580         yylex();
2581         return 0;
2582         }
2583 #endif
2584 #line 351 "/Users/sabre/llvm/lib/AsmParser/Lexer.l"
2585