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