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