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