lib/AsmParser/Lexer.cpp.cvs

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