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