lib/AsmParser/Lexer.cpp.cvs

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