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, char* EndBuffer) {
 987   char *BOut = Buffer;
 988   for (char *BIn = Buffer; *BIn; ) {
 989     if (BIn[0] == '\\') {
 990       if (BIn < EndBuffer-1 && BIn[1] == '\\') {
 991         *BOut++ = '\\'; // Two \ becomes one
 992         BIn += 2;
 993       } else if (BIn < EndBuffer-2 && isxdigit(BIn[1]) && isxdigit(BIn[2])) {
 994         char Tmp = BIn[3]; BIn[3] = 0;      // Terminate string
 995         *BOut = (char)strtol(BIn+1, 0, 16); // Convert to number
 996         BIn[3] = Tmp;                       // Restore character
 997         BIn += 3;                           // Skip over handled chars
 998         ++BOut;
 999       } else {
1000         *BOut++ = *BIn++;
1001       }
1002     } else {
1003       *BOut++ = *BIn++;
1004     }
1005   }
1006   return BOut;
1007 }
1008
1009 } // End llvm namespace
1010
1011 using namespace llvm;
1012
1013 #define YY_NEVER_INTERACTIVE 1
1014 /* Comments start with a ; and go till end of line */
1015 /* Local Values and Type identifiers start with a % sign */
1016 /* Global Value identifiers start with an @ sign */
1017 /* Label identifiers end with a colon */
1018 /* Quoted names can contain any character except " and \ */
1019 /* LocalVarID/GlobalVarID: match an unnamed local variable slot ID. */
1020 /* Integer types are specified with i and a bitwidth */
1021 /* E[PN]Integer: match positive and negative literal integer values. */
1022 /* FPConstant - A Floating point constant.
1023  */
1024 /* HexFPConstant - Floating point constant represented in IEEE format as a
1025  *  hexadecimal number for when exponential notation is not precise enough.
1026  */
1027 /* HexIntConstant - Hexadecimal constant generated by the CFE to avoid forcing
1028  * it to deal with 64 bit numbers.
1029  */
1030 #line 1031 "Lexer.cpp"
1031
1032 /* Macros after this point can all be overridden by user definitions in
1033  * section 1.
1034  */
1035
1036 #ifndef YY_SKIP_YYWRAP
1037 #ifdef __cplusplus
1038 extern "C" int yywrap YY_PROTO(( void ));
1039 #else
1040 extern int yywrap YY_PROTO(( void ));
1041 #endif
1042 #endif
1043
1044 #ifndef YY_NO_UNPUT
1045 static inline void yyunput YY_PROTO(( int c, char *buf_ptr ));
1046 #endif
1047
1048 #ifndef yytext_ptr
1049 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
1050 #endif
1051
1052 #ifdef YY_NEED_STRLEN
1053 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
1054 #endif
1055
1056 #ifndef YY_NO_INPUT
1057 #ifdef __cplusplus
1058 static int yyinput YY_PROTO(( void ));
1059 #else
1060 static int input YY_PROTO(( void ));
1061 #endif
1062 #endif
1063
1064 #if YY_STACK_USED
1065 static int yy_start_stack_ptr = 0;
1066 static int yy_start_stack_depth = 0;
1067 static int *yy_start_stack = 0;
1068 #ifndef YY_NO_PUSH_STATE
1069 static void yy_push_state YY_PROTO(( int new_state ));
1070 #endif
1071 #ifndef YY_NO_POP_STATE
1072 static void yy_pop_state YY_PROTO(( void ));
1073 #endif
1074 #ifndef YY_NO_TOP_STATE
1075 static int yy_top_state YY_PROTO(( void ));
1076 #endif
1077
1078 #else
1079 #define YY_NO_PUSH_STATE 1
1080 #define YY_NO_POP_STATE 1
1081 #define YY_NO_TOP_STATE 1
1082 #endif
1083
1084 #ifdef YY_MALLOC_DECL
1085 YY_MALLOC_DECL
1086 #else
1087 #if __STDC__
1088 #ifndef __cplusplus
1089 #include <stdlib.h>
1090 #endif
1091 #else
1092 /* Just try to get by without declaring the routines.  This will fail
1093  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
1094  * or sizeof(void*) != sizeof(int).
1095  */
1096 #endif
1097 #endif
1098
1099 /* Amount of stuff to slurp up with each read. */
1100 #ifndef YY_READ_BUF_SIZE
1101 #define YY_READ_BUF_SIZE 8192
1102 #endif
1103
1104 /* Copy whatever the last rule matched to the standard output. */
1105
1106 #ifndef ECHO
1107 /* This used to be an fputs(), but since the string might contain NUL's,
1108  * we now use fwrite().
1109  */
1110 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
1111 #endif
1112
1113 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
1114  * is returned in "result".
1115  */
1116 #ifndef YY_INPUT
1117 #define YY_INPUT(buf,result,max_size) \
1118         if ( yy_current_buffer->yy_is_interactive ) \
1119                 { \
1120                 int c = '*', n; \
1121                 for ( n = 0; n < max_size && \
1122                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
1123                         buf[n] = (char) c; \
1124                 if ( c == '\n' ) \
1125                         buf[n++] = (char) c; \
1126                 if ( c == EOF && ferror( yyin ) ) \
1127                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
1128                 result = n; \
1129                 } \
1130         else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
1131                   && ferror( yyin ) ) \
1132                 YY_FATAL_ERROR( "input in flex scanner failed" );
1133 #endif
1134
1135 /* No semi-colon after return; correct usage is to write "yyterminate();" -
1136  * we don't want an extra ';' after the "return" because that will cause
1137  * some compilers to complain about unreachable statements.
1138  */
1139 #ifndef yyterminate
1140 #define yyterminate() return YY_NULL
1141 #endif
1142
1143 /* Number of entries by which start-condition stack grows. */
1144 #ifndef YY_START_STACK_INCR
1145 #define YY_START_STACK_INCR 25
1146 #endif
1147
1148 /* Report a fatal error. */
1149 #ifndef YY_FATAL_ERROR
1150 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
1151 #endif
1152
1153 /* Default declaration of generated scanner - a define so the user can
1154  * easily add parameters.
1155  */
1156 #ifndef YY_DECL
1157 #define YY_DECL int yylex YY_PROTO(( void ))
1158 #endif
1159
1160 /* Code executed at the beginning of each rule, after yytext and yyleng
1161  * have been set up.
1162  */
1163 #ifndef YY_USER_ACTION
1164 #define YY_USER_ACTION
1165 #endif
1166
1167 /* Code executed at the end of each rule. */
1168 #ifndef YY_BREAK
1169 #define YY_BREAK break;
1170 #endif
1171
1172 #define YY_RULE_SETUP \
1173         YY_USER_ACTION
1174
1175 YY_DECL
1176         {
1177         register yy_state_type yy_current_state;
1178         register char *yy_cp = NULL, *yy_bp = NULL;
1179         register int yy_act;
1180
1181 #line 180 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1182
1183
1184 #line 1185 "Lexer.cpp"
1185
1186         if ( yy_init )
1187                 {
1188                 yy_init = 0;
1189
1190 #ifdef YY_USER_INIT
1191                 YY_USER_INIT;
1192 #endif
1193
1194                 if ( ! yy_start )
1195                         yy_start = 1;   /* first start state */
1196
1197                 if ( ! yyin )
1198                         yyin = stdin;
1199
1200                 if ( ! yyout )
1201                         yyout = stdout;
1202
1203                 if ( ! yy_current_buffer )
1204                         yy_current_buffer =
1205                                 yy_create_buffer( yyin, YY_BUF_SIZE );
1206
1207                 yy_load_buffer_state();
1208                 }
1209
1210         while ( 1 )             /* loops until end-of-file is reached */
1211                 {
1212                 yy_cp = yy_c_buf_p;
1213
1214                 /* Support of yytext. */
1215                 *yy_cp = yy_hold_char;
1216
1217                 /* yy_bp points to the position in yy_ch_buf of the start of
1218                  * the current run.
1219                  */
1220                 yy_bp = yy_cp;
1221
1222                 yy_current_state = yy_start;
1223                 yy_state_ptr = yy_state_buf;
1224                 *yy_state_ptr++ = yy_current_state;
1225 yy_match:
1226                 do
1227                         {
1228                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
1229                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1230                                 {
1231                                 yy_current_state = (int) yy_def[yy_current_state];
1232                                 if ( yy_current_state >= 563 )
1233                                         yy_c = yy_meta[(unsigned int) yy_c];
1234                                 }
1235                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1236                         *yy_state_ptr++ = yy_current_state;
1237                         ++yy_cp;
1238                         }
1239                 while ( yy_current_state != 562 );
1240
1241 yy_find_action:
1242                 yy_current_state = *--yy_state_ptr;
1243                 yy_lp = yy_accept[yy_current_state];
1244 find_rule: /* we branch to this label when backing up */
1245                 for ( ; ; ) /* until we find what rule we matched */
1246                         {
1247                         if ( yy_lp && yy_lp < yy_accept[yy_current_state + 1] )
1248                                 {
1249                                 yy_act = yy_acclist[yy_lp];
1250                                         {
1251                                         yy_full_match = yy_cp;
1252                                         break;
1253                                         }
1254                                 }
1255                         --yy_cp;
1256                         yy_current_state = *--yy_state_ptr;
1257                         yy_lp = yy_accept[yy_current_state];
1258                         }
1259
1260                 YY_DO_BEFORE_ACTION;
1261
1262                 if ( yy_act != YY_END_OF_BUFFER )
1263                         {
1264                         int yyl;
1265                         for ( yyl = 0; yyl < yyleng; ++yyl )
1266                                 if ( yytext[yyl] == '\n' )
1267                                         ++yylineno;
1268                         }
1269
1270 do_action:      /* This label is used only to access EOF actions. */
1271
1272
1273                 switch ( yy_act )
1274         { /* beginning of action switch */
1275 case 1:
1276 YY_RULE_SETUP
1277 #line 182 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1278 { /* Ignore comments for now */ }
1279         YY_BREAK
1280 case 2:
1281 YY_RULE_SETUP
1282 #line 184 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1283 { return BEGINTOK; }
1284         YY_BREAK
1285 case 3:
1286 YY_RULE_SETUP
1287 #line 185 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1288 { return ENDTOK; }
1289         YY_BREAK
1290 case 4:
1291 YY_RULE_SETUP
1292 #line 186 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1293 { return TRUETOK;  }
1294         YY_BREAK
1295 case 5:
1296 YY_RULE_SETUP
1297 #line 187 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1298 { return FALSETOK; }
1299         YY_BREAK
1300 case 6:
1301 YY_RULE_SETUP
1302 #line 188 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1303 { return DECLARE; }
1304         YY_BREAK
1305 case 7:
1306 YY_RULE_SETUP
1307 #line 189 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1308 { return DEFINE; }
1309         YY_BREAK
1310 case 8:
1311 YY_RULE_SETUP
1312 #line 190 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1313 { return GLOBAL; }
1314         YY_BREAK
1315 case 9:
1316 YY_RULE_SETUP
1317 #line 191 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1318 { return CONSTANT; }
1319         YY_BREAK
1320 case 10:
1321 YY_RULE_SETUP
1322 #line 192 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1323 { return INTERNAL; }
1324         YY_BREAK
1325 case 11:
1326 YY_RULE_SETUP
1327 #line 193 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1328 { return LINKONCE; }
1329         YY_BREAK
1330 case 12:
1331 YY_RULE_SETUP
1332 #line 194 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1333 { return WEAK; }
1334         YY_BREAK
1335 case 13:
1336 YY_RULE_SETUP
1337 #line 195 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1338 { return APPENDING; }
1339         YY_BREAK
1340 case 14:
1341 YY_RULE_SETUP
1342 #line 196 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1343 { return DLLIMPORT; }
1344         YY_BREAK
1345 case 15:
1346 YY_RULE_SETUP
1347 #line 197 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1348 { return DLLEXPORT; }
1349         YY_BREAK
1350 case 16:
1351 YY_RULE_SETUP
1352 #line 198 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1353 { return HIDDEN; }
1354         YY_BREAK
1355 case 17:
1356 YY_RULE_SETUP
1357 #line 199 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1358 { return PROTECTED; }
1359         YY_BREAK
1360 case 18:
1361 YY_RULE_SETUP
1362 #line 200 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1363 { return EXTERN_WEAK; }
1364         YY_BREAK
1365 case 19:
1366 YY_RULE_SETUP
1367 #line 201 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1368 { return EXTERNAL; }
1369         YY_BREAK
1370 case 20:
1371 YY_RULE_SETUP
1372 #line 202 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1373 { return THREAD_LOCAL; }
1374         YY_BREAK
1375 case 21:
1376 YY_RULE_SETUP
1377 #line 203 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1378 { return ZEROINITIALIZER; }
1379         YY_BREAK
1380 case 22:
1381 YY_RULE_SETUP
1382 #line 204 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1383 { return DOTDOTDOT; }
1384         YY_BREAK
1385 case 23:
1386 YY_RULE_SETUP
1387 #line 205 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1388 { return UNDEF; }
1389         YY_BREAK
1390 case 24:
1391 YY_RULE_SETUP
1392 #line 206 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1393 { return NULL_TOK; }
1394         YY_BREAK
1395 case 25:
1396 YY_RULE_SETUP
1397 #line 207 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1398 { return TO; }
1399         YY_BREAK
1400 case 26:
1401 YY_RULE_SETUP
1402 #line 208 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1403 { return TAIL; }
1404         YY_BREAK
1405 case 27:
1406 YY_RULE_SETUP
1407 #line 209 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1408 { return TARGET; }
1409         YY_BREAK
1410 case 28:
1411 YY_RULE_SETUP
1412 #line 210 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1413 { return TRIPLE; }
1414         YY_BREAK
1415 case 29:
1416 YY_RULE_SETUP
1417 #line 211 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1418 { return DEPLIBS; }
1419         YY_BREAK
1420 case 30:
1421 YY_RULE_SETUP
1422 #line 212 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1423 { return DATALAYOUT; }
1424         YY_BREAK
1425 case 31:
1426 YY_RULE_SETUP
1427 #line 213 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1428 { return VOLATILE; }
1429         YY_BREAK
1430 case 32:
1431 YY_RULE_SETUP
1432 #line 214 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1433 { return ALIGN;  }
1434         YY_BREAK
1435 case 33:
1436 YY_RULE_SETUP
1437 #line 215 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1438 { return SECTION; }
1439         YY_BREAK
1440 case 34:
1441 YY_RULE_SETUP
1442 #line 216 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1443 { return ALIAS; }
1444         YY_BREAK
1445 case 35:
1446 YY_RULE_SETUP
1447 #line 217 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1448 { return MODULE; }
1449         YY_BREAK
1450 case 36:
1451 YY_RULE_SETUP
1452 #line 218 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1453 { return ASM_TOK; }
1454         YY_BREAK
1455 case 37:
1456 YY_RULE_SETUP
1457 #line 219 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1458 { return SIDEEFFECT; }
1459         YY_BREAK
1460 case 38:
1461 YY_RULE_SETUP
1462 #line 221 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1463 { return CC_TOK; }
1464         YY_BREAK
1465 case 39:
1466 YY_RULE_SETUP
1467 #line 222 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1468 { return CCC_TOK; }
1469         YY_BREAK
1470 case 40:
1471 YY_RULE_SETUP
1472 #line 223 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1473 { return FASTCC_TOK; }
1474         YY_BREAK
1475 case 41:
1476 YY_RULE_SETUP
1477 #line 224 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1478 { return COLDCC_TOK; }
1479         YY_BREAK
1480 case 42:
1481 YY_RULE_SETUP
1482 #line 225 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1483 { return X86_STDCALLCC_TOK; }
1484         YY_BREAK
1485 case 43:
1486 YY_RULE_SETUP
1487 #line 226 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1488 { return X86_FASTCALLCC_TOK; }
1489         YY_BREAK
1490 case 44:
1491 YY_RULE_SETUP
1492 #line 228 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1493 { return INREG; }
1494         YY_BREAK
1495 case 45:
1496 YY_RULE_SETUP
1497 #line 229 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1498 { return SRET;  }
1499         YY_BREAK
1500 case 46:
1501 YY_RULE_SETUP
1502 #line 230 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1503 { return NOUNWIND; }
1504         YY_BREAK
1505 case 47:
1506 YY_RULE_SETUP
1507 #line 231 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1508 { return NORETURN; }
1509         YY_BREAK
1510 case 48:
1511 YY_RULE_SETUP
1512 #line 233 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1513 { RET_TY(Type::VoidTy,  VOID);  }
1514         YY_BREAK
1515 case 49:
1516 YY_RULE_SETUP
1517 #line 234 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1518 { RET_TY(Type::FloatTy, FLOAT); }
1519         YY_BREAK
1520 case 50:
1521 YY_RULE_SETUP
1522 #line 235 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1523 { RET_TY(Type::DoubleTy,DOUBLE);}
1524         YY_BREAK
1525 case 51:
1526 YY_RULE_SETUP
1527 #line 236 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1528 { RET_TY(Type::LabelTy, LABEL); }
1529         YY_BREAK
1530 case 52:
1531 YY_RULE_SETUP
1532 #line 237 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1533 { return TYPE;   }
1534         YY_BREAK
1535 case 53:
1536 YY_RULE_SETUP
1537 #line 238 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1538 { return OPAQUE; }
1539         YY_BREAK
1540 case 54:
1541 YY_RULE_SETUP
1542 #line 239 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1543 { uint64_t NumBits = atoull(yytext+1);
1544                   if (NumBits < IntegerType::MIN_INT_BITS ||
1545                       NumBits > IntegerType::MAX_INT_BITS)
1546                     GenerateError("Bitwidth for integer type out of range!");
1547                   const Type* Ty = IntegerType::get(NumBits);
1548                   RET_TY(Ty, INTTYPE);
1549                 }
1550         YY_BREAK
1551 case 55:
1552 YY_RULE_SETUP
1553 #line 247 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1554 { RET_TOK(BinaryOpVal, Add, ADD); }
1555         YY_BREAK
1556 case 56:
1557 YY_RULE_SETUP
1558 #line 248 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1559 { RET_TOK(BinaryOpVal, Sub, SUB); }
1560         YY_BREAK
1561 case 57:
1562 YY_RULE_SETUP
1563 #line 249 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1564 { RET_TOK(BinaryOpVal, Mul, MUL); }
1565         YY_BREAK
1566 case 58:
1567 YY_RULE_SETUP
1568 #line 250 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1569 { RET_TOK(BinaryOpVal, UDiv, UDIV); }
1570         YY_BREAK
1571 case 59:
1572 YY_RULE_SETUP
1573 #line 251 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1574 { RET_TOK(BinaryOpVal, SDiv, SDIV); }
1575         YY_BREAK
1576 case 60:
1577 YY_RULE_SETUP
1578 #line 252 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1579 { RET_TOK(BinaryOpVal, FDiv, FDIV); }
1580         YY_BREAK
1581 case 61:
1582 YY_RULE_SETUP
1583 #line 253 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1584 { RET_TOK(BinaryOpVal, URem, UREM); }
1585         YY_BREAK
1586 case 62:
1587 YY_RULE_SETUP
1588 #line 254 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1589 { RET_TOK(BinaryOpVal, SRem, SREM); }
1590         YY_BREAK
1591 case 63:
1592 YY_RULE_SETUP
1593 #line 255 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1594 { RET_TOK(BinaryOpVal, FRem, FREM); }
1595         YY_BREAK
1596 case 64:
1597 YY_RULE_SETUP
1598 #line 256 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1599 { RET_TOK(BinaryOpVal, Shl, SHL); }
1600         YY_BREAK
1601 case 65:
1602 YY_RULE_SETUP
1603 #line 257 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1604 { RET_TOK(BinaryOpVal, LShr, LSHR); }
1605         YY_BREAK
1606 case 66:
1607 YY_RULE_SETUP
1608 #line 258 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1609 { RET_TOK(BinaryOpVal, AShr, ASHR); }
1610         YY_BREAK
1611 case 67:
1612 YY_RULE_SETUP
1613 #line 259 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1614 { RET_TOK(BinaryOpVal, And, AND); }
1615         YY_BREAK
1616 case 68:
1617 YY_RULE_SETUP
1618 #line 260 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1619 { RET_TOK(BinaryOpVal, Or , OR ); }
1620         YY_BREAK
1621 case 69:
1622 YY_RULE_SETUP
1623 #line 261 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1624 { RET_TOK(BinaryOpVal, Xor, XOR); }
1625         YY_BREAK
1626 case 70:
1627 YY_RULE_SETUP
1628 #line 262 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1629 { RET_TOK(OtherOpVal,  ICmp,  ICMP); }
1630         YY_BREAK
1631 case 71:
1632 YY_RULE_SETUP
1633 #line 263 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1634 { RET_TOK(OtherOpVal,  FCmp,  FCMP); }
1635         YY_BREAK
1636 case 72:
1637 YY_RULE_SETUP
1638 #line 265 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1639 { return EQ;  }
1640         YY_BREAK
1641 case 73:
1642 YY_RULE_SETUP
1643 #line 266 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1644 { return NE;  }
1645         YY_BREAK
1646 case 74:
1647 YY_RULE_SETUP
1648 #line 267 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1649 { return SLT; }
1650         YY_BREAK
1651 case 75:
1652 YY_RULE_SETUP
1653 #line 268 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1654 { return SGT; }
1655         YY_BREAK
1656 case 76:
1657 YY_RULE_SETUP
1658 #line 269 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1659 { return SLE; }
1660         YY_BREAK
1661 case 77:
1662 YY_RULE_SETUP
1663 #line 270 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1664 { return SGE; }
1665         YY_BREAK
1666 case 78:
1667 YY_RULE_SETUP
1668 #line 271 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1669 { return ULT; }
1670         YY_BREAK
1671 case 79:
1672 YY_RULE_SETUP
1673 #line 272 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1674 { return UGT; }
1675         YY_BREAK
1676 case 80:
1677 YY_RULE_SETUP
1678 #line 273 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1679 { return ULE; }
1680         YY_BREAK
1681 case 81:
1682 YY_RULE_SETUP
1683 #line 274 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1684 { return UGE; }
1685         YY_BREAK
1686 case 82:
1687 YY_RULE_SETUP
1688 #line 275 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1689 { return OEQ; }
1690         YY_BREAK
1691 case 83:
1692 YY_RULE_SETUP
1693 #line 276 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1694 { return ONE; }
1695         YY_BREAK
1696 case 84:
1697 YY_RULE_SETUP
1698 #line 277 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1699 { return OLT; }
1700         YY_BREAK
1701 case 85:
1702 YY_RULE_SETUP
1703 #line 278 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1704 { return OGT; }
1705         YY_BREAK
1706 case 86:
1707 YY_RULE_SETUP
1708 #line 279 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1709 { return OLE; }
1710         YY_BREAK
1711 case 87:
1712 YY_RULE_SETUP
1713 #line 280 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1714 { return OGE; }
1715         YY_BREAK
1716 case 88:
1717 YY_RULE_SETUP
1718 #line 281 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1719 { return ORD; }
1720         YY_BREAK
1721 case 89:
1722 YY_RULE_SETUP
1723 #line 282 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1724 { return UNO; }
1725         YY_BREAK
1726 case 90:
1727 YY_RULE_SETUP
1728 #line 283 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1729 { return UEQ; }
1730         YY_BREAK
1731 case 91:
1732 YY_RULE_SETUP
1733 #line 284 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1734 { return UNE; }
1735         YY_BREAK
1736 case 92:
1737 YY_RULE_SETUP
1738 #line 286 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1739 { RET_TOK(OtherOpVal, PHI, PHI_TOK); }
1740         YY_BREAK
1741 case 93:
1742 YY_RULE_SETUP
1743 #line 287 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1744 { RET_TOK(OtherOpVal, Call, CALL); }
1745         YY_BREAK
1746 case 94:
1747 YY_RULE_SETUP
1748 #line 288 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1749 { RET_TOK(CastOpVal, Trunc, TRUNC); }
1750         YY_BREAK
1751 case 95:
1752 YY_RULE_SETUP
1753 #line 289 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1754 { RET_TOK(CastOpVal, ZExt, ZEXT); }
1755         YY_BREAK
1756 case 96:
1757 YY_RULE_SETUP
1758 #line 290 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1759 { RET_TOK(CastOpVal, SExt, SEXT); }
1760         YY_BREAK
1761 case 97:
1762 YY_RULE_SETUP
1763 #line 291 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1764 { RET_TOK(CastOpVal, FPTrunc, FPTRUNC); }
1765         YY_BREAK
1766 case 98:
1767 YY_RULE_SETUP
1768 #line 292 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1769 { RET_TOK(CastOpVal, FPExt, FPEXT); }
1770         YY_BREAK
1771 case 99:
1772 YY_RULE_SETUP
1773 #line 293 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1774 { RET_TOK(CastOpVal, UIToFP, UITOFP); }
1775         YY_BREAK
1776 case 100:
1777 YY_RULE_SETUP
1778 #line 294 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1779 { RET_TOK(CastOpVal, SIToFP, SITOFP); }
1780         YY_BREAK
1781 case 101:
1782 YY_RULE_SETUP
1783 #line 295 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1784 { RET_TOK(CastOpVal, FPToUI, FPTOUI); }
1785         YY_BREAK
1786 case 102:
1787 YY_RULE_SETUP
1788 #line 296 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1789 { RET_TOK(CastOpVal, FPToSI, FPTOSI); }
1790         YY_BREAK
1791 case 103:
1792 YY_RULE_SETUP
1793 #line 297 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1794 { RET_TOK(CastOpVal, IntToPtr, INTTOPTR); }
1795         YY_BREAK
1796 case 104:
1797 YY_RULE_SETUP
1798 #line 298 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1799 { RET_TOK(CastOpVal, PtrToInt, PTRTOINT); }
1800         YY_BREAK
1801 case 105:
1802 YY_RULE_SETUP
1803 #line 299 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1804 { RET_TOK(CastOpVal, BitCast, BITCAST); }
1805         YY_BREAK
1806 case 106:
1807 YY_RULE_SETUP
1808 #line 300 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1809 { RET_TOK(OtherOpVal, Select, SELECT); }
1810         YY_BREAK
1811 case 107:
1812 YY_RULE_SETUP
1813 #line 301 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1814 { RET_TOK(OtherOpVal, VAArg , VAARG); }
1815         YY_BREAK
1816 case 108:
1817 YY_RULE_SETUP
1818 #line 302 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1819 { RET_TOK(TermOpVal, Ret, RET); }
1820         YY_BREAK
1821 case 109:
1822 YY_RULE_SETUP
1823 #line 303 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1824 { RET_TOK(TermOpVal, Br, BR); }
1825         YY_BREAK
1826 case 110:
1827 YY_RULE_SETUP
1828 #line 304 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1829 { RET_TOK(TermOpVal, Switch, SWITCH); }
1830         YY_BREAK
1831 case 111:
1832 YY_RULE_SETUP
1833 #line 305 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1834 { RET_TOK(TermOpVal, Invoke, INVOKE); }
1835         YY_BREAK
1836 case 112:
1837 YY_RULE_SETUP
1838 #line 306 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1839 { RET_TOK(TermOpVal, Unwind, UNWIND); }
1840         YY_BREAK
1841 case 113:
1842 YY_RULE_SETUP
1843 #line 307 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1844 { RET_TOK(TermOpVal, Unreachable, UNREACHABLE); }
1845         YY_BREAK
1846 case 114:
1847 YY_RULE_SETUP
1848 #line 309 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1849 { RET_TOK(MemOpVal, Malloc, MALLOC); }
1850         YY_BREAK
1851 case 115:
1852 YY_RULE_SETUP
1853 #line 310 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1854 { RET_TOK(MemOpVal, Alloca, ALLOCA); }
1855         YY_BREAK
1856 case 116:
1857 YY_RULE_SETUP
1858 #line 311 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1859 { RET_TOK(MemOpVal, Free, FREE); }
1860         YY_BREAK
1861 case 117:
1862 YY_RULE_SETUP
1863 #line 312 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1864 { RET_TOK(MemOpVal, Load, LOAD); }
1865         YY_BREAK
1866 case 118:
1867 YY_RULE_SETUP
1868 #line 313 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1869 { RET_TOK(MemOpVal, Store, STORE); }
1870         YY_BREAK
1871 case 119:
1872 YY_RULE_SETUP
1873 #line 314 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1874 { RET_TOK(MemOpVal, GetElementPtr, GETELEMENTPTR); }
1875         YY_BREAK
1876 case 120:
1877 YY_RULE_SETUP
1878 #line 316 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1879 { RET_TOK(OtherOpVal, ExtractElement, EXTRACTELEMENT); }
1880         YY_BREAK
1881 case 121:
1882 YY_RULE_SETUP
1883 #line 317 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1884 { RET_TOK(OtherOpVal, InsertElement, INSERTELEMENT); }
1885         YY_BREAK
1886 case 122:
1887 YY_RULE_SETUP
1888 #line 318 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1889 { RET_TOK(OtherOpVal, ShuffleVector, SHUFFLEVECTOR); }
1890         YY_BREAK
1891 case 123:
1892 YY_RULE_SETUP
1893 #line 321 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1894 {
1895                   llvmAsmlval.StrVal = new std::string(yytext+1);   // Skip %
1896                   return LOCALVAR;
1897                 }
1898         YY_BREAK
1899 case 124:
1900 YY_RULE_SETUP
1901 #line 325 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1902 {
1903                   llvmAsmlval.StrVal = new std::string(yytext+1);   // Skip @
1904                   return GLOBALVAR;
1905                 }
1906         YY_BREAK
1907 case 125:
1908 YY_RULE_SETUP
1909 #line 329 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1910 {
1911                   yytext[yyleng-1] = 0;            // nuke colon
1912                   llvmAsmlval.StrVal = new std::string(yytext);
1913                   return LABELSTR;
1914                 }
1915         YY_BREAK
1916 case 126:
1917 YY_RULE_SETUP
1918 #line 334 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1919 {
1920                   yytext[yyleng-2] = 0;  // nuke colon, end quote
1921                   const char* EndChar = UnEscapeLexed(yytext+1, yytext+yyleng);
1922                   llvmAsmlval.StrVal =
1923                     new std::string(yytext+1, EndChar - yytext - 1);
1924                   return LABELSTR;
1925                 }
1926         YY_BREAK
1927 case 127:
1928 YY_RULE_SETUP
1929 #line 342 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1930 { yytext[yyleng-1] = 0;           // nuke end quote
1931                    const char* EndChar = UnEscapeLexed(yytext+1, yytext+yyleng);
1932                    llvmAsmlval.StrVal =
1933                      new std::string(yytext+1, EndChar - yytext - 1);
1934                    return STRINGCONSTANT;
1935                  }
1936         YY_BREAK
1937 case 128:
1938 YY_RULE_SETUP
1939 #line 348 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1940 {
1941                      yytext[yyleng-1] = 0;         // nuke end quote
1942                      const char* EndChar =
1943                        UnEscapeLexed(yytext+2, yytext+yyleng);
1944                      llvmAsmlval.StrVal =
1945                        new std::string(yytext+2, EndChar - yytext - 2);
1946                      return ATSTRINGCONSTANT;
1947                    }
1948         YY_BREAK
1949 case 129:
1950 YY_RULE_SETUP
1951 #line 356 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1952 {
1953                      yytext[yyleng-1] = 0;           // nuke end quote
1954                      const char* EndChar =
1955                        UnEscapeLexed(yytext+2, yytext+yyleng);
1956                      llvmAsmlval.StrVal =
1957                        new std::string(yytext+2, EndChar - yytext - 2);
1958                      return PCTSTRINGCONSTANT;
1959                    }
1960         YY_BREAK
1961 case 130:
1962 YY_RULE_SETUP
1963 #line 364 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1964 {
1965                   uint32_t numBits = ((yyleng * 64) / 19) + 1;
1966                   APInt Tmp(numBits, yytext, yyleng, 10);
1967                   uint32_t activeBits = Tmp.getActiveBits();
1968                   if (activeBits > 0 && activeBits < numBits)
1969                     Tmp.trunc(activeBits);
1970                   if (Tmp.getBitWidth() > 64) {
1971                     llvmAsmlval.APIntVal = new APInt(Tmp);
1972                     return EUAPINTVAL;
1973                   } else {
1974                     llvmAsmlval.UInt64Val = Tmp.getZExtValue();
1975                     return EUINT64VAL;
1976                   }
1977                 }
1978         YY_BREAK
1979 case 131:
1980 YY_RULE_SETUP
1981 #line 378 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
1982 {
1983                   uint32_t numBits = (((yyleng-1) * 64) / 19) + 2;
1984                   APInt Tmp(numBits, yytext, yyleng, 10);
1985                   uint32_t minBits = Tmp.getMinSignedBits();
1986                   if (minBits > 0 && minBits < numBits)
1987                     Tmp.trunc(minBits);
1988                   if (Tmp.getBitWidth() > 64) {
1989                     llvmAsmlval.APIntVal = new APInt(Tmp);
1990                     return ESAPINTVAL;
1991                   } else {
1992                     llvmAsmlval.SInt64Val = Tmp.getSExtValue();
1993                     return ESINT64VAL;
1994                   }
1995                 }
1996         YY_BREAK
1997 case 132:
1998 YY_RULE_SETUP
1999 #line 393 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
2000 { int len = yyleng - 3;
2001                    uint32_t bits = len * 4;
2002                    APInt Tmp(bits, yytext+3, len, 16);
2003                    uint32_t activeBits = Tmp.getActiveBits();
2004                    if (activeBits > 0 && activeBits < bits)
2005                      Tmp.trunc(activeBits);
2006                    if (Tmp.getBitWidth() > 64) {
2007                      llvmAsmlval.APIntVal = new APInt(Tmp);
2008                      return yytext[0] == 's' ? ESAPINTVAL : EUAPINTVAL;
2009                    } else if (yytext[0] == 's') {
2010                      llvmAsmlval.SInt64Val = Tmp.getSExtValue();
2011                      return ESINT64VAL;
2012                    } else {
2013                      llvmAsmlval.UInt64Val = Tmp.getZExtValue();
2014                      return EUINT64VAL;
2015                    }
2016                  }
2017         YY_BREAK
2018 case 133:
2019 YY_RULE_SETUP
2020 #line 411 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
2021 {
2022                   uint64_t Val = atoull(yytext+1);
2023                   if ((unsigned)Val != Val)
2024                     GenerateError("Invalid value number (too large)!");
2025                   llvmAsmlval.UIntVal = unsigned(Val);
2026                   return LOCALVAL_ID;
2027                 }
2028         YY_BREAK
2029 case 134:
2030 YY_RULE_SETUP
2031 #line 418 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
2032 {
2033                   uint64_t Val = atoull(yytext+1);
2034                   if ((unsigned)Val != Val)
2035                     GenerateError("Invalid value number (too large)!");
2036                   llvmAsmlval.UIntVal = unsigned(Val);
2037                   return GLOBALVAL_ID;
2038                 }
2039         YY_BREAK
2040 case 135:
2041 YY_RULE_SETUP
2042 #line 426 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
2043 { llvmAsmlval.FPVal = atof(yytext); return FPVAL; }
2044         YY_BREAK
2045 case 136:
2046 YY_RULE_SETUP
2047 #line 427 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
2048 { llvmAsmlval.FPVal = HexToFP(yytext); return FPVAL; }
2049         YY_BREAK
2050 case YY_STATE_EOF(INITIAL):
2051 #line 429 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
2052 {
2053                   /* Make sure to free the internal buffers for flex when we are
2054                    * done reading our input!
2055                    */
2056                   yy_delete_buffer(YY_CURRENT_BUFFER);
2057                   return EOF;
2058                 }
2059         YY_BREAK
2060 case 137:
2061 YY_RULE_SETUP
2062 #line 437 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
2063 { /* Ignore whitespace */ }
2064         YY_BREAK
2065 case 138:
2066 YY_RULE_SETUP
2067 #line 438 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
2068 { return yytext[0]; }
2069         YY_BREAK
2070 case 139:
2071 YY_RULE_SETUP
2072 #line 440 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
2073 YY_FATAL_ERROR( "flex scanner jammed" );
2074         YY_BREAK
2075 #line 2076 "Lexer.cpp"
2076
2077         case YY_END_OF_BUFFER:
2078                 {
2079                 /* Amount of text matched not including the EOB char. */
2080                 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
2081
2082                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
2083                 *yy_cp = yy_hold_char;
2084                 YY_RESTORE_YY_MORE_OFFSET
2085
2086                 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
2087                         {
2088                         /* We're scanning a new file or input source.  It's
2089                          * possible that this happened because the user
2090                          * just pointed yyin at a new source and called
2091                          * yylex().  If so, then we have to assure
2092                          * consistency between yy_current_buffer and our
2093                          * globals.  Here is the right place to do so, because
2094                          * this is the first action (other than possibly a
2095                          * back-up) that will match for the new input source.
2096                          */
2097                         yy_n_chars = yy_current_buffer->yy_n_chars;
2098                         yy_current_buffer->yy_input_file = yyin;
2099                         yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
2100                         }
2101
2102                 /* Note that here we test for yy_c_buf_p "<=" to the position
2103                  * of the first EOB in the buffer, since yy_c_buf_p will
2104                  * already have been incremented past the NUL character
2105                  * (since all states make transitions on EOB to the
2106                  * end-of-buffer state).  Contrast this with the test
2107                  * in input().
2108                  */
2109                 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
2110                         { /* This was really a NUL. */
2111                         yy_state_type yy_next_state;
2112
2113                         yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
2114
2115                         yy_current_state = yy_get_previous_state();
2116
2117                         /* Okay, we're now positioned to make the NUL
2118                          * transition.  We couldn't have
2119                          * yy_get_previous_state() go ahead and do it
2120                          * for us because it doesn't know how to deal
2121                          * with the possibility of jamming (and we don't
2122                          * want to build jamming into it because then it
2123                          * will run more slowly).
2124                          */
2125
2126                         yy_next_state = yy_try_NUL_trans( yy_current_state );
2127
2128                         yy_bp = yytext_ptr + YY_MORE_ADJ;
2129
2130                         if ( yy_next_state )
2131                                 {
2132                                 /* Consume the NUL. */
2133                                 yy_cp = ++yy_c_buf_p;
2134                                 yy_current_state = yy_next_state;
2135                                 goto yy_match;
2136                                 }
2137
2138                         else
2139                                 {
2140                                 yy_cp = yy_c_buf_p;
2141                                 goto yy_find_action;
2142                                 }
2143                         }
2144
2145                 else switch ( yy_get_next_buffer() )
2146                         {
2147                         case EOB_ACT_END_OF_FILE:
2148                                 {
2149                                 yy_did_buffer_switch_on_eof = 0;
2150
2151                                 if ( yywrap() )
2152                                         {
2153                                         /* Note: because we've taken care in
2154                                          * yy_get_next_buffer() to have set up
2155                                          * yytext, we can now set up
2156                                          * yy_c_buf_p so that if some total
2157                                          * hoser (like flex itself) wants to
2158                                          * call the scanner after we return the
2159                                          * YY_NULL, it'll still work - another
2160                                          * YY_NULL will get returned.
2161                                          */
2162                                         yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
2163
2164                                         yy_act = YY_STATE_EOF(YY_START);
2165                                         goto do_action;
2166                                         }
2167
2168                                 else
2169                                         {
2170                                         if ( ! yy_did_buffer_switch_on_eof )
2171                                                 YY_NEW_FILE;
2172                                         }
2173                                 break;
2174                                 }
2175
2176                         case EOB_ACT_CONTINUE_SCAN:
2177                                 yy_c_buf_p =
2178                                         yytext_ptr + yy_amount_of_matched_text;
2179
2180                                 yy_current_state = yy_get_previous_state();
2181
2182                                 yy_cp = yy_c_buf_p;
2183                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
2184                                 goto yy_match;
2185
2186                         case EOB_ACT_LAST_MATCH:
2187                                 yy_c_buf_p =
2188                                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
2189
2190                                 yy_current_state = yy_get_previous_state();
2191
2192                                 yy_cp = yy_c_buf_p;
2193                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
2194                                 goto yy_find_action;
2195                         }
2196                 break;
2197                 }
2198
2199         default:
2200                 YY_FATAL_ERROR(
2201                         "fatal flex scanner internal error--no action found" );
2202         } /* end of action switch */
2203                 } /* end of scanning one token */
2204         } /* end of yylex */
2205
2206
2207 /* yy_get_next_buffer - try to read in a new buffer
2208  *
2209  * Returns a code representing an action:
2210  *      EOB_ACT_LAST_MATCH -
2211  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
2212  *      EOB_ACT_END_OF_FILE - end of file
2213  */
2214
2215 static int yy_get_next_buffer()
2216         {
2217         register char *dest = yy_current_buffer->yy_ch_buf;
2218         register char *source = yytext_ptr;
2219         register int number_to_move, i;
2220         int ret_val;
2221
2222         if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
2223                 YY_FATAL_ERROR(
2224                 "fatal flex scanner internal error--end of buffer missed" );
2225
2226         if ( yy_current_buffer->yy_fill_buffer == 0 )
2227                 { /* Don't try to fill the buffer, so this is an EOF. */
2228                 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
2229                         {
2230                         /* We matched a single character, the EOB, so
2231                          * treat this as a final EOF.
2232                          */
2233                         return EOB_ACT_END_OF_FILE;
2234                         }
2235
2236                 else
2237                         {
2238                         /* We matched some text prior to the EOB, first
2239                          * process it.
2240                          */
2241                         return EOB_ACT_LAST_MATCH;
2242                         }
2243                 }
2244
2245         /* Try to read more data. */
2246
2247         /* First move last chars to start of buffer. */
2248         number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
2249
2250         for ( i = 0; i < number_to_move; ++i )
2251                 *(dest++) = *(source++);
2252
2253         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
2254                 /* don't do the read, it's not guaranteed to return an EOF,
2255                  * just force an EOF
2256                  */
2257                 yy_current_buffer->yy_n_chars = yy_n_chars = 0;
2258
2259         else
2260                 {
2261                 int num_to_read =
2262                         yy_current_buffer->yy_buf_size - number_to_move - 1;
2263
2264                 while ( num_to_read <= 0 )
2265                         { /* Not enough room in the buffer - grow it. */
2266 #ifdef YY_USES_REJECT
2267                         YY_FATAL_ERROR(
2268 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
2269 #else
2270
2271                         /* just a shorter name for the current buffer */
2272                         YY_BUFFER_STATE b = yy_current_buffer;
2273
2274                         int yy_c_buf_p_offset =
2275                                 (int) (yy_c_buf_p - b->yy_ch_buf);
2276
2277                         if ( b->yy_is_our_buffer )
2278                                 {
2279                                 int new_size = b->yy_buf_size * 2;
2280
2281                                 if ( new_size <= 0 )
2282                                         b->yy_buf_size += b->yy_buf_size / 8;
2283                                 else
2284                                         b->yy_buf_size *= 2;
2285
2286                                 b->yy_ch_buf = (char *)
2287                                         /* Include room in for 2 EOB chars. */
2288                                         yy_flex_realloc( (void *) b->yy_ch_buf,
2289                                                          b->yy_buf_size + 2 );
2290                                 }
2291                         else
2292                                 /* Can't grow it, we don't own it. */
2293                                 b->yy_ch_buf = 0;
2294
2295                         if ( ! b->yy_ch_buf )
2296                                 YY_FATAL_ERROR(
2297                                 "fatal error - scanner input buffer overflow" );
2298
2299                         yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
2300
2301                         num_to_read = yy_current_buffer->yy_buf_size -
2302                                                 number_to_move - 1;
2303 #endif
2304                         }
2305
2306                 if ( num_to_read > YY_READ_BUF_SIZE )
2307                         num_to_read = YY_READ_BUF_SIZE;
2308
2309                 /* Read in more data. */
2310                 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
2311                         yy_n_chars, num_to_read );
2312
2313                 yy_current_buffer->yy_n_chars = yy_n_chars;
2314                 }
2315
2316         if ( yy_n_chars == 0 )
2317                 {
2318                 if ( number_to_move == YY_MORE_ADJ )
2319                         {
2320                         ret_val = EOB_ACT_END_OF_FILE;
2321                         yyrestart( yyin );
2322                         }
2323
2324                 else
2325                         {
2326                         ret_val = EOB_ACT_LAST_MATCH;
2327                         yy_current_buffer->yy_buffer_status =
2328                                 YY_BUFFER_EOF_PENDING;
2329                         }
2330                 }
2331
2332         else
2333                 ret_val = EOB_ACT_CONTINUE_SCAN;
2334
2335         yy_n_chars += number_to_move;
2336         yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
2337         yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
2338
2339         yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
2340
2341         return ret_val;
2342         }
2343
2344
2345 /* yy_get_previous_state - get the state just before the EOB char was reached */
2346
2347 static yy_state_type yy_get_previous_state()
2348         {
2349         register yy_state_type yy_current_state;
2350         register char *yy_cp;
2351
2352         yy_current_state = yy_start;
2353         yy_state_ptr = yy_state_buf;
2354         *yy_state_ptr++ = yy_current_state;
2355
2356         for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
2357                 {
2358                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
2359                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2360                         {
2361                         yy_current_state = (int) yy_def[yy_current_state];
2362                         if ( yy_current_state >= 563 )
2363                                 yy_c = yy_meta[(unsigned int) yy_c];
2364                         }
2365                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2366                 *yy_state_ptr++ = yy_current_state;
2367                 }
2368
2369         return yy_current_state;
2370         }
2371
2372
2373 /* yy_try_NUL_trans - try to make a transition on the NUL character
2374  *
2375  * synopsis
2376  *      next_state = yy_try_NUL_trans( current_state );
2377  */
2378
2379 #ifdef YY_USE_PROTOS
2380 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
2381 #else
2382 static yy_state_type yy_try_NUL_trans( yy_current_state )
2383 yy_state_type yy_current_state;
2384 #endif
2385         {
2386         register int yy_is_jam;
2387
2388         register YY_CHAR yy_c = 1;
2389         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2390                 {
2391                 yy_current_state = (int) yy_def[yy_current_state];
2392                 if ( yy_current_state >= 563 )
2393                         yy_c = yy_meta[(unsigned int) yy_c];
2394                 }
2395         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2396         yy_is_jam = (yy_current_state == 562);
2397         if ( ! yy_is_jam )
2398                 *yy_state_ptr++ = yy_current_state;
2399
2400         return yy_is_jam ? 0 : yy_current_state;
2401         }
2402
2403
2404 #ifndef YY_NO_UNPUT
2405 #ifdef YY_USE_PROTOS
2406 static inline void yyunput( int c, register char *yy_bp )
2407 #else
2408 static inline void yyunput( c, yy_bp )
2409 int c;
2410 register char *yy_bp;
2411 #endif
2412         {
2413         register char *yy_cp = yy_c_buf_p;
2414
2415         /* undo effects of setting up yytext */
2416         *yy_cp = yy_hold_char;
2417
2418         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
2419                 { /* need to shift things up to make room */
2420                 /* +2 for EOB chars. */
2421                 register int number_to_move = yy_n_chars + 2;
2422                 register char *dest = &yy_current_buffer->yy_ch_buf[
2423                                         yy_current_buffer->yy_buf_size + 2];
2424                 register char *source =
2425                                 &yy_current_buffer->yy_ch_buf[number_to_move];
2426
2427                 while ( source > yy_current_buffer->yy_ch_buf )
2428                         *--dest = *--source;
2429
2430                 yy_cp += (int) (dest - source);
2431                 yy_bp += (int) (dest - source);
2432                 yy_current_buffer->yy_n_chars =
2433                         yy_n_chars = yy_current_buffer->yy_buf_size;
2434
2435                 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
2436                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
2437                 }
2438
2439         *--yy_cp = (char) c;
2440
2441         if ( c == '\n' )
2442                 --yylineno;
2443
2444         yytext_ptr = yy_bp;
2445         yy_hold_char = *yy_cp;
2446         yy_c_buf_p = yy_cp;
2447         }
2448 #endif  /* ifndef YY_NO_UNPUT */
2449
2450
2451 #ifndef YY_NO_INPUT
2452 #ifdef __cplusplus
2453 static int yyinput()
2454 #else
2455 static int input()
2456 #endif
2457         {
2458         int c;
2459
2460         *yy_c_buf_p = yy_hold_char;
2461
2462         if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
2463                 {
2464                 /* yy_c_buf_p now points to the character we want to return.
2465                  * If this occurs *before* the EOB characters, then it's a
2466                  * valid NUL; if not, then we've hit the end of the buffer.
2467                  */
2468                 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
2469                         /* This was really a NUL. */
2470                         *yy_c_buf_p = '\0';
2471
2472                 else
2473                         { /* need more input */
2474                         int offset = yy_c_buf_p - yytext_ptr;
2475                         ++yy_c_buf_p;
2476
2477                         switch ( yy_get_next_buffer() )
2478                                 {
2479                                 case EOB_ACT_LAST_MATCH:
2480                                         /* This happens because yy_g_n_b()
2481                                          * sees that we've accumulated a
2482                                          * token and flags that we need to
2483                                          * try matching the token before
2484                                          * proceeding.  But for input(),
2485                                          * there's no matching to consider.
2486                                          * So convert the EOB_ACT_LAST_MATCH
2487                                          * to EOB_ACT_END_OF_FILE.
2488                                          */
2489
2490                                         /* Reset buffer status. */
2491                                         yyrestart( yyin );
2492
2493                                         /* fall through */
2494
2495                                 case EOB_ACT_END_OF_FILE:
2496                                         {
2497                                         if ( yywrap() )
2498                                                 return EOF;
2499
2500                                         if ( ! yy_did_buffer_switch_on_eof )
2501                                                 YY_NEW_FILE;
2502 #ifdef __cplusplus
2503                                         return yyinput();
2504 #else
2505                                         return input();
2506 #endif
2507                                         }
2508
2509                                 case EOB_ACT_CONTINUE_SCAN:
2510                                         yy_c_buf_p = yytext_ptr + offset;
2511                                         break;
2512                                 }
2513                         }
2514                 }
2515
2516         c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */
2517         *yy_c_buf_p = '\0';     /* preserve yytext */
2518         yy_hold_char = *++yy_c_buf_p;
2519
2520         if ( c == '\n' )
2521                 ++yylineno;
2522
2523         return c;
2524         }
2525 #endif /* YY_NO_INPUT */
2526
2527 #ifdef YY_USE_PROTOS
2528 void yyrestart( FILE *input_file )
2529 #else
2530 void yyrestart( input_file )
2531 FILE *input_file;
2532 #endif
2533         {
2534         if ( ! yy_current_buffer )
2535                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
2536
2537         yy_init_buffer( yy_current_buffer, input_file );
2538         yy_load_buffer_state();
2539         }
2540
2541
2542 #ifdef YY_USE_PROTOS
2543 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
2544 #else
2545 void yy_switch_to_buffer( new_buffer )
2546 YY_BUFFER_STATE new_buffer;
2547 #endif
2548         {
2549         if ( yy_current_buffer == new_buffer )
2550                 return;
2551
2552         if ( yy_current_buffer )
2553                 {
2554                 /* Flush out information for old buffer. */
2555                 *yy_c_buf_p = yy_hold_char;
2556                 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
2557                 yy_current_buffer->yy_n_chars = yy_n_chars;
2558                 }
2559
2560         yy_current_buffer = new_buffer;
2561         yy_load_buffer_state();
2562
2563         /* We don't actually know whether we did this switch during
2564          * EOF (yywrap()) processing, but the only time this flag
2565          * is looked at is after yywrap() is called, so it's safe
2566          * to go ahead and always set it.
2567          */
2568         yy_did_buffer_switch_on_eof = 1;
2569         }
2570
2571
2572 #ifdef YY_USE_PROTOS
2573 void yy_load_buffer_state( void )
2574 #else
2575 void yy_load_buffer_state()
2576 #endif
2577         {
2578         yy_n_chars = yy_current_buffer->yy_n_chars;
2579         yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
2580         yyin = yy_current_buffer->yy_input_file;
2581         yy_hold_char = *yy_c_buf_p;
2582         }
2583
2584
2585 #ifdef YY_USE_PROTOS
2586 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
2587 #else
2588 YY_BUFFER_STATE yy_create_buffer( file, size )
2589 FILE *file;
2590 int size;
2591 #endif
2592         {
2593         YY_BUFFER_STATE b;
2594
2595         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
2596         if ( ! b )
2597                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2598
2599         b->yy_buf_size = size;
2600
2601         /* yy_ch_buf has to be 2 characters longer than the size given because
2602          * we need to put in 2 end-of-buffer characters.
2603          */
2604         b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
2605         if ( ! b->yy_ch_buf )
2606                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2607
2608         b->yy_is_our_buffer = 1;
2609
2610         yy_init_buffer( b, file );
2611
2612         return b;
2613         }
2614
2615
2616 #ifdef YY_USE_PROTOS
2617 void yy_delete_buffer( YY_BUFFER_STATE b )
2618 #else
2619 void yy_delete_buffer( b )
2620 YY_BUFFER_STATE b;
2621 #endif
2622         {
2623         if ( ! b )
2624                 return;
2625
2626         if ( b == yy_current_buffer )
2627                 yy_current_buffer = (YY_BUFFER_STATE) 0;
2628
2629         if ( b->yy_is_our_buffer )
2630                 yy_flex_free( (void *) b->yy_ch_buf );
2631
2632         yy_flex_free( (void *) b );
2633         }
2634
2635
2636
2637 #ifdef YY_USE_PROTOS
2638 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
2639 #else
2640 void yy_init_buffer( b, file )
2641 YY_BUFFER_STATE b;
2642 FILE *file;
2643 #endif
2644
2645
2646         {
2647         yy_flush_buffer( b );
2648
2649         b->yy_input_file = file;
2650         b->yy_fill_buffer = 1;
2651
2652 #if YY_ALWAYS_INTERACTIVE
2653         b->yy_is_interactive = 1;
2654 #else
2655 #if YY_NEVER_INTERACTIVE
2656         b->yy_is_interactive = 0;
2657 #else
2658         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
2659 #endif
2660 #endif
2661         }
2662
2663
2664 #ifdef YY_USE_PROTOS
2665 void yy_flush_buffer( YY_BUFFER_STATE b )
2666 #else
2667 void yy_flush_buffer( b )
2668 YY_BUFFER_STATE b;
2669 #endif
2670
2671         {
2672         if ( ! b )
2673                 return;
2674
2675         b->yy_n_chars = 0;
2676
2677         /* We always need two end-of-buffer characters.  The first causes
2678          * a transition to the end-of-buffer state.  The second causes
2679          * a jam in that state.
2680          */
2681         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2682         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2683
2684         b->yy_buf_pos = &b->yy_ch_buf[0];
2685
2686         b->yy_at_bol = 1;
2687         b->yy_buffer_status = YY_BUFFER_NEW;
2688
2689         if ( b == yy_current_buffer )
2690                 yy_load_buffer_state();
2691         }
2692
2693
2694 #ifndef YY_NO_SCAN_BUFFER
2695 #ifdef YY_USE_PROTOS
2696 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
2697 #else
2698 YY_BUFFER_STATE yy_scan_buffer( base, size )
2699 char *base;
2700 yy_size_t size;
2701 #endif
2702         {
2703         YY_BUFFER_STATE b;
2704
2705         if ( size < 2 ||
2706              base[size-2] != YY_END_OF_BUFFER_CHAR ||
2707              base[size-1] != YY_END_OF_BUFFER_CHAR )
2708                 /* They forgot to leave room for the EOB's. */
2709                 return 0;
2710
2711         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
2712         if ( ! b )
2713                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
2714
2715         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
2716         b->yy_buf_pos = b->yy_ch_buf = base;
2717         b->yy_is_our_buffer = 0;
2718         b->yy_input_file = 0;
2719         b->yy_n_chars = b->yy_buf_size;
2720         b->yy_is_interactive = 0;
2721         b->yy_at_bol = 1;
2722         b->yy_fill_buffer = 0;
2723         b->yy_buffer_status = YY_BUFFER_NEW;
2724
2725         yy_switch_to_buffer( b );
2726
2727         return b;
2728         }
2729 #endif
2730
2731
2732 #ifndef YY_NO_SCAN_STRING
2733 #ifdef YY_USE_PROTOS
2734 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
2735 #else
2736 YY_BUFFER_STATE yy_scan_string( yy_str )
2737 yyconst char *yy_str;
2738 #endif
2739         {
2740         int len;
2741         for ( len = 0; yy_str[len]; ++len )
2742                 ;
2743
2744         return yy_scan_bytes( yy_str, len );
2745         }
2746 #endif
2747
2748
2749 #ifndef YY_NO_SCAN_BYTES
2750 #ifdef YY_USE_PROTOS
2751 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
2752 #else
2753 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
2754 yyconst char *bytes;
2755 int len;
2756 #endif
2757         {
2758         YY_BUFFER_STATE b;
2759         char *buf;
2760         yy_size_t n;
2761         int i;
2762
2763         /* Get memory for full buffer, including space for trailing EOB's. */
2764         n = len + 2;
2765         buf = (char *) yy_flex_alloc( n );
2766         if ( ! buf )
2767                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
2768
2769         for ( i = 0; i < len; ++i )
2770                 buf[i] = bytes[i];
2771
2772         buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
2773
2774         b = yy_scan_buffer( buf, n );
2775         if ( ! b )
2776                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2777
2778         /* It's okay to grow etc. this buffer, and we should throw it
2779          * away when we're done.
2780          */
2781         b->yy_is_our_buffer = 1;
2782
2783         return b;
2784         }
2785 #endif
2786
2787
2788 #ifndef YY_NO_PUSH_STATE
2789 #ifdef YY_USE_PROTOS
2790 static void yy_push_state( int new_state )
2791 #else
2792 static void yy_push_state( new_state )
2793 int new_state;
2794 #endif
2795         {
2796         if ( yy_start_stack_ptr >= yy_start_stack_depth )
2797                 {
2798                 yy_size_t new_size;
2799
2800                 yy_start_stack_depth += YY_START_STACK_INCR;
2801                 new_size = yy_start_stack_depth * sizeof( int );
2802
2803                 if ( ! yy_start_stack )
2804                         yy_start_stack = (int *) yy_flex_alloc( new_size );
2805
2806                 else
2807                         yy_start_stack = (int *) yy_flex_realloc(
2808                                         (void *) yy_start_stack, new_size );
2809
2810                 if ( ! yy_start_stack )
2811                         YY_FATAL_ERROR(
2812                         "out of memory expanding start-condition stack" );
2813                 }
2814
2815         yy_start_stack[yy_start_stack_ptr++] = YY_START;
2816
2817         BEGIN(new_state);
2818         }
2819 #endif
2820
2821
2822 #ifndef YY_NO_POP_STATE
2823 static void yy_pop_state()
2824         {
2825         if ( --yy_start_stack_ptr < 0 )
2826                 YY_FATAL_ERROR( "start-condition stack underflow" );
2827
2828         BEGIN(yy_start_stack[yy_start_stack_ptr]);
2829         }
2830 #endif
2831
2832
2833 #ifndef YY_NO_TOP_STATE
2834 static int yy_top_state()
2835         {
2836         return yy_start_stack[yy_start_stack_ptr - 1];
2837         }
2838 #endif
2839
2840 #ifndef YY_EXIT_FAILURE
2841 #define YY_EXIT_FAILURE 2
2842 #endif
2843
2844 #ifdef YY_USE_PROTOS
2845 static void yy_fatal_error( yyconst char msg[] )
2846 #else
2847 static void yy_fatal_error( msg )
2848 char msg[];
2849 #endif
2850         {
2851         (void) fprintf( stderr, "%s\n", msg );
2852         exit( YY_EXIT_FAILURE );
2853         }
2854
2855
2856
2857 /* Redefine yyless() so it works in section 3 code. */
2858
2859 #undef yyless
2860 #define yyless(n) \
2861         do \
2862                 { \
2863                 /* Undo effects of setting up yytext. */ \
2864                 yytext[yyleng] = yy_hold_char; \
2865                 yy_c_buf_p = yytext + n; \
2866                 yy_hold_char = *yy_c_buf_p; \
2867                 *yy_c_buf_p = '\0'; \
2868                 yyleng = n; \
2869                 } \
2870         while ( 0 )
2871
2872
2873 /* Internal utility routines. */
2874
2875 #ifndef yytext_ptr
2876 #ifdef YY_USE_PROTOS
2877 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
2878 #else
2879 static void yy_flex_strncpy( s1, s2, n )
2880 char *s1;
2881 yyconst char *s2;
2882 int n;
2883 #endif
2884         {
2885         register int i;
2886         for ( i = 0; i < n; ++i )
2887                 s1[i] = s2[i];
2888         }
2889 #endif
2890
2891 #ifdef YY_NEED_STRLEN
2892 #ifdef YY_USE_PROTOS
2893 static int yy_flex_strlen( yyconst char *s )
2894 #else
2895 static int yy_flex_strlen( s )
2896 yyconst char *s;
2897 #endif
2898         {
2899         register int n;
2900         for ( n = 0; s[n]; ++n )
2901                 ;
2902
2903         return n;
2904         }
2905 #endif
2906
2907
2908 #ifdef YY_USE_PROTOS
2909 static void *yy_flex_alloc( yy_size_t size )
2910 #else
2911 static void *yy_flex_alloc( size )
2912 yy_size_t size;
2913 #endif
2914         {
2915         return (void *) malloc( size );
2916         }
2917
2918 #ifdef YY_USE_PROTOS
2919 static inline void *yy_flex_realloc( void *ptr, yy_size_t size )
2920 #else
2921 static inline void *yy_flex_realloc( ptr, size )
2922 void *ptr;
2923 yy_size_t size;
2924 #endif
2925         {
2926         /* The cast to (char *) in the following accommodates both
2927          * implementations that use char* generic pointers, and those
2928          * that use void* generic pointers.  It works with the latter
2929          * because both ANSI C and C++ allow castless assignment from
2930          * any pointer type to void*, and deal with argument conversions
2931          * as though doing an assignment.
2932          */
2933         return (void *) realloc( (char *) ptr, size );
2934         }
2935
2936 #ifdef YY_USE_PROTOS
2937 static void yy_flex_free( void *ptr )
2938 #else
2939 static void yy_flex_free( ptr )
2940 void *ptr;
2941 #endif
2942         {
2943         free( ptr );
2944         }
2945
2946 #if YY_MAIN
2947 int main()
2948         {
2949         yylex();
2950         return 0;
2951         }
2952 #endif
2953 #line 440 "/proj/llvm/llvm-4/lib/AsmParser/Lexer.l"
2954