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