lib/AsmParser/Lexer.cpp.cvs

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