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