lib/AsmParser/Lexer.cpp.cvs

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