lib/AsmParser/Lexer.cpp.cvs

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