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