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