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