lib/AsmParser/Lexer.cpp.cvs

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