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