ia64/linux-2.6.18-xen.hg

annotate scripts/genksyms/lex.c_shipped @ 893:f994bfe9b93b

linux/blktap2: reduce TLB flush scope

c/s 885 added very coarse TLB flushing. Since these flushes always
follow single page updates, single page flushes (when available) are
sufficient.

Signed-off-by: Jan Beulich <jbeulich@novell.com>
author Keir Fraser <keir.fraser@citrix.com>
date Thu Jun 04 10:32:57 2009 +0100 (2009-06-04)
parents 831230e53067
children
rev   line source
ian@0 1 #line 2 "scripts/genksyms/lex.c"
ian@0 2 /* A lexical scanner generated by flex */
ian@0 3
ian@0 4 /* Scanner skeleton version:
ian@0 5 * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.91 96/09/10 16:58:48 vern Exp $
ian@0 6 */
ian@0 7
ian@0 8 #define FLEX_SCANNER
ian@0 9 #define YY_FLEX_MAJOR_VERSION 2
ian@0 10 #define YY_FLEX_MINOR_VERSION 5
ian@0 11
ian@0 12 #include <stdio.h>
ian@0 13 #include <unistd.h>
ian@0 14
ian@0 15
ian@0 16 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
ian@0 17 #ifdef c_plusplus
ian@0 18 #ifndef __cplusplus
ian@0 19 #define __cplusplus
ian@0 20 #endif
ian@0 21 #endif
ian@0 22
ian@0 23
ian@0 24 #ifdef __cplusplus
ian@0 25
ian@0 26 #include <stdlib.h>
ian@0 27
ian@0 28 /* Use prototypes in function declarations. */
ian@0 29 #define YY_USE_PROTOS
ian@0 30
ian@0 31 /* The "const" storage-class-modifier is valid. */
ian@0 32 #define YY_USE_CONST
ian@0 33
ian@0 34 #else /* ! __cplusplus */
ian@0 35
ian@0 36 #if __STDC__
ian@0 37
ian@0 38 #define YY_USE_PROTOS
ian@0 39 #define YY_USE_CONST
ian@0 40
ian@0 41 #endif /* __STDC__ */
ian@0 42 #endif /* ! __cplusplus */
ian@0 43
ian@0 44 #ifdef __TURBOC__
ian@0 45 #pragma warn -rch
ian@0 46 #pragma warn -use
ian@0 47 #include <io.h>
ian@0 48 #include <stdlib.h>
ian@0 49 #define YY_USE_CONST
ian@0 50 #define YY_USE_PROTOS
ian@0 51 #endif
ian@0 52
ian@0 53 #ifdef YY_USE_CONST
ian@0 54 #define yyconst const
ian@0 55 #else
ian@0 56 #define yyconst
ian@0 57 #endif
ian@0 58
ian@0 59
ian@0 60 #ifdef YY_USE_PROTOS
ian@0 61 #define YY_PROTO(proto) proto
ian@0 62 #else
ian@0 63 #define YY_PROTO(proto) ()
ian@0 64 #endif
ian@0 65
ian@0 66 /* Returned upon end-of-file. */
ian@0 67 #define YY_NULL 0
ian@0 68
ian@0 69 /* Promotes a possibly negative, possibly signed char to an unsigned
ian@0 70 * integer for use as an array index. If the signed char is negative,
ian@0 71 * we want to instead treat it as an 8-bit unsigned char, hence the
ian@0 72 * double cast.
ian@0 73 */
ian@0 74 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
ian@0 75
ian@0 76 /* Enter a start condition. This macro really ought to take a parameter,
ian@0 77 * but we do it the disgusting crufty way forced on us by the ()-less
ian@0 78 * definition of BEGIN.
ian@0 79 */
ian@0 80 #define BEGIN yy_start = 1 + 2 *
ian@0 81
ian@0 82 /* Translate the current start state into a value that can be later handed
ian@0 83 * to BEGIN to return to the state. The YYSTATE alias is for lex
ian@0 84 * compatibility.
ian@0 85 */
ian@0 86 #define YY_START ((yy_start - 1) / 2)
ian@0 87 #define YYSTATE YY_START
ian@0 88
ian@0 89 /* Action number for EOF rule of a given start state. */
ian@0 90 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
ian@0 91
ian@0 92 /* Special action meaning "start processing a new file". */
ian@0 93 #define YY_NEW_FILE yyrestart( yyin )
ian@0 94
ian@0 95 #define YY_END_OF_BUFFER_CHAR 0
ian@0 96
ian@0 97 /* Size of default input buffer. */
ian@0 98 #define YY_BUF_SIZE 16384
ian@0 99
ian@0 100 typedef struct yy_buffer_state *YY_BUFFER_STATE;
ian@0 101
ian@0 102 extern int yyleng;
ian@0 103 extern FILE *yyin, *yyout;
ian@0 104
ian@0 105 #define EOB_ACT_CONTINUE_SCAN 0
ian@0 106 #define EOB_ACT_END_OF_FILE 1
ian@0 107 #define EOB_ACT_LAST_MATCH 2
ian@0 108
ian@0 109 /* The funky do-while in the following #define is used to turn the definition
ian@0 110 * int a single C statement (which needs a semi-colon terminator). This
ian@0 111 * avoids problems with code like:
ian@0 112 *
ian@0 113 * if ( condition_holds )
ian@0 114 * yyless( 5 );
ian@0 115 * else
ian@0 116 * do_something_else();
ian@0 117 *
ian@0 118 * Prior to using the do-while the compiler would get upset at the
ian@0 119 * "else" because it interpreted the "if" statement as being all
ian@0 120 * done when it reached the ';' after the yyless() call.
ian@0 121 */
ian@0 122
ian@0 123 /* Return all but the first 'n' matched characters back to the input stream. */
ian@0 124
ian@0 125 #define yyless(n) \
ian@0 126 do \
ian@0 127 { \
ian@0 128 /* Undo effects of setting up yytext. */ \
ian@0 129 *yy_cp = yy_hold_char; \
ian@0 130 YY_RESTORE_YY_MORE_OFFSET \
ian@0 131 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
ian@0 132 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
ian@0 133 } \
ian@0 134 while ( 0 )
ian@0 135
ian@0 136 #define unput(c) yyunput( c, yytext_ptr )
ian@0 137
ian@0 138 /* The following is because we cannot portably get our hands on size_t
ian@0 139 * (without autoconf's help, which isn't available because we want
ian@0 140 * flex-generated scanners to compile on their own).
ian@0 141 */
ian@0 142 typedef unsigned int yy_size_t;
ian@0 143
ian@0 144
ian@0 145 struct yy_buffer_state
ian@0 146 {
ian@0 147 FILE *yy_input_file;
ian@0 148
ian@0 149 char *yy_ch_buf; /* input buffer */
ian@0 150 char *yy_buf_pos; /* current position in input buffer */
ian@0 151
ian@0 152 /* Size of input buffer in bytes, not including room for EOB
ian@0 153 * characters.
ian@0 154 */
ian@0 155 yy_size_t yy_buf_size;
ian@0 156
ian@0 157 /* Number of characters read into yy_ch_buf, not including EOB
ian@0 158 * characters.
ian@0 159 */
ian@0 160 int yy_n_chars;
ian@0 161
ian@0 162 /* Whether we "own" the buffer - i.e., we know we created it,
ian@0 163 * and can realloc() it to grow it, and should free() it to
ian@0 164 * delete it.
ian@0 165 */
ian@0 166 int yy_is_our_buffer;
ian@0 167
ian@0 168 /* Whether this is an "interactive" input source; if so, and
ian@0 169 * if we're using stdio for input, then we want to use getc()
ian@0 170 * instead of fread(), to make sure we stop fetching input after
ian@0 171 * each newline.
ian@0 172 */
ian@0 173 int yy_is_interactive;
ian@0 174
ian@0 175 /* Whether we're considered to be at the beginning of a line.
ian@0 176 * If so, '^' rules will be active on the next match, otherwise
ian@0 177 * not.
ian@0 178 */
ian@0 179 int yy_at_bol;
ian@0 180
ian@0 181 /* Whether to try to fill the input buffer when we reach the
ian@0 182 * end of it.
ian@0 183 */
ian@0 184 int yy_fill_buffer;
ian@0 185
ian@0 186 int yy_buffer_status;
ian@0 187 #define YY_BUFFER_NEW 0
ian@0 188 #define YY_BUFFER_NORMAL 1
ian@0 189 /* When an EOF's been seen but there's still some text to process
ian@0 190 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
ian@0 191 * shouldn't try reading from the input source any more. We might
ian@0 192 * still have a bunch of tokens to match, though, because of
ian@0 193 * possible backing-up.
ian@0 194 *
ian@0 195 * When we actually see the EOF, we change the status to "new"
ian@0 196 * (via yyrestart()), so that the user can continue scanning by
ian@0 197 * just pointing yyin at a new input file.
ian@0 198 */
ian@0 199 #define YY_BUFFER_EOF_PENDING 2
ian@0 200 };
ian@0 201
ian@0 202 static YY_BUFFER_STATE yy_current_buffer = 0;
ian@0 203
ian@0 204 /* We provide macros for accessing buffer states in case in the
ian@0 205 * future we want to put the buffer states in a more general
ian@0 206 * "scanner state".
ian@0 207 */
ian@0 208 #define YY_CURRENT_BUFFER yy_current_buffer
ian@0 209
ian@0 210
ian@0 211 /* yy_hold_char holds the character lost when yytext is formed. */
ian@0 212 static char yy_hold_char;
ian@0 213
ian@0 214 static int yy_n_chars; /* number of characters read into yy_ch_buf */
ian@0 215
ian@0 216
ian@0 217 int yyleng;
ian@0 218
ian@0 219 /* Points to current character in buffer. */
ian@0 220 static char *yy_c_buf_p = (char *) 0;
ian@0 221 static int yy_init = 1; /* whether we need to initialize */
ian@0 222 static int yy_start = 0; /* start state number */
ian@0 223
ian@0 224 /* Flag which is used to allow yywrap()'s to do buffer switches
ian@0 225 * instead of setting up a fresh yyin. A bit of a hack ...
ian@0 226 */
ian@0 227 static int yy_did_buffer_switch_on_eof;
ian@0 228
ian@0 229 void yyrestart YY_PROTO(( FILE *input_file ));
ian@0 230
ian@0 231 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
ian@0 232 void yy_load_buffer_state YY_PROTO(( void ));
ian@0 233 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
ian@0 234 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
ian@0 235 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
ian@0 236 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
ian@0 237 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
ian@0 238
ian@0 239 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
ian@0 240 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
ian@0 241 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
ian@0 242
ian@0 243 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
ian@0 244 static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
ian@0 245 static void yy_flex_free YY_PROTO(( void * ));
ian@0 246
ian@0 247 #define yy_new_buffer yy_create_buffer
ian@0 248
ian@0 249 #define yy_set_interactive(is_interactive) \
ian@0 250 { \
ian@0 251 if ( ! yy_current_buffer ) \
ian@0 252 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
ian@0 253 yy_current_buffer->yy_is_interactive = is_interactive; \
ian@0 254 }
ian@0 255
ian@0 256 #define yy_set_bol(at_bol) \
ian@0 257 { \
ian@0 258 if ( ! yy_current_buffer ) \
ian@0 259 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
ian@0 260 yy_current_buffer->yy_at_bol = at_bol; \
ian@0 261 }
ian@0 262
ian@0 263 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
ian@0 264
ian@0 265
ian@0 266 #define yywrap() 1
ian@0 267 #define YY_SKIP_YYWRAP
ian@0 268
ian@0 269 #define FLEX_DEBUG
ian@0 270 typedef unsigned char YY_CHAR;
ian@0 271 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
ian@0 272 typedef int yy_state_type;
ian@0 273
ian@0 274 #define FLEX_DEBUG
ian@0 275 extern char *yytext;
ian@0 276 #define yytext_ptr yytext
ian@0 277
ian@0 278 static yy_state_type yy_get_previous_state YY_PROTO(( void ));
ian@0 279 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
ian@0 280 static int yy_get_next_buffer YY_PROTO(( void ));
ian@0 281 static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
ian@0 282
ian@0 283 /* Done after the current pattern has been matched and before the
ian@0 284 * corresponding action - sets up yytext.
ian@0 285 */
ian@0 286 #define YY_DO_BEFORE_ACTION \
ian@0 287 yytext_ptr = yy_bp; \
ian@0 288 yyleng = (int) (yy_cp - yy_bp); \
ian@0 289 yy_hold_char = *yy_cp; \
ian@0 290 *yy_cp = '\0'; \
ian@0 291 yy_c_buf_p = yy_cp;
ian@0 292
ian@0 293 #define YY_NUM_RULES 13
ian@0 294 #define YY_END_OF_BUFFER 14
ian@0 295 static yyconst short int yy_accept[76] =
ian@0 296 { 0,
ian@0 297 0, 0, 0, 0, 14, 12, 4, 3, 12, 7,
ian@0 298 12, 12, 7, 12, 12, 12, 12, 12, 9, 9,
ian@0 299 12, 12, 12, 4, 0, 5, 0, 7, 0, 6,
ian@0 300 0, 0, 0, 0, 0, 0, 2, 8, 10, 10,
ian@0 301 9, 0, 0, 9, 9, 0, 9, 0, 0, 11,
ian@0 302 0, 0, 0, 10, 0, 10, 9, 9, 0, 0,
ian@0 303 0, 0, 0, 0, 0, 10, 10, 0, 0, 0,
ian@0 304 0, 0, 0, 1, 0
ian@0 305 } ;
ian@0 306
ian@0 307 static yyconst int yy_ec[256] =
ian@0 308 { 0,
ian@0 309 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
ian@0 310 4, 4, 4, 1, 1, 1, 1, 1, 1, 1,
ian@0 311 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
ian@0 312 1, 2, 1, 5, 6, 7, 8, 9, 10, 1,
ian@0 313 1, 8, 11, 1, 12, 13, 8, 14, 15, 15,
ian@0 314 15, 15, 15, 15, 15, 16, 16, 1, 1, 17,
ian@0 315 18, 19, 1, 1, 20, 20, 20, 20, 21, 22,
ian@0 316 7, 7, 7, 7, 7, 23, 7, 7, 7, 7,
ian@0 317 7, 7, 7, 7, 24, 7, 7, 25, 7, 7,
ian@0 318 1, 26, 1, 8, 7, 1, 20, 20, 20, 20,
ian@0 319
ian@0 320 21, 22, 7, 7, 7, 7, 7, 27, 7, 7,
ian@0 321 7, 7, 7, 7, 7, 7, 24, 7, 7, 25,
ian@0 322 7, 7, 1, 28, 1, 8, 1, 1, 1, 1,
ian@0 323 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
ian@0 324 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
ian@0 325 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
ian@0 326 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
ian@0 327 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
ian@0 328 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
ian@0 329 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
ian@0 330
ian@0 331 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
ian@0 332 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
ian@0 333 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
ian@0 334 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
ian@0 335 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
ian@0 336 1, 1, 1, 1, 1
ian@0 337 } ;
ian@0 338
ian@0 339 static yyconst int yy_meta[29] =
ian@0 340 { 0,
ian@0 341 1, 1, 2, 1, 1, 1, 3, 1, 1, 1,
ian@0 342 4, 4, 5, 6, 6, 6, 1, 1, 1, 7,
ian@0 343 8, 7, 3, 3, 3, 1, 3, 1
ian@0 344 } ;
ian@0 345
ian@0 346 static yyconst short int yy_base[88] =
ian@0 347 { 0,
ian@0 348 0, 147, 21, 140, 145, 284, 39, 284, 26, 0,
ian@0 349 32, 126, 40, 44, 115, 35, 36, 46, 50, 53,
ian@0 350 39, 61, 54, 79, 65, 284, 0, 0, 66, 284,
ian@0 351 0, 119, 79, 75, 123, 104, 284, 284, 107, 0,
ian@0 352 79, 73, 76, 76, 66, 0, 0, 85, 86, 284,
ian@0 353 133, 83, 91, 284, 99, 147, 284, 114, 122, 70,
ian@0 354 107, 141, 172, 151, 135, 181, 284, 137, 114, 157,
ian@0 355 149, 48, 45, 284, 284, 208, 214, 222, 230, 238,
ian@0 356 246, 250, 255, 256, 261, 267, 275
ian@0 357 } ;
ian@0 358
ian@0 359 static yyconst short int yy_def[88] =
ian@0 360 { 0,
ian@0 361 75, 1, 1, 3, 75, 75, 75, 75, 76, 77,
ian@0 362 78, 75, 77, 79, 75, 75, 75, 75, 75, 19,
ian@0 363 75, 75, 75, 75, 76, 75, 80, 77, 78, 75,
ian@0 364 81, 75, 76, 78, 79, 79, 75, 75, 75, 39,
ian@0 365 19, 82, 83, 75, 75, 84, 20, 76, 78, 75,
ian@0 366 79, 51, 85, 75, 75, 75, 75, 84, 79, 51,
ian@0 367 79, 79, 79, 51, 75, 75, 75, 86, 79, 63,
ian@0 368 86, 87, 87, 75, 0, 75, 75, 75, 75, 75,
ian@0 369 75, 75, 75, 75, 75, 75, 75
ian@0 370 } ;
ian@0 371
ian@0 372 static yyconst short int yy_nxt[313] =
ian@0 373 { 0,
ian@0 374 6, 7, 8, 7, 9, 6, 10, 6, 6, 11,
ian@0 375 6, 6, 12, 6, 6, 6, 6, 6, 6, 10,
ian@0 376 10, 10, 13, 10, 10, 6, 10, 6, 15, 16,
ian@0 377 26, 15, 17, 18, 19, 20, 20, 21, 15, 22,
ian@0 378 24, 30, 24, 38, 33, 36, 37, 74, 23, 34,
ian@0 379 74, 27, 38, 38, 38, 38, 38, 31, 32, 39,
ian@0 380 39, 39, 40, 41, 41, 42, 47, 47, 47, 26,
ian@0 381 43, 38, 44, 45, 46, 30, 44, 75, 38, 38,
ian@0 382 24, 38, 24, 26, 30, 40, 55, 55, 57, 26,
ian@0 383 27, 31, 57, 43, 35, 30, 64, 64, 64, 57,
ian@0 384
ian@0 385 31, 65, 65, 75, 27, 36, 37, 35, 59, 37,
ian@0 386 27, 31, 56, 56, 56, 59, 37, 51, 52, 52,
ian@0 387 39, 39, 39, 59, 37, 37, 68, 53, 54, 54,
ian@0 388 69, 50, 38, 54, 59, 37, 44, 45, 32, 37,
ian@0 389 44, 35, 59, 37, 75, 14, 60, 60, 66, 66,
ian@0 390 66, 37, 14, 72, 75, 61, 62, 63, 59, 61,
ian@0 391 56, 56, 56, 69, 64, 64, 64, 69, 67, 67,
ian@0 392 75, 75, 75, 67, 37, 35, 75, 75, 75, 61,
ian@0 393 62, 75, 75, 61, 75, 70, 70, 70, 75, 75,
ian@0 394 75, 70, 70, 70, 66, 66, 66, 75, 75, 75,
ian@0 395
ian@0 396 75, 75, 54, 54, 75, 75, 75, 54, 25, 25,
ian@0 397 25, 25, 25, 25, 25, 25, 28, 75, 75, 28,
ian@0 398 28, 28, 29, 29, 29, 29, 29, 29, 29, 29,
ian@0 399 35, 35, 35, 35, 35, 35, 35, 35, 48, 75,
ian@0 400 48, 48, 48, 48, 48, 48, 49, 75, 49, 49,
ian@0 401 49, 49, 49, 49, 42, 42, 75, 42, 56, 75,
ian@0 402 56, 58, 58, 58, 66, 75, 66, 71, 71, 71,
ian@0 403 71, 71, 71, 71, 71, 73, 73, 73, 73, 73,
ian@0 404 73, 73, 73, 5, 75, 75, 75, 75, 75, 75,
ian@0 405 75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
ian@0 406
ian@0 407 75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
ian@0 408 75, 75
ian@0 409 } ;
ian@0 410
ian@0 411 static yyconst short int yy_chk[313] =
ian@0 412 { 0,
ian@0 413 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
ian@0 414 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
ian@0 415 1, 1, 1, 1, 1, 1, 1, 1, 3, 3,
ian@0 416 9, 3, 3, 3, 3, 3, 3, 3, 3, 3,
ian@0 417 7, 11, 7, 16, 13, 14, 14, 73, 3, 13,
ian@0 418 72, 9, 16, 17, 17, 21, 21, 11, 18, 18,
ian@0 419 18, 18, 19, 19, 19, 19, 20, 20, 20, 25,
ian@0 420 19, 23, 19, 19, 19, 29, 19, 20, 22, 22,
ian@0 421 24, 23, 24, 33, 34, 42, 43, 43, 45, 48,
ian@0 422 25, 29, 45, 42, 60, 49, 52, 52, 52, 44,
ian@0 423
ian@0 424 34, 53, 53, 41, 33, 36, 36, 52, 61, 61,
ian@0 425 48, 49, 55, 55, 55, 69, 69, 36, 36, 36,
ian@0 426 39, 39, 39, 59, 59, 35, 59, 39, 39, 39,
ian@0 427 61, 32, 15, 39, 51, 51, 58, 58, 12, 68,
ian@0 428 58, 68, 62, 62, 5, 4, 51, 51, 65, 65,
ian@0 429 65, 71, 2, 71, 0, 51, 51, 51, 70, 51,
ian@0 430 56, 56, 56, 62, 64, 64, 64, 62, 56, 56,
ian@0 431 0, 0, 0, 56, 63, 64, 0, 0, 0, 70,
ian@0 432 70, 0, 0, 70, 0, 63, 63, 63, 0, 0,
ian@0 433 0, 63, 63, 63, 66, 66, 66, 0, 0, 0,
ian@0 434
ian@0 435 0, 0, 66, 66, 0, 0, 0, 66, 76, 76,
ian@0 436 76, 76, 76, 76, 76, 76, 77, 0, 0, 77,
ian@0 437 77, 77, 78, 78, 78, 78, 78, 78, 78, 78,
ian@0 438 79, 79, 79, 79, 79, 79, 79, 79, 80, 0,
ian@0 439 80, 80, 80, 80, 80, 80, 81, 0, 81, 81,
ian@0 440 81, 81, 81, 81, 82, 82, 0, 82, 83, 0,
ian@0 441 83, 84, 84, 84, 85, 0, 85, 86, 86, 86,
ian@0 442 86, 86, 86, 86, 86, 87, 87, 87, 87, 87,
ian@0 443 87, 87, 87, 75, 75, 75, 75, 75, 75, 75,
ian@0 444 75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
ian@0 445
ian@0 446 75, 75, 75, 75, 75, 75, 75, 75, 75, 75,
ian@0 447 75, 75
ian@0 448 } ;
ian@0 449
ian@0 450 static yy_state_type yy_last_accepting_state;
ian@0 451 static char *yy_last_accepting_cpos;
ian@0 452
ian@0 453 extern int yy_flex_debug;
ian@0 454 int yy_flex_debug = 1;
ian@0 455
ian@0 456 static yyconst short int yy_rule_linenum[13] =
ian@0 457 { 0,
ian@0 458 69, 70, 71, 74, 77, 78, 79, 85, 86, 87,
ian@0 459 89, 92
ian@0 460 } ;
ian@0 461
ian@0 462 /* The intent behind this definition is that it'll catch
ian@0 463 * any uses of REJECT which flex missed.
ian@0 464 */
ian@0 465 #define REJECT reject_used_but_not_detected
ian@0 466 #define yymore() yymore_used_but_not_detected
ian@0 467 #define YY_MORE_ADJ 0
ian@0 468 #define YY_RESTORE_YY_MORE_OFFSET
ian@0 469 char *yytext;
ian@0 470 #line 1 "scripts/genksyms/lex.l"
ian@0 471 #define INITIAL 0
ian@0 472 /* Lexical analysis for genksyms.
ian@0 473 Copyright 1996, 1997 Linux International.
ian@0 474
ian@0 475 New implementation contributed by Richard Henderson <rth@tamu.edu>
ian@0 476 Based on original work by Bjorn Ekwall <bj0rn@blox.se>
ian@0 477
ian@0 478 Taken from Linux modutils 2.4.22.
ian@0 479
ian@0 480 This program is free software; you can redistribute it and/or modify it
ian@0 481 under the terms of the GNU General Public License as published by the
ian@0 482 Free Software Foundation; either version 2 of the License, or (at your
ian@0 483 option) any later version.
ian@0 484
ian@0 485 This program is distributed in the hope that it will be useful, but
ian@0 486 WITHOUT ANY WARRANTY; without even the implied warranty of
ian@0 487 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
ian@0 488 General Public License for more details.
ian@0 489
ian@0 490 You should have received a copy of the GNU General Public License
ian@0 491 along with this program; if not, write to the Free Software Foundation,
ian@0 492 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
ian@0 493 #line 25 "scripts/genksyms/lex.l"
ian@0 494
ian@0 495 #include <limits.h>
ian@0 496 #include <stdlib.h>
ian@0 497 #include <string.h>
ian@0 498 #include <ctype.h>
ian@0 499
ian@0 500 #include "genksyms.h"
ian@0 501 #include "parse.h"
ian@0 502
ian@0 503 /* We've got a two-level lexer here. We let flex do basic tokenization
ian@0 504 and then we categorize those basic tokens in the second stage. */
ian@0 505 #define YY_DECL static int yylex1(void)
ian@0 506
ian@0 507 /* Version 2 checksumming does proper tokenization; version 1 wasn't
ian@0 508 quite so pedantic. */
ian@0 509 #define V2_TOKENS 1
ian@0 510
ian@0 511 /* We don't do multiple input files. */
ian@0 512 #line 513 "scripts/genksyms/lex.c"
ian@0 513
ian@0 514 /* Macros after this point can all be overridden by user definitions in
ian@0 515 * section 1.
ian@0 516 */
ian@0 517
ian@0 518 #ifndef YY_SKIP_YYWRAP
ian@0 519 #ifdef __cplusplus
ian@0 520 extern "C" int yywrap YY_PROTO(( void ));
ian@0 521 #else
ian@0 522 extern int yywrap YY_PROTO(( void ));
ian@0 523 #endif
ian@0 524 #endif
ian@0 525
ian@0 526 #ifndef YY_NO_UNPUT
ian@0 527 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
ian@0 528 #endif
ian@0 529
ian@0 530 #ifndef yytext_ptr
ian@0 531 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
ian@0 532 #endif
ian@0 533
ian@0 534 #ifdef YY_NEED_STRLEN
ian@0 535 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
ian@0 536 #endif
ian@0 537
ian@0 538 #ifndef YY_NO_INPUT
ian@0 539 #ifdef __cplusplus
ian@0 540 static int yyinput YY_PROTO(( void ));
ian@0 541 #else
ian@0 542 static int input YY_PROTO(( void ));
ian@0 543 #endif
ian@0 544 #endif
ian@0 545
ian@0 546 #if YY_STACK_USED
ian@0 547 static int yy_start_stack_ptr = 0;
ian@0 548 static int yy_start_stack_depth = 0;
ian@0 549 static int *yy_start_stack = 0;
ian@0 550 #ifndef YY_NO_PUSH_STATE
ian@0 551 static void yy_push_state YY_PROTO(( int new_state ));
ian@0 552 #endif
ian@0 553 #ifndef YY_NO_POP_STATE
ian@0 554 static void yy_pop_state YY_PROTO(( void ));
ian@0 555 #endif
ian@0 556 #ifndef YY_NO_TOP_STATE
ian@0 557 static int yy_top_state YY_PROTO(( void ));
ian@0 558 #endif
ian@0 559
ian@0 560 #else
ian@0 561 #define YY_NO_PUSH_STATE 1
ian@0 562 #define YY_NO_POP_STATE 1
ian@0 563 #define YY_NO_TOP_STATE 1
ian@0 564 #endif
ian@0 565
ian@0 566 #ifdef YY_MALLOC_DECL
ian@0 567 YY_MALLOC_DECL
ian@0 568 #else
ian@0 569 #if __STDC__
ian@0 570 #ifndef __cplusplus
ian@0 571 #include <stdlib.h>
ian@0 572 #endif
ian@0 573 #else
ian@0 574 /* Just try to get by without declaring the routines. This will fail
ian@0 575 * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
ian@0 576 * or sizeof(void*) != sizeof(int).
ian@0 577 */
ian@0 578 #endif
ian@0 579 #endif
ian@0 580
ian@0 581 /* Amount of stuff to slurp up with each read. */
ian@0 582 #ifndef YY_READ_BUF_SIZE
ian@0 583 #define YY_READ_BUF_SIZE 8192
ian@0 584 #endif
ian@0 585
ian@0 586 /* Copy whatever the last rule matched to the standard output. */
ian@0 587
ian@0 588 #ifndef ECHO
ian@0 589 /* This used to be an fputs(), but since the string might contain NUL's,
ian@0 590 * we now use fwrite().
ian@0 591 */
ian@0 592 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
ian@0 593 #endif
ian@0 594
ian@0 595 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
ian@0 596 * is returned in "result".
ian@0 597 */
ian@0 598 #ifndef YY_INPUT
ian@0 599 #define YY_INPUT(buf,result,max_size) \
ian@0 600 if ( yy_current_buffer->yy_is_interactive ) \
ian@0 601 { \
ian@0 602 int c = '*', n; \
ian@0 603 for ( n = 0; n < max_size && \
ian@0 604 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
ian@0 605 buf[n] = (char) c; \
ian@0 606 if ( c == '\n' ) \
ian@0 607 buf[n++] = (char) c; \
ian@0 608 if ( c == EOF && ferror( yyin ) ) \
ian@0 609 YY_FATAL_ERROR( "input in flex scanner failed" ); \
ian@0 610 result = n; \
ian@0 611 } \
ian@0 612 else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
ian@0 613 && ferror( yyin ) ) \
ian@0 614 YY_FATAL_ERROR( "input in flex scanner failed" );
ian@0 615 #endif
ian@0 616
ian@0 617 /* No semi-colon after return; correct usage is to write "yyterminate();" -
ian@0 618 * we don't want an extra ';' after the "return" because that will cause
ian@0 619 * some compilers to complain about unreachable statements.
ian@0 620 */
ian@0 621 #ifndef yyterminate
ian@0 622 #define yyterminate() return YY_NULL
ian@0 623 #endif
ian@0 624
ian@0 625 /* Number of entries by which start-condition stack grows. */
ian@0 626 #ifndef YY_START_STACK_INCR
ian@0 627 #define YY_START_STACK_INCR 25
ian@0 628 #endif
ian@0 629
ian@0 630 /* Report a fatal error. */
ian@0 631 #ifndef YY_FATAL_ERROR
ian@0 632 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
ian@0 633 #endif
ian@0 634
ian@0 635 /* Default declaration of generated scanner - a define so the user can
ian@0 636 * easily add parameters.
ian@0 637 */
ian@0 638 #ifndef YY_DECL
ian@0 639 #define YY_DECL int yylex YY_PROTO(( void ))
ian@0 640 #endif
ian@0 641
ian@0 642 /* Code executed at the beginning of each rule, after yytext and yyleng
ian@0 643 * have been set up.
ian@0 644 */
ian@0 645 #ifndef YY_USER_ACTION
ian@0 646 #define YY_USER_ACTION
ian@0 647 #endif
ian@0 648
ian@0 649 /* Code executed at the end of each rule. */
ian@0 650 #ifndef YY_BREAK
ian@0 651 #define YY_BREAK break;
ian@0 652 #endif
ian@0 653
ian@0 654 #define YY_RULE_SETUP \
ian@0 655 if ( yyleng > 0 ) \
ian@0 656 yy_current_buffer->yy_at_bol = \
ian@0 657 (yytext[yyleng - 1] == '\n'); \
ian@0 658 YY_USER_ACTION
ian@0 659
ian@0 660 YY_DECL
ian@0 661 {
ian@0 662 register yy_state_type yy_current_state;
ian@0 663 register char *yy_cp = NULL, *yy_bp = NULL;
ian@0 664 register int yy_act;
ian@0 665
ian@0 666 #line 65 "scripts/genksyms/lex.l"
ian@0 667
ian@0 668
ian@0 669
ian@0 670 /* Keep track of our location in the original source files. */
ian@0 671 #line 672 "scripts/genksyms/lex.c"
ian@0 672
ian@0 673 if ( yy_init )
ian@0 674 {
ian@0 675 yy_init = 0;
ian@0 676
ian@0 677 #ifdef YY_USER_INIT
ian@0 678 YY_USER_INIT;
ian@0 679 #endif
ian@0 680
ian@0 681 if ( ! yy_start )
ian@0 682 yy_start = 1; /* first start state */
ian@0 683
ian@0 684 if ( ! yyin )
ian@0 685 yyin = stdin;
ian@0 686
ian@0 687 if ( ! yyout )
ian@0 688 yyout = stdout;
ian@0 689
ian@0 690 if ( ! yy_current_buffer )
ian@0 691 yy_current_buffer =
ian@0 692 yy_create_buffer( yyin, YY_BUF_SIZE );
ian@0 693
ian@0 694 yy_load_buffer_state();
ian@0 695 }
ian@0 696
ian@0 697 while ( 1 ) /* loops until end-of-file is reached */
ian@0 698 {
ian@0 699 yy_cp = yy_c_buf_p;
ian@0 700
ian@0 701 /* Support of yytext. */
ian@0 702 *yy_cp = yy_hold_char;
ian@0 703
ian@0 704 /* yy_bp points to the position in yy_ch_buf of the start of
ian@0 705 * the current run.
ian@0 706 */
ian@0 707 yy_bp = yy_cp;
ian@0 708
ian@0 709 yy_current_state = yy_start;
ian@0 710 yy_current_state += YY_AT_BOL();
ian@0 711 yy_match:
ian@0 712 do
ian@0 713 {
ian@0 714 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
ian@0 715 if ( yy_accept[yy_current_state] )
ian@0 716 {
ian@0 717 yy_last_accepting_state = yy_current_state;
ian@0 718 yy_last_accepting_cpos = yy_cp;
ian@0 719 }
ian@0 720 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
ian@0 721 {
ian@0 722 yy_current_state = (int) yy_def[yy_current_state];
ian@0 723 if ( yy_current_state >= 76 )
ian@0 724 yy_c = yy_meta[(unsigned int) yy_c];
ian@0 725 }
ian@0 726 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
ian@0 727 ++yy_cp;
ian@0 728 }
ian@0 729 while ( yy_base[yy_current_state] != 284 );
ian@0 730
ian@0 731 yy_find_action:
ian@0 732 yy_act = yy_accept[yy_current_state];
ian@0 733 if ( yy_act == 0 )
ian@0 734 { /* have to back up */
ian@0 735 yy_cp = yy_last_accepting_cpos;
ian@0 736 yy_current_state = yy_last_accepting_state;
ian@0 737 yy_act = yy_accept[yy_current_state];
ian@0 738 }
ian@0 739
ian@0 740 YY_DO_BEFORE_ACTION;
ian@0 741
ian@0 742
ian@0 743 do_action: /* This label is used only to access EOF actions. */
ian@0 744
ian@0 745 if ( yy_flex_debug )
ian@0 746 {
ian@0 747 if ( yy_act == 0 )
ian@0 748 fprintf( stderr, "--scanner backing up\n" );
ian@0 749 else if ( yy_act < 13 )
ian@0 750 fprintf( stderr, "--accepting rule at line %d (\"%s\")\n",
ian@0 751 yy_rule_linenum[yy_act], yytext );
ian@0 752 else if ( yy_act == 13 )
ian@0 753 fprintf( stderr, "--accepting default rule (\"%s\")\n",
ian@0 754 yytext );
ian@0 755 else if ( yy_act == 14 )
ian@0 756 fprintf( stderr, "--(end of buffer or a NUL)\n" );
ian@0 757 else
ian@0 758 fprintf( stderr, "--EOF (start condition %d)\n", YY_START );
ian@0 759 }
ian@0 760
ian@0 761 switch ( yy_act )
ian@0 762 { /* beginning of action switch */
ian@0 763 case 0: /* must back up */
ian@0 764 /* undo the effects of YY_DO_BEFORE_ACTION */
ian@0 765 *yy_cp = yy_hold_char;
ian@0 766 yy_cp = yy_last_accepting_cpos;
ian@0 767 yy_current_state = yy_last_accepting_state;
ian@0 768 goto yy_find_action;
ian@0 769
ian@0 770 case 1:
ian@0 771 YY_RULE_SETUP
ian@0 772 #line 69 "scripts/genksyms/lex.l"
ian@0 773 return FILENAME;
ian@0 774 YY_BREAK
ian@0 775 case 2:
ian@0 776 YY_RULE_SETUP
ian@0 777 #line 70 "scripts/genksyms/lex.l"
ian@0 778 cur_line++;
ian@0 779 YY_BREAK
ian@0 780 case 3:
ian@0 781 YY_RULE_SETUP
ian@0 782 #line 71 "scripts/genksyms/lex.l"
ian@0 783 cur_line++;
ian@0 784 YY_BREAK
ian@0 785 /* Ignore all other whitespace. */
ian@0 786 case 4:
ian@0 787 YY_RULE_SETUP
ian@0 788 #line 74 "scripts/genksyms/lex.l"
ian@0 789 ;
ian@0 790 YY_BREAK
ian@0 791 case 5:
ian@0 792 YY_RULE_SETUP
ian@0 793 #line 77 "scripts/genksyms/lex.l"
ian@0 794 return STRING;
ian@0 795 YY_BREAK
ian@0 796 case 6:
ian@0 797 YY_RULE_SETUP
ian@0 798 #line 78 "scripts/genksyms/lex.l"
ian@0 799 return CHAR;
ian@0 800 YY_BREAK
ian@0 801 case 7:
ian@0 802 YY_RULE_SETUP
ian@0 803 #line 79 "scripts/genksyms/lex.l"
ian@0 804 return IDENT;
ian@0 805 YY_BREAK
ian@0 806 /* The Pedant requires that the other C multi-character tokens be
ian@0 807 recognized as tokens. We don't actually use them since we don't
ian@0 808 parse expressions, but we do want whitespace to be arranged
ian@0 809 around them properly. */
ian@0 810 case 8:
ian@0 811 YY_RULE_SETUP
ian@0 812 #line 85 "scripts/genksyms/lex.l"
ian@0 813 return OTHER;
ian@0 814 YY_BREAK
ian@0 815 case 9:
ian@0 816 YY_RULE_SETUP
ian@0 817 #line 86 "scripts/genksyms/lex.l"
ian@0 818 return INT;
ian@0 819 YY_BREAK
ian@0 820 case 10:
ian@0 821 YY_RULE_SETUP
ian@0 822 #line 87 "scripts/genksyms/lex.l"
ian@0 823 return REAL;
ian@0 824 YY_BREAK
ian@0 825 case 11:
ian@0 826 YY_RULE_SETUP
ian@0 827 #line 89 "scripts/genksyms/lex.l"
ian@0 828 return DOTS;
ian@0 829 YY_BREAK
ian@0 830 /* All other tokens are single characters. */
ian@0 831 case 12:
ian@0 832 YY_RULE_SETUP
ian@0 833 #line 92 "scripts/genksyms/lex.l"
ian@0 834 return yytext[0];
ian@0 835 YY_BREAK
ian@0 836 case 13:
ian@0 837 YY_RULE_SETUP
ian@0 838 #line 95 "scripts/genksyms/lex.l"
ian@0 839 ECHO;
ian@0 840 YY_BREAK
ian@0 841 #line 842 "scripts/genksyms/lex.c"
ian@0 842 case YY_STATE_EOF(INITIAL):
ian@0 843 case YY_STATE_EOF(V2_TOKENS):
ian@0 844 yyterminate();
ian@0 845
ian@0 846 case YY_END_OF_BUFFER:
ian@0 847 {
ian@0 848 /* Amount of text matched not including the EOB char. */
ian@0 849 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
ian@0 850
ian@0 851 /* Undo the effects of YY_DO_BEFORE_ACTION. */
ian@0 852 *yy_cp = yy_hold_char;
ian@0 853 YY_RESTORE_YY_MORE_OFFSET
ian@0 854
ian@0 855 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
ian@0 856 {
ian@0 857 /* We're scanning a new file or input source. It's
ian@0 858 * possible that this happened because the user
ian@0 859 * just pointed yyin at a new source and called
ian@0 860 * yylex(). If so, then we have to assure
ian@0 861 * consistency between yy_current_buffer and our
ian@0 862 * globals. Here is the right place to do so, because
ian@0 863 * this is the first action (other than possibly a
ian@0 864 * back-up) that will match for the new input source.
ian@0 865 */
ian@0 866 yy_n_chars = yy_current_buffer->yy_n_chars;
ian@0 867 yy_current_buffer->yy_input_file = yyin;
ian@0 868 yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
ian@0 869 }
ian@0 870
ian@0 871 /* Note that here we test for yy_c_buf_p "<=" to the position
ian@0 872 * of the first EOB in the buffer, since yy_c_buf_p will
ian@0 873 * already have been incremented past the NUL character
ian@0 874 * (since all states make transitions on EOB to the
ian@0 875 * end-of-buffer state). Contrast this with the test
ian@0 876 * in input().
ian@0 877 */
ian@0 878 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
ian@0 879 { /* This was really a NUL. */
ian@0 880 yy_state_type yy_next_state;
ian@0 881
ian@0 882 yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
ian@0 883
ian@0 884 yy_current_state = yy_get_previous_state();
ian@0 885
ian@0 886 /* Okay, we're now positioned to make the NUL
ian@0 887 * transition. We couldn't have
ian@0 888 * yy_get_previous_state() go ahead and do it
ian@0 889 * for us because it doesn't know how to deal
ian@0 890 * with the possibility of jamming (and we don't
ian@0 891 * want to build jamming into it because then it
ian@0 892 * will run more slowly).
ian@0 893 */
ian@0 894
ian@0 895 yy_next_state = yy_try_NUL_trans( yy_current_state );
ian@0 896
ian@0 897 yy_bp = yytext_ptr + YY_MORE_ADJ;
ian@0 898
ian@0 899 if ( yy_next_state )
ian@0 900 {
ian@0 901 /* Consume the NUL. */
ian@0 902 yy_cp = ++yy_c_buf_p;
ian@0 903 yy_current_state = yy_next_state;
ian@0 904 goto yy_match;
ian@0 905 }
ian@0 906
ian@0 907 else
ian@0 908 {
ian@0 909 yy_cp = yy_c_buf_p;
ian@0 910 goto yy_find_action;
ian@0 911 }
ian@0 912 }
ian@0 913
ian@0 914 else switch ( yy_get_next_buffer() )
ian@0 915 {
ian@0 916 case EOB_ACT_END_OF_FILE:
ian@0 917 {
ian@0 918 yy_did_buffer_switch_on_eof = 0;
ian@0 919
ian@0 920 if ( yywrap() )
ian@0 921 {
ian@0 922 /* Note: because we've taken care in
ian@0 923 * yy_get_next_buffer() to have set up
ian@0 924 * yytext, we can now set up
ian@0 925 * yy_c_buf_p so that if some total
ian@0 926 * hoser (like flex itself) wants to
ian@0 927 * call the scanner after we return the
ian@0 928 * YY_NULL, it'll still work - another
ian@0 929 * YY_NULL will get returned.
ian@0 930 */
ian@0 931 yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
ian@0 932
ian@0 933 yy_act = YY_STATE_EOF(YY_START);
ian@0 934 goto do_action;
ian@0 935 }
ian@0 936
ian@0 937 else
ian@0 938 {
ian@0 939 if ( ! yy_did_buffer_switch_on_eof )
ian@0 940 YY_NEW_FILE;
ian@0 941 }
ian@0 942 break;
ian@0 943 }
ian@0 944
ian@0 945 case EOB_ACT_CONTINUE_SCAN:
ian@0 946 yy_c_buf_p =
ian@0 947 yytext_ptr + yy_amount_of_matched_text;
ian@0 948
ian@0 949 yy_current_state = yy_get_previous_state();
ian@0 950
ian@0 951 yy_cp = yy_c_buf_p;
ian@0 952 yy_bp = yytext_ptr + YY_MORE_ADJ;
ian@0 953 goto yy_match;
ian@0 954
ian@0 955 case EOB_ACT_LAST_MATCH:
ian@0 956 yy_c_buf_p =
ian@0 957 &yy_current_buffer->yy_ch_buf[yy_n_chars];
ian@0 958
ian@0 959 yy_current_state = yy_get_previous_state();
ian@0 960
ian@0 961 yy_cp = yy_c_buf_p;
ian@0 962 yy_bp = yytext_ptr + YY_MORE_ADJ;
ian@0 963 goto yy_find_action;
ian@0 964 }
ian@0 965 break;
ian@0 966 }
ian@0 967
ian@0 968 default:
ian@0 969 YY_FATAL_ERROR(
ian@0 970 "fatal flex scanner internal error--no action found" );
ian@0 971 } /* end of action switch */
ian@0 972 } /* end of scanning one token */
ian@0 973 } /* end of yylex */
ian@0 974
ian@0 975
ian@0 976 /* yy_get_next_buffer - try to read in a new buffer
ian@0 977 *
ian@0 978 * Returns a code representing an action:
ian@0 979 * EOB_ACT_LAST_MATCH -
ian@0 980 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
ian@0 981 * EOB_ACT_END_OF_FILE - end of file
ian@0 982 */
ian@0 983
ian@0 984 static int yy_get_next_buffer()
ian@0 985 {
ian@0 986 register char *dest = yy_current_buffer->yy_ch_buf;
ian@0 987 register char *source = yytext_ptr;
ian@0 988 register int number_to_move, i;
ian@0 989 int ret_val;
ian@0 990
ian@0 991 if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
ian@0 992 YY_FATAL_ERROR(
ian@0 993 "fatal flex scanner internal error--end of buffer missed" );
ian@0 994
ian@0 995 if ( yy_current_buffer->yy_fill_buffer == 0 )
ian@0 996 { /* Don't try to fill the buffer, so this is an EOF. */
ian@0 997 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
ian@0 998 {
ian@0 999 /* We matched a single character, the EOB, so
ian@0 1000 * treat this as a final EOF.
ian@0 1001 */
ian@0 1002 return EOB_ACT_END_OF_FILE;
ian@0 1003 }
ian@0 1004
ian@0 1005 else
ian@0 1006 {
ian@0 1007 /* We matched some text prior to the EOB, first
ian@0 1008 * process it.
ian@0 1009 */
ian@0 1010 return EOB_ACT_LAST_MATCH;
ian@0 1011 }
ian@0 1012 }
ian@0 1013
ian@0 1014 /* Try to read more data. */
ian@0 1015
ian@0 1016 /* First move last chars to start of buffer. */
ian@0 1017 number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
ian@0 1018
ian@0 1019 for ( i = 0; i < number_to_move; ++i )
ian@0 1020 *(dest++) = *(source++);
ian@0 1021
ian@0 1022 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
ian@0 1023 /* don't do the read, it's not guaranteed to return an EOF,
ian@0 1024 * just force an EOF
ian@0 1025 */
ian@0 1026 yy_current_buffer->yy_n_chars = yy_n_chars = 0;
ian@0 1027
ian@0 1028 else
ian@0 1029 {
ian@0 1030 int num_to_read =
ian@0 1031 yy_current_buffer->yy_buf_size - number_to_move - 1;
ian@0 1032
ian@0 1033 while ( num_to_read <= 0 )
ian@0 1034 { /* Not enough room in the buffer - grow it. */
ian@0 1035 #ifdef YY_USES_REJECT
ian@0 1036 YY_FATAL_ERROR(
ian@0 1037 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
ian@0 1038 #else
ian@0 1039
ian@0 1040 /* just a shorter name for the current buffer */
ian@0 1041 YY_BUFFER_STATE b = yy_current_buffer;
ian@0 1042
ian@0 1043 int yy_c_buf_p_offset =
ian@0 1044 (int) (yy_c_buf_p - b->yy_ch_buf);
ian@0 1045
ian@0 1046 if ( b->yy_is_our_buffer )
ian@0 1047 {
ian@0 1048 int new_size = b->yy_buf_size * 2;
ian@0 1049
ian@0 1050 if ( new_size <= 0 )
ian@0 1051 b->yy_buf_size += b->yy_buf_size / 8;
ian@0 1052 else
ian@0 1053 b->yy_buf_size *= 2;
ian@0 1054
ian@0 1055 b->yy_ch_buf = (char *)
ian@0 1056 /* Include room in for 2 EOB chars. */
ian@0 1057 yy_flex_realloc( (void *) b->yy_ch_buf,
ian@0 1058 b->yy_buf_size + 2 );
ian@0 1059 }
ian@0 1060 else
ian@0 1061 /* Can't grow it, we don't own it. */
ian@0 1062 b->yy_ch_buf = 0;
ian@0 1063
ian@0 1064 if ( ! b->yy_ch_buf )
ian@0 1065 YY_FATAL_ERROR(
ian@0 1066 "fatal error - scanner input buffer overflow" );
ian@0 1067
ian@0 1068 yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
ian@0 1069
ian@0 1070 num_to_read = yy_current_buffer->yy_buf_size -
ian@0 1071 number_to_move - 1;
ian@0 1072 #endif
ian@0 1073 }
ian@0 1074
ian@0 1075 if ( num_to_read > YY_READ_BUF_SIZE )
ian@0 1076 num_to_read = YY_READ_BUF_SIZE;
ian@0 1077
ian@0 1078 /* Read in more data. */
ian@0 1079 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
ian@0 1080 yy_n_chars, num_to_read );
ian@0 1081
ian@0 1082 yy_current_buffer->yy_n_chars = yy_n_chars;
ian@0 1083 }
ian@0 1084
ian@0 1085 if ( yy_n_chars == 0 )
ian@0 1086 {
ian@0 1087 if ( number_to_move == YY_MORE_ADJ )
ian@0 1088 {
ian@0 1089 ret_val = EOB_ACT_END_OF_FILE;
ian@0 1090 yyrestart( yyin );
ian@0 1091 }
ian@0 1092
ian@0 1093 else
ian@0 1094 {
ian@0 1095 ret_val = EOB_ACT_LAST_MATCH;
ian@0 1096 yy_current_buffer->yy_buffer_status =
ian@0 1097 YY_BUFFER_EOF_PENDING;
ian@0 1098 }
ian@0 1099 }
ian@0 1100
ian@0 1101 else
ian@0 1102 ret_val = EOB_ACT_CONTINUE_SCAN;
ian@0 1103
ian@0 1104 yy_n_chars += number_to_move;
ian@0 1105 yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
ian@0 1106 yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
ian@0 1107
ian@0 1108 yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
ian@0 1109
ian@0 1110 return ret_val;
ian@0 1111 }
ian@0 1112
ian@0 1113
ian@0 1114 /* yy_get_previous_state - get the state just before the EOB char was reached */
ian@0 1115
ian@0 1116 static yy_state_type yy_get_previous_state()
ian@0 1117 {
ian@0 1118 register yy_state_type yy_current_state;
ian@0 1119 register char *yy_cp;
ian@0 1120
ian@0 1121 yy_current_state = yy_start;
ian@0 1122 yy_current_state += YY_AT_BOL();
ian@0 1123
ian@0 1124 for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
ian@0 1125 {
ian@0 1126 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
ian@0 1127 if ( yy_accept[yy_current_state] )
ian@0 1128 {
ian@0 1129 yy_last_accepting_state = yy_current_state;
ian@0 1130 yy_last_accepting_cpos = yy_cp;
ian@0 1131 }
ian@0 1132 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
ian@0 1133 {
ian@0 1134 yy_current_state = (int) yy_def[yy_current_state];
ian@0 1135 if ( yy_current_state >= 76 )
ian@0 1136 yy_c = yy_meta[(unsigned int) yy_c];
ian@0 1137 }
ian@0 1138 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
ian@0 1139 }
ian@0 1140
ian@0 1141 return yy_current_state;
ian@0 1142 }
ian@0 1143
ian@0 1144
ian@0 1145 /* yy_try_NUL_trans - try to make a transition on the NUL character
ian@0 1146 *
ian@0 1147 * synopsis
ian@0 1148 * next_state = yy_try_NUL_trans( current_state );
ian@0 1149 */
ian@0 1150
ian@0 1151 #ifdef YY_USE_PROTOS
ian@0 1152 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
ian@0 1153 #else
ian@0 1154 static yy_state_type yy_try_NUL_trans( yy_current_state )
ian@0 1155 yy_state_type yy_current_state;
ian@0 1156 #endif
ian@0 1157 {
ian@0 1158 register int yy_is_jam;
ian@0 1159 register char *yy_cp = yy_c_buf_p;
ian@0 1160
ian@0 1161 register YY_CHAR yy_c = 1;
ian@0 1162 if ( yy_accept[yy_current_state] )
ian@0 1163 {
ian@0 1164 yy_last_accepting_state = yy_current_state;
ian@0 1165 yy_last_accepting_cpos = yy_cp;
ian@0 1166 }
ian@0 1167 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
ian@0 1168 {
ian@0 1169 yy_current_state = (int) yy_def[yy_current_state];
ian@0 1170 if ( yy_current_state >= 76 )
ian@0 1171 yy_c = yy_meta[(unsigned int) yy_c];
ian@0 1172 }
ian@0 1173 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
ian@0 1174 yy_is_jam = (yy_current_state == 75);
ian@0 1175
ian@0 1176 return yy_is_jam ? 0 : yy_current_state;
ian@0 1177 }
ian@0 1178
ian@0 1179
ian@0 1180 #ifndef YY_NO_UNPUT
ian@0 1181 #ifdef YY_USE_PROTOS
ian@0 1182 static void yyunput( int c, register char *yy_bp )
ian@0 1183 #else
ian@0 1184 static void yyunput( c, yy_bp )
ian@0 1185 int c;
ian@0 1186 register char *yy_bp;
ian@0 1187 #endif
ian@0 1188 {
ian@0 1189 register char *yy_cp = yy_c_buf_p;
ian@0 1190
ian@0 1191 /* undo effects of setting up yytext */
ian@0 1192 *yy_cp = yy_hold_char;
ian@0 1193
ian@0 1194 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
ian@0 1195 { /* need to shift things up to make room */
ian@0 1196 /* +2 for EOB chars. */
ian@0 1197 register int number_to_move = yy_n_chars + 2;
ian@0 1198 register char *dest = &yy_current_buffer->yy_ch_buf[
ian@0 1199 yy_current_buffer->yy_buf_size + 2];
ian@0 1200 register char *source =
ian@0 1201 &yy_current_buffer->yy_ch_buf[number_to_move];
ian@0 1202
ian@0 1203 while ( source > yy_current_buffer->yy_ch_buf )
ian@0 1204 *--dest = *--source;
ian@0 1205
ian@0 1206 yy_cp += (int) (dest - source);
ian@0 1207 yy_bp += (int) (dest - source);
ian@0 1208 yy_current_buffer->yy_n_chars =
ian@0 1209 yy_n_chars = yy_current_buffer->yy_buf_size;
ian@0 1210
ian@0 1211 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
ian@0 1212 YY_FATAL_ERROR( "flex scanner push-back overflow" );
ian@0 1213 }
ian@0 1214
ian@0 1215 *--yy_cp = (char) c;
ian@0 1216
ian@0 1217
ian@0 1218 yytext_ptr = yy_bp;
ian@0 1219 yy_hold_char = *yy_cp;
ian@0 1220 yy_c_buf_p = yy_cp;
ian@0 1221 }
ian@0 1222 #endif /* ifndef YY_NO_UNPUT */
ian@0 1223
ian@0 1224
ian@0 1225 #ifdef __cplusplus
ian@0 1226 static int yyinput()
ian@0 1227 #else
ian@0 1228 static int input()
ian@0 1229 #endif
ian@0 1230 {
ian@0 1231 int c;
ian@0 1232
ian@0 1233 *yy_c_buf_p = yy_hold_char;
ian@0 1234
ian@0 1235 if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
ian@0 1236 {
ian@0 1237 /* yy_c_buf_p now points to the character we want to return.
ian@0 1238 * If this occurs *before* the EOB characters, then it's a
ian@0 1239 * valid NUL; if not, then we've hit the end of the buffer.
ian@0 1240 */
ian@0 1241 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
ian@0 1242 /* This was really a NUL. */
ian@0 1243 *yy_c_buf_p = '\0';
ian@0 1244
ian@0 1245 else
ian@0 1246 { /* need more input */
ian@0 1247 int offset = yy_c_buf_p - yytext_ptr;
ian@0 1248 ++yy_c_buf_p;
ian@0 1249
ian@0 1250 switch ( yy_get_next_buffer() )
ian@0 1251 {
ian@0 1252 case EOB_ACT_LAST_MATCH:
ian@0 1253 /* This happens because yy_g_n_b()
ian@0 1254 * sees that we've accumulated a
ian@0 1255 * token and flags that we need to
ian@0 1256 * try matching the token before
ian@0 1257 * proceeding. But for input(),
ian@0 1258 * there's no matching to consider.
ian@0 1259 * So convert the EOB_ACT_LAST_MATCH
ian@0 1260 * to EOB_ACT_END_OF_FILE.
ian@0 1261 */
ian@0 1262
ian@0 1263 /* Reset buffer status. */
ian@0 1264 yyrestart( yyin );
ian@0 1265
ian@0 1266 /* fall through */
ian@0 1267
ian@0 1268 case EOB_ACT_END_OF_FILE:
ian@0 1269 {
ian@0 1270 if ( yywrap() )
ian@0 1271 return EOF;
ian@0 1272
ian@0 1273 if ( ! yy_did_buffer_switch_on_eof )
ian@0 1274 YY_NEW_FILE;
ian@0 1275 #ifdef __cplusplus
ian@0 1276 return yyinput();
ian@0 1277 #else
ian@0 1278 return input();
ian@0 1279 #endif
ian@0 1280 }
ian@0 1281
ian@0 1282 case EOB_ACT_CONTINUE_SCAN:
ian@0 1283 yy_c_buf_p = yytext_ptr + offset;
ian@0 1284 break;
ian@0 1285 }
ian@0 1286 }
ian@0 1287 }
ian@0 1288
ian@0 1289 c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */
ian@0 1290 *yy_c_buf_p = '\0'; /* preserve yytext */
ian@0 1291 yy_hold_char = *++yy_c_buf_p;
ian@0 1292
ian@0 1293 yy_current_buffer->yy_at_bol = (c == '\n');
ian@0 1294
ian@0 1295 return c;
ian@0 1296 }
ian@0 1297
ian@0 1298
ian@0 1299 #ifdef YY_USE_PROTOS
ian@0 1300 void yyrestart( FILE *input_file )
ian@0 1301 #else
ian@0 1302 void yyrestart( input_file )
ian@0 1303 FILE *input_file;
ian@0 1304 #endif
ian@0 1305 {
ian@0 1306 if ( ! yy_current_buffer )
ian@0 1307 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
ian@0 1308
ian@0 1309 yy_init_buffer( yy_current_buffer, input_file );
ian@0 1310 yy_load_buffer_state();
ian@0 1311 }
ian@0 1312
ian@0 1313
ian@0 1314 #ifdef YY_USE_PROTOS
ian@0 1315 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
ian@0 1316 #else
ian@0 1317 void yy_switch_to_buffer( new_buffer )
ian@0 1318 YY_BUFFER_STATE new_buffer;
ian@0 1319 #endif
ian@0 1320 {
ian@0 1321 if ( yy_current_buffer == new_buffer )
ian@0 1322 return;
ian@0 1323
ian@0 1324 if ( yy_current_buffer )
ian@0 1325 {
ian@0 1326 /* Flush out information for old buffer. */
ian@0 1327 *yy_c_buf_p = yy_hold_char;
ian@0 1328 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
ian@0 1329 yy_current_buffer->yy_n_chars = yy_n_chars;
ian@0 1330 }
ian@0 1331
ian@0 1332 yy_current_buffer = new_buffer;
ian@0 1333 yy_load_buffer_state();
ian@0 1334
ian@0 1335 /* We don't actually know whether we did this switch during
ian@0 1336 * EOF (yywrap()) processing, but the only time this flag
ian@0 1337 * is looked at is after yywrap() is called, so it's safe
ian@0 1338 * to go ahead and always set it.
ian@0 1339 */
ian@0 1340 yy_did_buffer_switch_on_eof = 1;
ian@0 1341 }
ian@0 1342
ian@0 1343
ian@0 1344 #ifdef YY_USE_PROTOS
ian@0 1345 void yy_load_buffer_state( void )
ian@0 1346 #else
ian@0 1347 void yy_load_buffer_state()
ian@0 1348 #endif
ian@0 1349 {
ian@0 1350 yy_n_chars = yy_current_buffer->yy_n_chars;
ian@0 1351 yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
ian@0 1352 yyin = yy_current_buffer->yy_input_file;
ian@0 1353 yy_hold_char = *yy_c_buf_p;
ian@0 1354 }
ian@0 1355
ian@0 1356
ian@0 1357 #ifdef YY_USE_PROTOS
ian@0 1358 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
ian@0 1359 #else
ian@0 1360 YY_BUFFER_STATE yy_create_buffer( file, size )
ian@0 1361 FILE *file;
ian@0 1362 int size;
ian@0 1363 #endif
ian@0 1364 {
ian@0 1365 YY_BUFFER_STATE b;
ian@0 1366
ian@0 1367 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
ian@0 1368 if ( ! b )
ian@0 1369 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
ian@0 1370
ian@0 1371 b->yy_buf_size = size;
ian@0 1372
ian@0 1373 /* yy_ch_buf has to be 2 characters longer than the size given because
ian@0 1374 * we need to put in 2 end-of-buffer characters.
ian@0 1375 */
ian@0 1376 b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
ian@0 1377 if ( ! b->yy_ch_buf )
ian@0 1378 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
ian@0 1379
ian@0 1380 b->yy_is_our_buffer = 1;
ian@0 1381
ian@0 1382 yy_init_buffer( b, file );
ian@0 1383
ian@0 1384 return b;
ian@0 1385 }
ian@0 1386
ian@0 1387
ian@0 1388 #ifdef YY_USE_PROTOS
ian@0 1389 void yy_delete_buffer( YY_BUFFER_STATE b )
ian@0 1390 #else
ian@0 1391 void yy_delete_buffer( b )
ian@0 1392 YY_BUFFER_STATE b;
ian@0 1393 #endif
ian@0 1394 {
ian@0 1395 if ( ! b )
ian@0 1396 return;
ian@0 1397
ian@0 1398 if ( b == yy_current_buffer )
ian@0 1399 yy_current_buffer = (YY_BUFFER_STATE) 0;
ian@0 1400
ian@0 1401 if ( b->yy_is_our_buffer )
ian@0 1402 yy_flex_free( (void *) b->yy_ch_buf );
ian@0 1403
ian@0 1404 yy_flex_free( (void *) b );
ian@0 1405 }
ian@0 1406
ian@0 1407
ian@0 1408
ian@0 1409 #ifdef YY_USE_PROTOS
ian@0 1410 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
ian@0 1411 #else
ian@0 1412 void yy_init_buffer( b, file )
ian@0 1413 YY_BUFFER_STATE b;
ian@0 1414 FILE *file;
ian@0 1415 #endif
ian@0 1416
ian@0 1417
ian@0 1418 {
ian@0 1419 yy_flush_buffer( b );
ian@0 1420
ian@0 1421 b->yy_input_file = file;
ian@0 1422 b->yy_fill_buffer = 1;
ian@0 1423
ian@0 1424 #if YY_ALWAYS_INTERACTIVE
ian@0 1425 b->yy_is_interactive = 1;
ian@0 1426 #else
ian@0 1427 #if YY_NEVER_INTERACTIVE
ian@0 1428 b->yy_is_interactive = 0;
ian@0 1429 #else
ian@0 1430 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
ian@0 1431 #endif
ian@0 1432 #endif
ian@0 1433 }
ian@0 1434
ian@0 1435
ian@0 1436 #ifdef YY_USE_PROTOS
ian@0 1437 void yy_flush_buffer( YY_BUFFER_STATE b )
ian@0 1438 #else
ian@0 1439 void yy_flush_buffer( b )
ian@0 1440 YY_BUFFER_STATE b;
ian@0 1441 #endif
ian@0 1442
ian@0 1443 {
ian@0 1444 if ( ! b )
ian@0 1445 return;
ian@0 1446
ian@0 1447 b->yy_n_chars = 0;
ian@0 1448
ian@0 1449 /* We always need two end-of-buffer characters. The first causes
ian@0 1450 * a transition to the end-of-buffer state. The second causes
ian@0 1451 * a jam in that state.
ian@0 1452 */
ian@0 1453 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
ian@0 1454 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
ian@0 1455
ian@0 1456 b->yy_buf_pos = &b->yy_ch_buf[0];
ian@0 1457
ian@0 1458 b->yy_at_bol = 1;
ian@0 1459 b->yy_buffer_status = YY_BUFFER_NEW;
ian@0 1460
ian@0 1461 if ( b == yy_current_buffer )
ian@0 1462 yy_load_buffer_state();
ian@0 1463 }
ian@0 1464
ian@0 1465
ian@0 1466 #ifndef YY_NO_SCAN_BUFFER
ian@0 1467 #ifdef YY_USE_PROTOS
ian@0 1468 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
ian@0 1469 #else
ian@0 1470 YY_BUFFER_STATE yy_scan_buffer( base, size )
ian@0 1471 char *base;
ian@0 1472 yy_size_t size;
ian@0 1473 #endif
ian@0 1474 {
ian@0 1475 YY_BUFFER_STATE b;
ian@0 1476
ian@0 1477 if ( size < 2 ||
ian@0 1478 base[size-2] != YY_END_OF_BUFFER_CHAR ||
ian@0 1479 base[size-1] != YY_END_OF_BUFFER_CHAR )
ian@0 1480 /* They forgot to leave room for the EOB's. */
ian@0 1481 return 0;
ian@0 1482
ian@0 1483 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
ian@0 1484 if ( ! b )
ian@0 1485 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
ian@0 1486
ian@0 1487 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
ian@0 1488 b->yy_buf_pos = b->yy_ch_buf = base;
ian@0 1489 b->yy_is_our_buffer = 0;
ian@0 1490 b->yy_input_file = 0;
ian@0 1491 b->yy_n_chars = b->yy_buf_size;
ian@0 1492 b->yy_is_interactive = 0;
ian@0 1493 b->yy_at_bol = 1;
ian@0 1494 b->yy_fill_buffer = 0;
ian@0 1495 b->yy_buffer_status = YY_BUFFER_NEW;
ian@0 1496
ian@0 1497 yy_switch_to_buffer( b );
ian@0 1498
ian@0 1499 return b;
ian@0 1500 }
ian@0 1501 #endif
ian@0 1502
ian@0 1503
ian@0 1504 #ifndef YY_NO_SCAN_STRING
ian@0 1505 #ifdef YY_USE_PROTOS
ian@0 1506 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
ian@0 1507 #else
ian@0 1508 YY_BUFFER_STATE yy_scan_string( yy_str )
ian@0 1509 yyconst char *yy_str;
ian@0 1510 #endif
ian@0 1511 {
ian@0 1512 int len;
ian@0 1513 for ( len = 0; yy_str[len]; ++len )
ian@0 1514 ;
ian@0 1515
ian@0 1516 return yy_scan_bytes( yy_str, len );
ian@0 1517 }
ian@0 1518 #endif
ian@0 1519
ian@0 1520
ian@0 1521 #ifndef YY_NO_SCAN_BYTES
ian@0 1522 #ifdef YY_USE_PROTOS
ian@0 1523 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
ian@0 1524 #else
ian@0 1525 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
ian@0 1526 yyconst char *bytes;
ian@0 1527 int len;
ian@0 1528 #endif
ian@0 1529 {
ian@0 1530 YY_BUFFER_STATE b;
ian@0 1531 char *buf;
ian@0 1532 yy_size_t n;
ian@0 1533 int i;
ian@0 1534
ian@0 1535 /* Get memory for full buffer, including space for trailing EOB's. */
ian@0 1536 n = len + 2;
ian@0 1537 buf = (char *) yy_flex_alloc( n );
ian@0 1538 if ( ! buf )
ian@0 1539 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
ian@0 1540
ian@0 1541 for ( i = 0; i < len; ++i )
ian@0 1542 buf[i] = bytes[i];
ian@0 1543
ian@0 1544 buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
ian@0 1545
ian@0 1546 b = yy_scan_buffer( buf, n );
ian@0 1547 if ( ! b )
ian@0 1548 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
ian@0 1549
ian@0 1550 /* It's okay to grow etc. this buffer, and we should throw it
ian@0 1551 * away when we're done.
ian@0 1552 */
ian@0 1553 b->yy_is_our_buffer = 1;
ian@0 1554
ian@0 1555 return b;
ian@0 1556 }
ian@0 1557 #endif
ian@0 1558
ian@0 1559
ian@0 1560 #ifndef YY_NO_PUSH_STATE
ian@0 1561 #ifdef YY_USE_PROTOS
ian@0 1562 static void yy_push_state( int new_state )
ian@0 1563 #else
ian@0 1564 static void yy_push_state( new_state )
ian@0 1565 int new_state;
ian@0 1566 #endif
ian@0 1567 {
ian@0 1568 if ( yy_start_stack_ptr >= yy_start_stack_depth )
ian@0 1569 {
ian@0 1570 yy_size_t new_size;
ian@0 1571
ian@0 1572 yy_start_stack_depth += YY_START_STACK_INCR;
ian@0 1573 new_size = yy_start_stack_depth * sizeof( int );
ian@0 1574
ian@0 1575 if ( ! yy_start_stack )
ian@0 1576 yy_start_stack = (int *) yy_flex_alloc( new_size );
ian@0 1577
ian@0 1578 else
ian@0 1579 yy_start_stack = (int *) yy_flex_realloc(
ian@0 1580 (void *) yy_start_stack, new_size );
ian@0 1581
ian@0 1582 if ( ! yy_start_stack )
ian@0 1583 YY_FATAL_ERROR(
ian@0 1584 "out of memory expanding start-condition stack" );
ian@0 1585 }
ian@0 1586
ian@0 1587 yy_start_stack[yy_start_stack_ptr++] = YY_START;
ian@0 1588
ian@0 1589 BEGIN(new_state);
ian@0 1590 }
ian@0 1591 #endif
ian@0 1592
ian@0 1593
ian@0 1594 #ifndef YY_NO_POP_STATE
ian@0 1595 static void yy_pop_state()
ian@0 1596 {
ian@0 1597 if ( --yy_start_stack_ptr < 0 )
ian@0 1598 YY_FATAL_ERROR( "start-condition stack underflow" );
ian@0 1599
ian@0 1600 BEGIN(yy_start_stack[yy_start_stack_ptr]);
ian@0 1601 }
ian@0 1602 #endif
ian@0 1603
ian@0 1604
ian@0 1605 #ifndef YY_NO_TOP_STATE
ian@0 1606 static int yy_top_state()
ian@0 1607 {
ian@0 1608 return yy_start_stack[yy_start_stack_ptr - 1];
ian@0 1609 }
ian@0 1610 #endif
ian@0 1611
ian@0 1612 #ifndef YY_EXIT_FAILURE
ian@0 1613 #define YY_EXIT_FAILURE 2
ian@0 1614 #endif
ian@0 1615
ian@0 1616 #ifdef YY_USE_PROTOS
ian@0 1617 static void yy_fatal_error( yyconst char msg[] )
ian@0 1618 #else
ian@0 1619 static void yy_fatal_error( msg )
ian@0 1620 char msg[];
ian@0 1621 #endif
ian@0 1622 {
ian@0 1623 (void) fprintf( stderr, "%s\n", msg );
ian@0 1624 exit( YY_EXIT_FAILURE );
ian@0 1625 }
ian@0 1626
ian@0 1627
ian@0 1628
ian@0 1629 /* Redefine yyless() so it works in section 3 code. */
ian@0 1630
ian@0 1631 #undef yyless
ian@0 1632 #define yyless(n) \
ian@0 1633 do \
ian@0 1634 { \
ian@0 1635 /* Undo effects of setting up yytext. */ \
ian@0 1636 yytext[yyleng] = yy_hold_char; \
ian@0 1637 yy_c_buf_p = yytext + n; \
ian@0 1638 yy_hold_char = *yy_c_buf_p; \
ian@0 1639 *yy_c_buf_p = '\0'; \
ian@0 1640 yyleng = n; \
ian@0 1641 } \
ian@0 1642 while ( 0 )
ian@0 1643
ian@0 1644
ian@0 1645 /* Internal utility routines. */
ian@0 1646
ian@0 1647 #ifndef yytext_ptr
ian@0 1648 #ifdef YY_USE_PROTOS
ian@0 1649 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
ian@0 1650 #else
ian@0 1651 static void yy_flex_strncpy( s1, s2, n )
ian@0 1652 char *s1;
ian@0 1653 yyconst char *s2;
ian@0 1654 int n;
ian@0 1655 #endif
ian@0 1656 {
ian@0 1657 register int i;
ian@0 1658 for ( i = 0; i < n; ++i )
ian@0 1659 s1[i] = s2[i];
ian@0 1660 }
ian@0 1661 #endif
ian@0 1662
ian@0 1663 #ifdef YY_NEED_STRLEN
ian@0 1664 #ifdef YY_USE_PROTOS
ian@0 1665 static int yy_flex_strlen( yyconst char *s )
ian@0 1666 #else
ian@0 1667 static int yy_flex_strlen( s )
ian@0 1668 yyconst char *s;
ian@0 1669 #endif
ian@0 1670 {
ian@0 1671 register int n;
ian@0 1672 for ( n = 0; s[n]; ++n )
ian@0 1673 ;
ian@0 1674
ian@0 1675 return n;
ian@0 1676 }
ian@0 1677 #endif
ian@0 1678
ian@0 1679
ian@0 1680 #ifdef YY_USE_PROTOS
ian@0 1681 static void *yy_flex_alloc( yy_size_t size )
ian@0 1682 #else
ian@0 1683 static void *yy_flex_alloc( size )
ian@0 1684 yy_size_t size;
ian@0 1685 #endif
ian@0 1686 {
ian@0 1687 return (void *) malloc( size );
ian@0 1688 }
ian@0 1689
ian@0 1690 #ifdef YY_USE_PROTOS
ian@0 1691 static void *yy_flex_realloc( void *ptr, yy_size_t size )
ian@0 1692 #else
ian@0 1693 static void *yy_flex_realloc( ptr, size )
ian@0 1694 void *ptr;
ian@0 1695 yy_size_t size;
ian@0 1696 #endif
ian@0 1697 {
ian@0 1698 /* The cast to (char *) in the following accommodates both
ian@0 1699 * implementations that use char* generic pointers, and those
ian@0 1700 * that use void* generic pointers. It works with the latter
ian@0 1701 * because both ANSI C and C++ allow castless assignment from
ian@0 1702 * any pointer type to void*, and deal with argument conversions
ian@0 1703 * as though doing an assignment.
ian@0 1704 */
ian@0 1705 return (void *) realloc( (char *) ptr, size );
ian@0 1706 }
ian@0 1707
ian@0 1708 #ifdef YY_USE_PROTOS
ian@0 1709 static void yy_flex_free( void *ptr )
ian@0 1710 #else
ian@0 1711 static void yy_flex_free( ptr )
ian@0 1712 void *ptr;
ian@0 1713 #endif
ian@0 1714 {
ian@0 1715 free( ptr );
ian@0 1716 }
ian@0 1717
ian@0 1718 #if YY_MAIN
ian@0 1719 int main()
ian@0 1720 {
ian@0 1721 yylex();
ian@0 1722 return 0;
ian@0 1723 }
ian@0 1724 #endif
ian@0 1725 #line 95 "scripts/genksyms/lex.l"
ian@0 1726
ian@0 1727
ian@0 1728 /* Bring in the keyword recognizer. */
ian@0 1729
ian@0 1730 #include "keywords.c"
ian@0 1731
ian@0 1732
ian@0 1733 /* Macros to append to our phrase collection list. */
ian@0 1734
ian@0 1735 #define _APP(T,L) do { \
ian@0 1736 cur_node = next_node; \
ian@0 1737 next_node = xmalloc(sizeof(*next_node)); \
ian@0 1738 next_node->next = cur_node; \
ian@0 1739 cur_node->string = memcpy(xmalloc(L+1), T, L+1); \
ian@0 1740 cur_node->tag = SYM_NORMAL; \
ian@0 1741 } while (0)
ian@0 1742
ian@0 1743 #define APP _APP(yytext, yyleng)
ian@0 1744
ian@0 1745
ian@0 1746 /* The second stage lexer. Here we incorporate knowledge of the state
ian@0 1747 of the parser to tailor the tokens that are returned. */
ian@0 1748
ian@0 1749 int
ian@0 1750 yylex(void)
ian@0 1751 {
ian@0 1752 static enum {
ian@0 1753 ST_NOTSTARTED, ST_NORMAL, ST_ATTRIBUTE, ST_ASM, ST_BRACKET, ST_BRACE,
ian@0 1754 ST_EXPRESSION, ST_TABLE_1, ST_TABLE_2, ST_TABLE_3, ST_TABLE_4,
ian@0 1755 ST_TABLE_5, ST_TABLE_6
ian@0 1756 } lexstate = ST_NOTSTARTED;
ian@0 1757
ian@0 1758 static int suppress_type_lookup, dont_want_brace_phrase;
ian@0 1759 static struct string_list *next_node;
ian@0 1760
ian@0 1761 int token, count = 0;
ian@0 1762 struct string_list *cur_node;
ian@0 1763
ian@0 1764 if (lexstate == ST_NOTSTARTED)
ian@0 1765 {
ian@0 1766 BEGIN(V2_TOKENS);
ian@0 1767 next_node = xmalloc(sizeof(*next_node));
ian@0 1768 next_node->next = NULL;
ian@0 1769 lexstate = ST_NORMAL;
ian@0 1770 }
ian@0 1771
ian@0 1772 repeat:
ian@0 1773 token = yylex1();
ian@0 1774
ian@0 1775 if (token == 0)
ian@0 1776 return 0;
ian@0 1777 else if (token == FILENAME)
ian@0 1778 {
ian@0 1779 char *file, *e;
ian@0 1780
ian@0 1781 /* Save the filename and line number for later error messages. */
ian@0 1782
ian@0 1783 if (cur_filename)
ian@0 1784 free(cur_filename);
ian@0 1785
ian@0 1786 file = strchr(yytext, '\"')+1;
ian@0 1787 e = strchr(file, '\"');
ian@0 1788 *e = '\0';
ian@0 1789 cur_filename = memcpy(xmalloc(e-file+1), file, e-file+1);
ian@0 1790 cur_line = atoi(yytext+2);
ian@0 1791
ian@0 1792 goto repeat;
ian@0 1793 }
ian@0 1794
ian@0 1795 switch (lexstate)
ian@0 1796 {
ian@0 1797 case ST_NORMAL:
ian@0 1798 switch (token)
ian@0 1799 {
ian@0 1800 case IDENT:
ian@0 1801 APP;
ian@0 1802 {
ian@0 1803 const struct resword *r = is_reserved_word(yytext, yyleng);
ian@0 1804 if (r)
ian@0 1805 {
ian@0 1806 switch (token = r->token)
ian@0 1807 {
ian@0 1808 case ATTRIBUTE_KEYW:
ian@0 1809 lexstate = ST_ATTRIBUTE;
ian@0 1810 count = 0;
ian@0 1811 goto repeat;
ian@0 1812 case ASM_KEYW:
ian@0 1813 lexstate = ST_ASM;
ian@0 1814 count = 0;
ian@0 1815 goto repeat;
ian@0 1816
ian@0 1817 case STRUCT_KEYW:
ian@0 1818 case UNION_KEYW:
ian@0 1819 dont_want_brace_phrase = 3;
ian@0 1820 case ENUM_KEYW:
ian@0 1821 suppress_type_lookup = 2;
ian@0 1822 goto fini;
ian@0 1823
ian@0 1824 case EXPORT_SYMBOL_KEYW:
ian@0 1825 goto fini;
ian@0 1826 }
ian@0 1827 }
ian@0 1828 if (!suppress_type_lookup)
ian@0 1829 {
ian@0 1830 struct symbol *sym = find_symbol(yytext, SYM_TYPEDEF);
ian@0 1831 if (sym && sym->type == SYM_TYPEDEF)
ian@0 1832 token = TYPE;
ian@0 1833 }
ian@0 1834 }
ian@0 1835 break;
ian@0 1836
ian@0 1837 case '[':
ian@0 1838 APP;
ian@0 1839 lexstate = ST_BRACKET;
ian@0 1840 count = 1;
ian@0 1841 goto repeat;
ian@0 1842
ian@0 1843 case '{':
ian@0 1844 APP;
ian@0 1845 if (dont_want_brace_phrase)
ian@0 1846 break;
ian@0 1847 lexstate = ST_BRACE;
ian@0 1848 count = 1;
ian@0 1849 goto repeat;
ian@0 1850
ian@0 1851 case '=': case ':':
ian@0 1852 APP;
ian@0 1853 lexstate = ST_EXPRESSION;
ian@0 1854 break;
ian@0 1855
ian@0 1856 case DOTS:
ian@0 1857 default:
ian@0 1858 APP;
ian@0 1859 break;
ian@0 1860 }
ian@0 1861 break;
ian@0 1862
ian@0 1863 case ST_ATTRIBUTE:
ian@0 1864 APP;
ian@0 1865 switch (token)
ian@0 1866 {
ian@0 1867 case '(':
ian@0 1868 ++count;
ian@0 1869 goto repeat;
ian@0 1870 case ')':
ian@0 1871 if (--count == 0)
ian@0 1872 {
ian@0 1873 lexstate = ST_NORMAL;
ian@0 1874 token = ATTRIBUTE_PHRASE;
ian@0 1875 break;
ian@0 1876 }
ian@0 1877 goto repeat;
ian@0 1878 default:
ian@0 1879 goto repeat;
ian@0 1880 }
ian@0 1881 break;
ian@0 1882
ian@0 1883 case ST_ASM:
ian@0 1884 APP;
ian@0 1885 switch (token)
ian@0 1886 {
ian@0 1887 case '(':
ian@0 1888 ++count;
ian@0 1889 goto repeat;
ian@0 1890 case ')':
ian@0 1891 if (--count == 0)
ian@0 1892 {
ian@0 1893 lexstate = ST_NORMAL;
ian@0 1894 token = ASM_PHRASE;
ian@0 1895 break;
ian@0 1896 }
ian@0 1897 goto repeat;
ian@0 1898 default:
ian@0 1899 goto repeat;
ian@0 1900 }
ian@0 1901 break;
ian@0 1902
ian@0 1903 case ST_BRACKET:
ian@0 1904 APP;
ian@0 1905 switch (token)
ian@0 1906 {
ian@0 1907 case '[':
ian@0 1908 ++count;
ian@0 1909 goto repeat;
ian@0 1910 case ']':
ian@0 1911 if (--count == 0)
ian@0 1912 {
ian@0 1913 lexstate = ST_NORMAL;
ian@0 1914 token = BRACKET_PHRASE;
ian@0 1915 break;
ian@0 1916 }
ian@0 1917 goto repeat;
ian@0 1918 default:
ian@0 1919 goto repeat;
ian@0 1920 }
ian@0 1921 break;
ian@0 1922
ian@0 1923 case ST_BRACE:
ian@0 1924 APP;
ian@0 1925 switch (token)
ian@0 1926 {
ian@0 1927 case '{':
ian@0 1928 ++count;
ian@0 1929 goto repeat;
ian@0 1930 case '}':
ian@0 1931 if (--count == 0)
ian@0 1932 {
ian@0 1933 lexstate = ST_NORMAL;
ian@0 1934 token = BRACE_PHRASE;
ian@0 1935 break;
ian@0 1936 }
ian@0 1937 goto repeat;
ian@0 1938 default:
ian@0 1939 goto repeat;
ian@0 1940 }
ian@0 1941 break;
ian@0 1942
ian@0 1943 case ST_EXPRESSION:
ian@0 1944 switch (token)
ian@0 1945 {
ian@0 1946 case '(': case '[': case '{':
ian@0 1947 ++count;
ian@0 1948 APP;
ian@0 1949 goto repeat;
ian@0 1950 case ')': case ']': case '}':
ian@0 1951 --count;
ian@0 1952 APP;
ian@0 1953 goto repeat;
ian@0 1954 case ',': case ';':
ian@0 1955 if (count == 0)
ian@0 1956 {
ian@0 1957 /* Put back the token we just read so's we can find it again
ian@0 1958 after registering the expression. */
ian@0 1959 unput(token);
ian@0 1960
ian@0 1961 lexstate = ST_NORMAL;
ian@0 1962 token = EXPRESSION_PHRASE;
ian@0 1963 break;
ian@0 1964 }
ian@0 1965 APP;
ian@0 1966 goto repeat;
ian@0 1967 default:
ian@0 1968 APP;
ian@0 1969 goto repeat;
ian@0 1970 }
ian@0 1971 break;
ian@0 1972
ian@0 1973 case ST_TABLE_1:
ian@0 1974 goto repeat;
ian@0 1975
ian@0 1976 case ST_TABLE_2:
ian@0 1977 if (token == IDENT && yyleng == 1 && yytext[0] == 'X')
ian@0 1978 {
ian@0 1979 token = EXPORT_SYMBOL_KEYW;
ian@0 1980 lexstate = ST_TABLE_5;
ian@0 1981 APP;
ian@0 1982 break;
ian@0 1983 }
ian@0 1984 lexstate = ST_TABLE_6;
ian@0 1985 /* FALLTHRU */
ian@0 1986
ian@0 1987 case ST_TABLE_6:
ian@0 1988 switch (token)
ian@0 1989 {
ian@0 1990 case '{': case '[': case '(':
ian@0 1991 ++count;
ian@0 1992 break;
ian@0 1993 case '}': case ']': case ')':
ian@0 1994 --count;
ian@0 1995 break;
ian@0 1996 case ',':
ian@0 1997 if (count == 0)
ian@0 1998 lexstate = ST_TABLE_2;
ian@0 1999 break;
ian@0 2000 };
ian@0 2001 goto repeat;
ian@0 2002
ian@0 2003 case ST_TABLE_3:
ian@0 2004 goto repeat;
ian@0 2005
ian@0 2006 case ST_TABLE_4:
ian@0 2007 if (token == ';')
ian@0 2008 lexstate = ST_NORMAL;
ian@0 2009 goto repeat;
ian@0 2010
ian@0 2011 case ST_TABLE_5:
ian@0 2012 switch (token)
ian@0 2013 {
ian@0 2014 case ',':
ian@0 2015 token = ';';
ian@0 2016 lexstate = ST_TABLE_2;
ian@0 2017 APP;
ian@0 2018 break;
ian@0 2019 default:
ian@0 2020 APP;
ian@0 2021 break;
ian@0 2022 }
ian@0 2023 break;
ian@0 2024
ian@0 2025 default:
ian@0 2026 exit(1);
ian@0 2027 }
ian@0 2028 fini:
ian@0 2029
ian@0 2030 if (suppress_type_lookup > 0)
ian@0 2031 --suppress_type_lookup;
ian@0 2032 if (dont_want_brace_phrase > 0)
ian@0 2033 --dont_want_brace_phrase;
ian@0 2034
ian@0 2035 yylval = &next_node->next;
ian@0 2036
ian@0 2037 return token;
ian@0 2038 }
ian@0 2039 /* A Bison parser, made by GNU Bison 2.0. */
ian@0 2040
ian@0 2041 /* Skeleton parser for Yacc-like parsing with Bison,
ian@0 2042 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
ian@0 2043
ian@0 2044 This program is free software; you can redistribute it and/or modify
ian@0 2045 it under the terms of the GNU General Public License as published by
ian@0 2046 the Free Software Foundation; either version 2, or (at your option)
ian@0 2047 any later version.
ian@0 2048
ian@0 2049 This program is distributed in the hope that it will be useful,
ian@0 2050 but WITHOUT ANY WARRANTY; without even the implied warranty of
ian@0 2051 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
ian@0 2052 GNU General Public License for more details.
ian@0 2053
ian@0 2054 You should have received a copy of the GNU General Public License
ian@0 2055 along with this program; if not, write to the Free Software
ian@0 2056 Foundation, Inc., 59 Temple Place - Suite 330,
ian@0 2057 Boston, MA 02111-1307, USA. */
ian@0 2058
ian@0 2059 /* As a special exception, when this file is copied by Bison into a
ian@0 2060 Bison output file, you may use that output file without restriction.
ian@0 2061 This special exception was added by the Free Software Foundation
ian@0 2062 in version 1.24 of Bison. */
ian@0 2063
ian@0 2064 /* Tokens. */
ian@0 2065 #ifndef YYTOKENTYPE
ian@0 2066 # define YYTOKENTYPE
ian@0 2067 /* Put the tokens into the symbol table, so that GDB and other debuggers
ian@0 2068 know about them. */
ian@0 2069 enum yytokentype {
ian@0 2070 ASM_KEYW = 258,
ian@0 2071 ATTRIBUTE_KEYW = 259,
ian@0 2072 AUTO_KEYW = 260,
ian@0 2073 BOOL_KEYW = 261,
ian@0 2074 CHAR_KEYW = 262,
ian@0 2075 CONST_KEYW = 263,
ian@0 2076 DOUBLE_KEYW = 264,
ian@0 2077 ENUM_KEYW = 265,
ian@0 2078 EXTERN_KEYW = 266,
ian@0 2079 FLOAT_KEYW = 267,
ian@0 2080 INLINE_KEYW = 268,
ian@0 2081 INT_KEYW = 269,
ian@0 2082 LONG_KEYW = 270,
ian@0 2083 REGISTER_KEYW = 271,
ian@0 2084 RESTRICT_KEYW = 272,
ian@0 2085 SHORT_KEYW = 273,
ian@0 2086 SIGNED_KEYW = 274,
ian@0 2087 STATIC_KEYW = 275,
ian@0 2088 STRUCT_KEYW = 276,
ian@0 2089 TYPEDEF_KEYW = 277,
ian@0 2090 UNION_KEYW = 278,
ian@0 2091 UNSIGNED_KEYW = 279,
ian@0 2092 VOID_KEYW = 280,
ian@0 2093 VOLATILE_KEYW = 281,
ian@0 2094 TYPEOF_KEYW = 282,
ian@0 2095 EXPORT_SYMBOL_KEYW = 283,
ian@0 2096 ASM_PHRASE = 284,
ian@0 2097 ATTRIBUTE_PHRASE = 285,
ian@0 2098 BRACE_PHRASE = 286,
ian@0 2099 BRACKET_PHRASE = 287,
ian@0 2100 EXPRESSION_PHRASE = 288,
ian@0 2101 CHAR = 289,
ian@0 2102 DOTS = 290,
ian@0 2103 IDENT = 291,
ian@0 2104 INT = 292,
ian@0 2105 REAL = 293,
ian@0 2106 STRING = 294,
ian@0 2107 TYPE = 295,
ian@0 2108 OTHER = 296,
ian@0 2109 FILENAME = 297
ian@0 2110 };
ian@0 2111 #endif
ian@0 2112 #define ASM_KEYW 258
ian@0 2113 #define ATTRIBUTE_KEYW 259
ian@0 2114 #define AUTO_KEYW 260
ian@0 2115 #define BOOL_KEYW 261
ian@0 2116 #define CHAR_KEYW 262
ian@0 2117 #define CONST_KEYW 263
ian@0 2118 #define DOUBLE_KEYW 264
ian@0 2119 #define ENUM_KEYW 265
ian@0 2120 #define EXTERN_KEYW 266
ian@0 2121 #define FLOAT_KEYW 267
ian@0 2122 #define INLINE_KEYW 268
ian@0 2123 #define INT_KEYW 269
ian@0 2124 #define LONG_KEYW 270
ian@0 2125 #define REGISTER_KEYW 271
ian@0 2126 #define RESTRICT_KEYW 272
ian@0 2127 #define SHORT_KEYW 273
ian@0 2128 #define SIGNED_KEYW 274
ian@0 2129 #define STATIC_KEYW 275
ian@0 2130 #define STRUCT_KEYW 276
ian@0 2131 #define TYPEDEF_KEYW 277
ian@0 2132 #define UNION_KEYW 278
ian@0 2133 #define UNSIGNED_KEYW 279
ian@0 2134 #define VOID_KEYW 280
ian@0 2135 #define VOLATILE_KEYW 281
ian@0 2136 #define TYPEOF_KEYW 282
ian@0 2137 #define EXPORT_SYMBOL_KEYW 283
ian@0 2138 #define ASM_PHRASE 284
ian@0 2139 #define ATTRIBUTE_PHRASE 285
ian@0 2140 #define BRACE_PHRASE 286
ian@0 2141 #define BRACKET_PHRASE 287
ian@0 2142 #define EXPRESSION_PHRASE 288
ian@0 2143 #define CHAR 289
ian@0 2144 #define DOTS 290
ian@0 2145 #define IDENT 291
ian@0 2146 #define INT 292
ian@0 2147 #define REAL 293
ian@0 2148 #define STRING 294
ian@0 2149 #define TYPE 295
ian@0 2150 #define OTHER 296
ian@0 2151 #define FILENAME 297
ian@0 2152
ian@0 2153
ian@0 2154
ian@0 2155
ian@0 2156 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
ian@0 2157 typedef int YYSTYPE;
ian@0 2158 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
ian@0 2159 # define YYSTYPE_IS_DECLARED 1
ian@0 2160 # define YYSTYPE_IS_TRIVIAL 1
ian@0 2161 #endif
ian@0 2162
ian@0 2163 extern YYSTYPE yylval;
ian@0 2164
ian@0 2165
ian@0 2166