Branch data Line data Source code
1 : :
2 : : #line 3 "i386_lex.c"
3 : :
4 : : #define YY_INT_ALIGNED short int
5 : :
6 : : /* A lexical scanner generated by flex */
7 : :
8 : : #define yy_create_buffer i386__create_buffer
9 : : #define yy_delete_buffer i386__delete_buffer
10 : : #define yy_scan_buffer i386__scan_buffer
11 : : #define yy_scan_string i386__scan_string
12 : : #define yy_scan_bytes i386__scan_bytes
13 : : #define yy_init_buffer i386__init_buffer
14 : : #define yy_flush_buffer i386__flush_buffer
15 : : #define yy_load_buffer_state i386__load_buffer_state
16 : : #define yy_switch_to_buffer i386__switch_to_buffer
17 : : #define yypush_buffer_state i386_push_buffer_state
18 : : #define yypop_buffer_state i386_pop_buffer_state
19 : : #define yyensure_buffer_stack i386_ensure_buffer_stack
20 : : #define yy_flex_debug i386__flex_debug
21 : : #define yyin i386_in
22 : : #define yyleng i386_leng
23 : : #define yylex i386_lex
24 : : #define yylineno i386_lineno
25 : : #define yyout i386_out
26 : : #define yyrestart i386_restart
27 : : #define yytext i386_text
28 : : #define yywrap i386_wrap
29 : : #define yyalloc i386_alloc
30 : : #define yyrealloc i386_realloc
31 : : #define yyfree i386_free
32 : :
33 : : #define FLEX_SCANNER
34 : : #define YY_FLEX_MAJOR_VERSION 2
35 : : #define YY_FLEX_MINOR_VERSION 6
36 : : #define YY_FLEX_SUBMINOR_VERSION 4
37 : : #if YY_FLEX_SUBMINOR_VERSION > 0
38 : : #define FLEX_BETA
39 : : #endif
40 : :
41 : : #ifdef yy_create_buffer
42 : : #define i386__create_buffer_ALREADY_DEFINED
43 : : #else
44 : : #define yy_create_buffer i386__create_buffer
45 : : #endif
46 : :
47 : : #ifdef yy_delete_buffer
48 : : #define i386__delete_buffer_ALREADY_DEFINED
49 : : #else
50 : : #define yy_delete_buffer i386__delete_buffer
51 : : #endif
52 : :
53 : : #ifdef yy_scan_buffer
54 : : #define i386__scan_buffer_ALREADY_DEFINED
55 : : #else
56 : : #define yy_scan_buffer i386__scan_buffer
57 : : #endif
58 : :
59 : : #ifdef yy_scan_string
60 : : #define i386__scan_string_ALREADY_DEFINED
61 : : #else
62 : : #define yy_scan_string i386__scan_string
63 : : #endif
64 : :
65 : : #ifdef yy_scan_bytes
66 : : #define i386__scan_bytes_ALREADY_DEFINED
67 : : #else
68 : : #define yy_scan_bytes i386__scan_bytes
69 : : #endif
70 : :
71 : : #ifdef yy_init_buffer
72 : : #define i386__init_buffer_ALREADY_DEFINED
73 : : #else
74 : : #define yy_init_buffer i386__init_buffer
75 : : #endif
76 : :
77 : : #ifdef yy_flush_buffer
78 : : #define i386__flush_buffer_ALREADY_DEFINED
79 : : #else
80 : : #define yy_flush_buffer i386__flush_buffer
81 : : #endif
82 : :
83 : : #ifdef yy_load_buffer_state
84 : : #define i386__load_buffer_state_ALREADY_DEFINED
85 : : #else
86 : : #define yy_load_buffer_state i386__load_buffer_state
87 : : #endif
88 : :
89 : : #ifdef yy_switch_to_buffer
90 : : #define i386__switch_to_buffer_ALREADY_DEFINED
91 : : #else
92 : : #define yy_switch_to_buffer i386__switch_to_buffer
93 : : #endif
94 : :
95 : : #ifdef yypush_buffer_state
96 : : #define i386_push_buffer_state_ALREADY_DEFINED
97 : : #else
98 : : #define yypush_buffer_state i386_push_buffer_state
99 : : #endif
100 : :
101 : : #ifdef yypop_buffer_state
102 : : #define i386_pop_buffer_state_ALREADY_DEFINED
103 : : #else
104 : : #define yypop_buffer_state i386_pop_buffer_state
105 : : #endif
106 : :
107 : : #ifdef yyensure_buffer_stack
108 : : #define i386_ensure_buffer_stack_ALREADY_DEFINED
109 : : #else
110 : : #define yyensure_buffer_stack i386_ensure_buffer_stack
111 : : #endif
112 : :
113 : : #ifdef yylex
114 : : #define i386_lex_ALREADY_DEFINED
115 : : #else
116 : : #define yylex i386_lex
117 : : #endif
118 : :
119 : : #ifdef yyrestart
120 : : #define i386_restart_ALREADY_DEFINED
121 : : #else
122 : : #define yyrestart i386_restart
123 : : #endif
124 : :
125 : : #ifdef yylex_init
126 : : #define i386_lex_init_ALREADY_DEFINED
127 : : #else
128 : : #define yylex_init i386_lex_init
129 : : #endif
130 : :
131 : : #ifdef yylex_init_extra
132 : : #define i386_lex_init_extra_ALREADY_DEFINED
133 : : #else
134 : : #define yylex_init_extra i386_lex_init_extra
135 : : #endif
136 : :
137 : : #ifdef yylex_destroy
138 : : #define i386_lex_destroy_ALREADY_DEFINED
139 : : #else
140 : : #define yylex_destroy i386_lex_destroy
141 : : #endif
142 : :
143 : : #ifdef yyget_debug
144 : : #define i386_get_debug_ALREADY_DEFINED
145 : : #else
146 : : #define yyget_debug i386_get_debug
147 : : #endif
148 : :
149 : : #ifdef yyset_debug
150 : : #define i386_set_debug_ALREADY_DEFINED
151 : : #else
152 : : #define yyset_debug i386_set_debug
153 : : #endif
154 : :
155 : : #ifdef yyget_extra
156 : : #define i386_get_extra_ALREADY_DEFINED
157 : : #else
158 : : #define yyget_extra i386_get_extra
159 : : #endif
160 : :
161 : : #ifdef yyset_extra
162 : : #define i386_set_extra_ALREADY_DEFINED
163 : : #else
164 : : #define yyset_extra i386_set_extra
165 : : #endif
166 : :
167 : : #ifdef yyget_in
168 : : #define i386_get_in_ALREADY_DEFINED
169 : : #else
170 : : #define yyget_in i386_get_in
171 : : #endif
172 : :
173 : : #ifdef yyset_in
174 : : #define i386_set_in_ALREADY_DEFINED
175 : : #else
176 : : #define yyset_in i386_set_in
177 : : #endif
178 : :
179 : : #ifdef yyget_out
180 : : #define i386_get_out_ALREADY_DEFINED
181 : : #else
182 : : #define yyget_out i386_get_out
183 : : #endif
184 : :
185 : : #ifdef yyset_out
186 : : #define i386_set_out_ALREADY_DEFINED
187 : : #else
188 : : #define yyset_out i386_set_out
189 : : #endif
190 : :
191 : : #ifdef yyget_leng
192 : : #define i386_get_leng_ALREADY_DEFINED
193 : : #else
194 : : #define yyget_leng i386_get_leng
195 : : #endif
196 : :
197 : : #ifdef yyget_text
198 : : #define i386_get_text_ALREADY_DEFINED
199 : : #else
200 : : #define yyget_text i386_get_text
201 : : #endif
202 : :
203 : : #ifdef yyget_lineno
204 : : #define i386_get_lineno_ALREADY_DEFINED
205 : : #else
206 : : #define yyget_lineno i386_get_lineno
207 : : #endif
208 : :
209 : : #ifdef yyset_lineno
210 : : #define i386_set_lineno_ALREADY_DEFINED
211 : : #else
212 : : #define yyset_lineno i386_set_lineno
213 : : #endif
214 : :
215 : : #ifdef yywrap
216 : : #define i386_wrap_ALREADY_DEFINED
217 : : #else
218 : : #define yywrap i386_wrap
219 : : #endif
220 : :
221 : : #ifdef yyalloc
222 : : #define i386_alloc_ALREADY_DEFINED
223 : : #else
224 : : #define yyalloc i386_alloc
225 : : #endif
226 : :
227 : : #ifdef yyrealloc
228 : : #define i386_realloc_ALREADY_DEFINED
229 : : #else
230 : : #define yyrealloc i386_realloc
231 : : #endif
232 : :
233 : : #ifdef yyfree
234 : : #define i386_free_ALREADY_DEFINED
235 : : #else
236 : : #define yyfree i386_free
237 : : #endif
238 : :
239 : : #ifdef yytext
240 : : #define i386_text_ALREADY_DEFINED
241 : : #else
242 : : #define yytext i386_text
243 : : #endif
244 : :
245 : : #ifdef yyleng
246 : : #define i386_leng_ALREADY_DEFINED
247 : : #else
248 : : #define yyleng i386_leng
249 : : #endif
250 : :
251 : : #ifdef yyin
252 : : #define i386_in_ALREADY_DEFINED
253 : : #else
254 : : #define yyin i386_in
255 : : #endif
256 : :
257 : : #ifdef yyout
258 : : #define i386_out_ALREADY_DEFINED
259 : : #else
260 : : #define yyout i386_out
261 : : #endif
262 : :
263 : : #ifdef yy_flex_debug
264 : : #define i386__flex_debug_ALREADY_DEFINED
265 : : #else
266 : : #define yy_flex_debug i386__flex_debug
267 : : #endif
268 : :
269 : : #ifdef yylineno
270 : : #define i386_lineno_ALREADY_DEFINED
271 : : #else
272 : : #define yylineno i386_lineno
273 : : #endif
274 : :
275 : : /* First, we deal with platform-specific or compiler-specific issues. */
276 : :
277 : : /* begin standard C headers. */
278 : : #include <stdio.h>
279 : : #include <string.h>
280 : : #include <errno.h>
281 : : #include <stdlib.h>
282 : :
283 : : /* end standard C headers. */
284 : :
285 : : /* flex integer type definitions */
286 : :
287 : : #ifndef FLEXINT_H
288 : : #define FLEXINT_H
289 : :
290 : : /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
291 : :
292 : : #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
293 : :
294 : : /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
295 : : * if you want the limit (max/min) macros for int types.
296 : : */
297 : : #ifndef __STDC_LIMIT_MACROS
298 : : #define __STDC_LIMIT_MACROS 1
299 : : #endif
300 : :
301 : : #include <inttypes.h>
302 : : typedef int8_t flex_int8_t;
303 : : typedef uint8_t flex_uint8_t;
304 : : typedef int16_t flex_int16_t;
305 : : typedef uint16_t flex_uint16_t;
306 : : typedef int32_t flex_int32_t;
307 : : typedef uint32_t flex_uint32_t;
308 : : #else
309 : : typedef signed char flex_int8_t;
310 : : typedef short int flex_int16_t;
311 : : typedef int flex_int32_t;
312 : : typedef unsigned char flex_uint8_t;
313 : : typedef unsigned short int flex_uint16_t;
314 : : typedef unsigned int flex_uint32_t;
315 : :
316 : : /* Limits of integral types. */
317 : : #ifndef INT8_MIN
318 : : #define INT8_MIN (-128)
319 : : #endif
320 : : #ifndef INT16_MIN
321 : : #define INT16_MIN (-32767-1)
322 : : #endif
323 : : #ifndef INT32_MIN
324 : : #define INT32_MIN (-2147483647-1)
325 : : #endif
326 : : #ifndef INT8_MAX
327 : : #define INT8_MAX (127)
328 : : #endif
329 : : #ifndef INT16_MAX
330 : : #define INT16_MAX (32767)
331 : : #endif
332 : : #ifndef INT32_MAX
333 : : #define INT32_MAX (2147483647)
334 : : #endif
335 : : #ifndef UINT8_MAX
336 : : #define UINT8_MAX (255U)
337 : : #endif
338 : : #ifndef UINT16_MAX
339 : : #define UINT16_MAX (65535U)
340 : : #endif
341 : : #ifndef UINT32_MAX
342 : : #define UINT32_MAX (4294967295U)
343 : : #endif
344 : :
345 : : #ifndef SIZE_MAX
346 : : #define SIZE_MAX (~(size_t)0)
347 : : #endif
348 : :
349 : : #endif /* ! C99 */
350 : :
351 : : #endif /* ! FLEXINT_H */
352 : :
353 : : /* begin standard C++ headers. */
354 : :
355 : : /* TODO: this is always defined, so inline it */
356 : : #define yyconst const
357 : :
358 : : #if defined(__GNUC__) && __GNUC__ >= 3
359 : : #define yynoreturn __attribute__((__noreturn__))
360 : : #else
361 : : #define yynoreturn
362 : : #endif
363 : :
364 : : /* Returned upon end-of-file. */
365 : : #define YY_NULL 0
366 : :
367 : : /* Promotes a possibly negative, possibly signed char to an
368 : : * integer in range [0..255] for use as an array index.
369 : : */
370 : : #define YY_SC_TO_UI(c) ((YY_CHAR) (c))
371 : :
372 : : /* Enter a start condition. This macro really ought to take a parameter,
373 : : * but we do it the disgusting crufty way forced on us by the ()-less
374 : : * definition of BEGIN.
375 : : */
376 : : #define BEGIN (yy_start) = 1 + 2 *
377 : : /* Translate the current start state into a value that can be later handed
378 : : * to BEGIN to return to the state. The YYSTATE alias is for lex
379 : : * compatibility.
380 : : */
381 : : #define YY_START (((yy_start) - 1) / 2)
382 : : #define YYSTATE YY_START
383 : : /* Action number for EOF rule of a given start state. */
384 : : #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
385 : : /* Special action meaning "start processing a new file". */
386 : : #define YY_NEW_FILE yyrestart( yyin )
387 : : #define YY_END_OF_BUFFER_CHAR 0
388 : :
389 : : /* Size of default input buffer. */
390 : : #ifndef YY_BUF_SIZE
391 : : #ifdef __ia64__
392 : : /* On IA-64, the buffer size is 16k, not 8k.
393 : : * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
394 : : * Ditto for the __ia64__ case accordingly.
395 : : */
396 : : #define YY_BUF_SIZE 32768
397 : : #else
398 : : #define YY_BUF_SIZE 16384
399 : : #endif /* __ia64__ */
400 : : #endif
401 : :
402 : : /* The state buf must be large enough to hold one state per character in the main buffer.
403 : : */
404 : : #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
405 : :
406 : : #ifndef YY_TYPEDEF_YY_BUFFER_STATE
407 : : #define YY_TYPEDEF_YY_BUFFER_STATE
408 : : typedef struct yy_buffer_state *YY_BUFFER_STATE;
409 : : #endif
410 : :
411 : : #ifndef YY_TYPEDEF_YY_SIZE_T
412 : : #define YY_TYPEDEF_YY_SIZE_T
413 : : typedef size_t yy_size_t;
414 : : #endif
415 : :
416 : : extern int yyleng;
417 : :
418 : : extern FILE *yyin, *yyout;
419 : :
420 : : #define EOB_ACT_CONTINUE_SCAN 0
421 : : #define EOB_ACT_END_OF_FILE 1
422 : : #define EOB_ACT_LAST_MATCH 2
423 : :
424 : : /* Note: We specifically omit the test for yy_rule_can_match_eol because it requires
425 : : * access to the local variable yy_act. Since yyless() is a macro, it would break
426 : : * existing scanners that call yyless() from OUTSIDE yylex.
427 : : * One obvious solution it to make yy_act a global. I tried that, and saw
428 : : * a 5% performance hit in a non-yylineno scanner, because yy_act is
429 : : * normally declared as a register variable-- so it is not worth it.
430 : : */
431 : : #define YY_LESS_LINENO(n) \
432 : : do { \
433 : : int yyl;\
434 : : for ( yyl = n; yyl < yyleng; ++yyl )\
435 : : if ( yytext[yyl] == '\n' )\
436 : : --yylineno;\
437 : : }while(0)
438 : : #define YY_LINENO_REWIND_TO(dst) \
439 : : do {\
440 : : const char *p;\
441 : : for ( p = yy_cp-1; p >= (dst); --p)\
442 : : if ( *p == '\n' )\
443 : : --yylineno;\
444 : : }while(0)
445 : :
446 : : /* Return all but the first "n" matched characters back to the input stream. */
447 : : #define yyless(n) \
448 : : do \
449 : : { \
450 : : /* Undo effects of setting up yytext. */ \
451 : : int yyless_macro_arg = (n); \
452 : : YY_LESS_LINENO(yyless_macro_arg);\
453 : : *yy_cp = (yy_hold_char); \
454 : : YY_RESTORE_YY_MORE_OFFSET \
455 : : (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
456 : : YY_DO_BEFORE_ACTION; /* set up yytext again */ \
457 : : } \
458 : : while ( 0 )
459 : : #define unput(c) yyunput( c, (yytext_ptr) )
460 : :
461 : : #ifndef YY_STRUCT_YY_BUFFER_STATE
462 : : #define YY_STRUCT_YY_BUFFER_STATE
463 : : struct yy_buffer_state
464 : : {
465 : : FILE *yy_input_file;
466 : :
467 : : char *yy_ch_buf; /* input buffer */
468 : : char *yy_buf_pos; /* current position in input buffer */
469 : :
470 : : /* Size of input buffer in bytes, not including room for EOB
471 : : * characters.
472 : : */
473 : : int yy_buf_size;
474 : :
475 : : /* Number of characters read into yy_ch_buf, not including EOB
476 : : * characters.
477 : : */
478 : : int yy_n_chars;
479 : :
480 : : /* Whether we "own" the buffer - i.e., we know we created it,
481 : : * and can realloc() it to grow it, and should free() it to
482 : : * delete it.
483 : : */
484 : : int yy_is_our_buffer;
485 : :
486 : : /* Whether this is an "interactive" input source; if so, and
487 : : * if we're using stdio for input, then we want to use getc()
488 : : * instead of fread(), to make sure we stop fetching input after
489 : : * each newline.
490 : : */
491 : : int yy_is_interactive;
492 : :
493 : : /* Whether we're considered to be at the beginning of a line.
494 : : * If so, '^' rules will be active on the next match, otherwise
495 : : * not.
496 : : */
497 : : int yy_at_bol;
498 : :
499 : : int yy_bs_lineno; /**< The line count. */
500 : : int yy_bs_column; /**< The column count. */
501 : :
502 : : /* Whether to try to fill the input buffer when we reach the
503 : : * end of it.
504 : : */
505 : : int yy_fill_buffer;
506 : :
507 : : int yy_buffer_status;
508 : :
509 : : #define YY_BUFFER_NEW 0
510 : : #define YY_BUFFER_NORMAL 1
511 : : /* When an EOF's been seen but there's still some text to process
512 : : * then we mark the buffer as YY_EOF_PENDING, to indicate that we
513 : : * shouldn't try reading from the input source any more. We might
514 : : * still have a bunch of tokens to match, though, because of
515 : : * possible backing-up.
516 : : *
517 : : * When we actually see the EOF, we change the status to "new"
518 : : * (via yyrestart()), so that the user can continue scanning by
519 : : * just pointing yyin at a new input file.
520 : : */
521 : : #define YY_BUFFER_EOF_PENDING 2
522 : :
523 : : };
524 : : #endif /* !YY_STRUCT_YY_BUFFER_STATE */
525 : :
526 : : /* Stack of input buffers. */
527 : : static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
528 : : static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
529 : : static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */
530 : :
531 : : /* We provide macros for accessing buffer states in case in the
532 : : * future we want to put the buffer states in a more general
533 : : * "scanner state".
534 : : *
535 : : * Returns the top of the stack, or NULL.
536 : : */
537 : : #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
538 : : ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
539 : : : NULL)
540 : : /* Same as previous macro, but useful when we know that the buffer stack is not
541 : : * NULL or when we need an lvalue. For internal use only.
542 : : */
543 : : #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
544 : :
545 : : /* yy_hold_char holds the character lost when yytext is formed. */
546 : : static char yy_hold_char;
547 : : static int yy_n_chars; /* number of characters read into yy_ch_buf */
548 : : int yyleng;
549 : :
550 : : /* Points to current character in buffer. */
551 : : static char *yy_c_buf_p = NULL;
552 : : static int yy_init = 0; /* whether we need to initialize */
553 : : static int yy_start = 0; /* start state number */
554 : :
555 : : /* Flag which is used to allow yywrap()'s to do buffer switches
556 : : * instead of setting up a fresh yyin. A bit of a hack ...
557 : : */
558 : : static int yy_did_buffer_switch_on_eof;
559 : :
560 : : void yyrestart ( FILE *input_file );
561 : : void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer );
562 : : YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size );
563 : : void yy_delete_buffer ( YY_BUFFER_STATE b );
564 : : void yy_flush_buffer ( YY_BUFFER_STATE b );
565 : : void yypush_buffer_state ( YY_BUFFER_STATE new_buffer );
566 : : void yypop_buffer_state ( void );
567 : :
568 : : static void yyensure_buffer_stack ( void );
569 : : static void yy_load_buffer_state ( void );
570 : : static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file );
571 : : #define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER )
572 : :
573 : : YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size );
574 : : YY_BUFFER_STATE yy_scan_string ( const char *yy_str );
575 : : YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len );
576 : :
577 : : void *yyalloc ( yy_size_t );
578 : : void *yyrealloc ( void *, yy_size_t );
579 : : void yyfree ( void * );
580 : :
581 : : #define yy_new_buffer yy_create_buffer
582 : : #define yy_set_interactive(is_interactive) \
583 : : { \
584 : : if ( ! YY_CURRENT_BUFFER ){ \
585 : : yyensure_buffer_stack (); \
586 : : YY_CURRENT_BUFFER_LVALUE = \
587 : : yy_create_buffer( yyin, YY_BUF_SIZE ); \
588 : : } \
589 : : YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
590 : : }
591 : : #define yy_set_bol(at_bol) \
592 : : { \
593 : : if ( ! YY_CURRENT_BUFFER ){\
594 : : yyensure_buffer_stack (); \
595 : : YY_CURRENT_BUFFER_LVALUE = \
596 : : yy_create_buffer( yyin, YY_BUF_SIZE ); \
597 : : } \
598 : : YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
599 : : }
600 : : #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
601 : :
602 : : /* Begin user sect3 */
603 : :
604 : : #define i386_wrap() (/*CONSTCOND*/1)
605 : : #define YY_SKIP_YYWRAP
606 : : typedef flex_uint8_t YY_CHAR;
607 : :
608 : : FILE *yyin = NULL, *yyout = NULL;
609 : :
610 : : typedef int yy_state_type;
611 : :
612 : : extern int yylineno;
613 : : int yylineno = 1;
614 : :
615 : : extern char *yytext;
616 : : #ifdef yytext_ptr
617 : : #undef yytext_ptr
618 : : #endif
619 : : #define yytext_ptr yytext
620 : :
621 : : static yy_state_type yy_get_previous_state ( void );
622 : : static yy_state_type yy_try_NUL_trans ( yy_state_type current_state );
623 : : static int yy_get_next_buffer ( void );
624 : : static void yynoreturn yy_fatal_error ( const char* msg );
625 : :
626 : : /* Done after the current pattern has been matched and before the
627 : : * corresponding action - sets up yytext.
628 : : */
629 : : #define YY_DO_BEFORE_ACTION \
630 : : (yytext_ptr) = yy_bp; \
631 : : yyleng = (int) (yy_cp - yy_bp); \
632 : : (yy_hold_char) = *yy_cp; \
633 : : *yy_cp = '\0'; \
634 : : (yy_c_buf_p) = yy_cp;
635 : : #define YY_NUM_RULES 21
636 : : #define YY_END_OF_BUFFER 22
637 : : /* This struct is not used in this scanner,
638 : : but its presence is necessary. */
639 : : struct yy_trans_info
640 : : {
641 : : flex_int32_t yy_verify;
642 : : flex_int32_t yy_nxt;
643 : : };
644 : : static const flex_int16_t yy_accept[62] =
645 : : { 0,
646 : : 0, 0, 0, 0, 22, 20, 17, 15, 20, 5,
647 : : 20, 14, 16, 19, 18, 15, 12, 7, 8, 13,
648 : : 11, 11, 19, 14, 16, 17, 6, 0, 0, 0,
649 : : 5, 0, 9, 18, 11, 11, 0, 0, 0, 0,
650 : : 11, 0, 0, 0, 0, 11, 1, 0, 0, 0,
651 : : 11, 0, 0, 0, 11, 2, 3, 0, 10, 4,
652 : : 0
653 : : } ;
654 : :
655 : : static const YY_CHAR yy_ec[256] =
656 : : { 0,
657 : : 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
658 : : 2, 2, 2, 1, 1, 1, 1, 1, 1, 1,
659 : : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
660 : : 1, 2, 1, 1, 4, 1, 5, 1, 1, 1,
661 : : 1, 1, 1, 6, 1, 1, 7, 8, 9, 10,
662 : : 10, 10, 10, 10, 10, 10, 10, 11, 1, 1,
663 : : 1, 1, 1, 1, 12, 13, 13, 14, 13, 13,
664 : : 13, 13, 15, 13, 13, 16, 13, 17, 13, 13,
665 : : 13, 13, 13, 13, 13, 18, 13, 13, 13, 13,
666 : : 1, 1, 1, 1, 13, 1, 19, 13, 13, 13,
667 : :
668 : : 20, 21, 13, 13, 22, 13, 23, 13, 24, 25,
669 : : 26, 27, 13, 28, 29, 13, 30, 13, 13, 31,
670 : : 32, 13, 33, 1, 34, 1, 1, 1, 1, 1,
671 : : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
672 : : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
673 : : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
674 : : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
675 : : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
676 : : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
677 : : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
678 : :
679 : : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
680 : : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
681 : : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
682 : : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
683 : : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
684 : : 1, 1, 1, 1, 1
685 : : } ;
686 : :
687 : : static const YY_CHAR yy_meta[35] =
688 : : { 0,
689 : : 1, 1, 1, 1, 1, 1, 2, 2, 2, 2,
690 : : 3, 2, 2, 2, 2, 2, 2, 2, 2, 2,
691 : : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
692 : : 2, 2, 1, 3
693 : : } ;
694 : :
695 : : static const flex_int16_t yy_base[65] =
696 : : { 0,
697 : : 0, 32, 65, 3, 113, 114, 9, 11, 19, 7,
698 : : 78, 16, 114, 114, 18, 20, 114, 114, 114, 114,
699 : : 0, 94, 76, 23, 114, 25, 114, 90, 80, 0,
700 : : 41, 73, 114, 36, 0, 88, 76, 44, 42, 37,
701 : : 49, 37, 38, 37, 31, 40, 114, 33, 32, 28,
702 : : 37, 16, 14, 12, 17, 114, 114, 5, 0, 114,
703 : : 114, 99, 101, 2
704 : : } ;
705 : :
706 : : static const flex_int16_t yy_def[65] =
707 : : { 0,
708 : : 62, 62, 61, 3, 61, 61, 61, 61, 61, 61,
709 : : 63, 61, 61, 61, 61, 61, 61, 61, 61, 61,
710 : : 64, 64, 63, 61, 61, 61, 61, 61, 61, 61,
711 : : 61, 63, 61, 61, 64, 64, 61, 61, 61, 61,
712 : : 64, 61, 61, 61, 61, 64, 61, 61, 61, 61,
713 : : 64, 61, 61, 61, 64, 61, 61, 61, 64, 61,
714 : : 0, 61, 61, 61
715 : : } ;
716 : :
717 : : static const flex_int16_t yy_nxt[149] =
718 : : { 0,
719 : : 61, 7, 8, 35, 9, 24, 25, 10, 10, 10,
720 : : 26, 26, 26, 26, 31, 31, 31, 26, 26, 34,
721 : : 34, 34, 34, 27, 34, 34, 26, 26, 60, 39,
722 : : 59, 40, 11, 7, 12, 13, 9, 34, 34, 10,
723 : : 10, 10, 28, 58, 57, 29, 56, 30, 31, 31,
724 : : 31, 55, 54, 53, 52, 51, 50, 49, 48, 47,
725 : : 46, 45, 44, 43, 11, 14, 15, 16, 14, 14,
726 : : 17, 14, 18, 19, 14, 20, 21, 21, 21, 22,
727 : : 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,
728 : : 21, 21, 21, 21, 21, 21, 21, 23, 14, 6,
729 : :
730 : : 6, 6, 32, 32, 42, 41, 33, 38, 37, 33,
731 : : 36, 33, 61, 5, 61, 61, 61, 61, 61, 61,
732 : : 61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
733 : : 61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
734 : : 61, 61, 61, 61, 61, 61, 61, 61
735 : : } ;
736 : :
737 : : static const flex_int16_t yy_chk[149] =
738 : : { 0,
739 : : 0, 1, 1, 64, 1, 4, 4, 1, 1, 1,
740 : : 7, 7, 8, 8, 10, 10, 10, 12, 12, 15,
741 : : 15, 16, 16, 9, 24, 24, 26, 26, 58, 30,
742 : : 55, 30, 1, 2, 2, 2, 2, 34, 34, 2,
743 : : 2, 2, 9, 54, 53, 9, 52, 9, 31, 31,
744 : : 31, 51, 50, 49, 48, 46, 45, 44, 43, 42,
745 : : 41, 40, 39, 38, 2, 3, 3, 3, 3, 3,
746 : : 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
747 : : 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
748 : : 3, 3, 3, 3, 3, 3, 3, 3, 3, 62,
749 : :
750 : : 62, 62, 63, 63, 37, 36, 32, 29, 28, 23,
751 : : 22, 11, 5, 61, 61, 61, 61, 61, 61, 61,
752 : : 61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
753 : : 61, 61, 61, 61, 61, 61, 61, 61, 61, 61,
754 : : 61, 61, 61, 61, 61, 61, 61, 61
755 : : } ;
756 : :
757 : : /* Table of booleans, true if rule could match eol. */
758 : : static const flex_int32_t yy_rule_can_match_eol[22] =
759 : : { 0,
760 : : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0,
761 : : 0, 0, };
762 : :
763 : : static yy_state_type yy_last_accepting_state;
764 : : static char *yy_last_accepting_cpos;
765 : :
766 : : extern int yy_flex_debug;
767 : : int yy_flex_debug = 0;
768 : :
769 : : /* The intent behind this definition is that it'll catch
770 : : * any uses of REJECT which flex missed.
771 : : */
772 : : #define REJECT reject_used_but_not_detected
773 : : #define yymore() yymore_used_but_not_detected
774 : : #define YY_MORE_ADJ 0
775 : : #define YY_RESTORE_YY_MORE_OFFSET
776 : : char *yytext;
777 : : #line 1 "i386_lex.l"
778 : : #line 2 "i386_lex.l"
779 : : /* Copyright (C) 2004, 2005, 2007, 2008 Red Hat, Inc.
780 : : Written by Ulrich Drepper <drepper@redhat.com>, 2004.
781 : :
782 : : This file is free software; you can redistribute it and/or modify
783 : : it under the terms of either
784 : :
785 : : * the GNU Lesser General Public License as published by the Free
786 : : Software Foundation; either version 3 of the License, or (at
787 : : your option) any later version
788 : :
789 : : or
790 : :
791 : : * the GNU General Public License as published by the Free
792 : : Software Foundation; either version 2 of the License, or (at
793 : : your option) any later version
794 : :
795 : : or both in parallel, as here.
796 : :
797 : : elfutils is distributed in the hope that it will be useful, but
798 : : WITHOUT ANY WARRANTY; without even the implied warranty of
799 : : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
800 : : General Public License for more details.
801 : :
802 : : You should have received copies of the GNU General Public License and
803 : : the GNU Lesser General Public License along with this program. If
804 : : not, see <http://www.gnu.org/licenses/>. */
805 : :
806 : : #ifdef HAVE_CONFIG_H
807 : : # include <config.h>
808 : : #endif
809 : :
810 : : #include <ctype.h>
811 : :
812 : : #include <libeu.h>
813 : : #include "system.h"
814 : : #include "i386_parse.h"
815 : :
816 : :
817 : : static void eat_to_eol (void);
818 : : static void invalid_char (int ch);
819 : : #line 820 "i386_lex.c"
820 : :
821 : : #line 822 "i386_lex.c"
822 : :
823 : : #define INITIAL 0
824 : : #define MAIN 1
825 : :
826 : : #ifndef YY_NO_UNISTD_H
827 : : /* Special case for "unistd.h", since it is non-ANSI. We include it way
828 : : * down here because we want the user's section 1 to have been scanned first.
829 : : * The user has a chance to override it with an option.
830 : : */
831 : : #include <unistd.h>
832 : : #endif
833 : :
834 : : #ifndef YY_EXTRA_TYPE
835 : : #define YY_EXTRA_TYPE void *
836 : : #endif
837 : :
838 : : static int yy_init_globals ( void );
839 : :
840 : : /* Accessor methods to globals.
841 : : These are made visible to non-reentrant scanners for convenience. */
842 : :
843 : : int yylex_destroy ( void );
844 : :
845 : : int yyget_debug ( void );
846 : :
847 : : void yyset_debug ( int debug_flag );
848 : :
849 : : YY_EXTRA_TYPE yyget_extra ( void );
850 : :
851 : : void yyset_extra ( YY_EXTRA_TYPE user_defined );
852 : :
853 : : FILE *yyget_in ( void );
854 : :
855 : : void yyset_in ( FILE * _in_str );
856 : :
857 : : FILE *yyget_out ( void );
858 : :
859 : : void yyset_out ( FILE * _out_str );
860 : :
861 : : int yyget_leng ( void );
862 : :
863 : : char *yyget_text ( void );
864 : :
865 : : int yyget_lineno ( void );
866 : :
867 : : void yyset_lineno ( int _line_number );
868 : :
869 : : /* Macros after this point can all be overridden by user definitions in
870 : : * section 1.
871 : : */
872 : :
873 : : #ifndef YY_SKIP_YYWRAP
874 : : #ifdef __cplusplus
875 : : extern "C" int yywrap ( void );
876 : : #else
877 : : extern int yywrap ( void );
878 : : #endif
879 : : #endif
880 : :
881 : : #ifndef YY_NO_UNPUT
882 : :
883 : : static void yyunput ( int c, char *buf_ptr );
884 : :
885 : : #endif
886 : :
887 : : #ifndef yytext_ptr
888 : : static void yy_flex_strncpy ( char *, const char *, int );
889 : : #endif
890 : :
891 : : #ifdef YY_NEED_STRLEN
892 : : static int yy_flex_strlen ( const char * );
893 : : #endif
894 : :
895 : : #ifndef YY_NO_INPUT
896 : : #ifdef __cplusplus
897 : : static int yyinput ( void );
898 : : #else
899 : : static int input ( void );
900 : : #endif
901 : :
902 : : #endif
903 : :
904 : : /* Amount of stuff to slurp up with each read. */
905 : : #ifndef YY_READ_BUF_SIZE
906 : : #ifdef __ia64__
907 : : /* On IA-64, the buffer size is 16k, not 8k */
908 : : #define YY_READ_BUF_SIZE 16384
909 : : #else
910 : : #define YY_READ_BUF_SIZE 8192
911 : : #endif /* __ia64__ */
912 : : #endif
913 : :
914 : : /* Copy whatever the last rule matched to the standard output. */
915 : : #ifndef ECHO
916 : : /* This used to be an fputs(), but since the string might contain NUL's,
917 : : * we now use fwrite().
918 : : */
919 : : #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
920 : : #endif
921 : :
922 : : /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
923 : : * is returned in "result".
924 : : */
925 : : #ifndef YY_INPUT
926 : : #define YY_INPUT(buf,result,max_size) \
927 : : if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
928 : : { \
929 : : int c = '*'; \
930 : : int n; \
931 : : for ( n = 0; n < max_size && \
932 : : (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
933 : : buf[n] = (char) c; \
934 : : if ( c == '\n' ) \
935 : : buf[n++] = (char) c; \
936 : : if ( c == EOF && ferror( yyin ) ) \
937 : : YY_FATAL_ERROR( "input in flex scanner failed" ); \
938 : : result = n; \
939 : : } \
940 : : else \
941 : : { \
942 : : errno=0; \
943 : : while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
944 : : { \
945 : : if( errno != EINTR) \
946 : : { \
947 : : YY_FATAL_ERROR( "input in flex scanner failed" ); \
948 : : break; \
949 : : } \
950 : : errno=0; \
951 : : clearerr(yyin); \
952 : : } \
953 : : }\
954 : : \
955 : :
956 : : #endif
957 : :
958 : : /* No semi-colon after return; correct usage is to write "yyterminate();" -
959 : : * we don't want an extra ';' after the "return" because that will cause
960 : : * some compilers to complain about unreachable statements.
961 : : */
962 : : #ifndef yyterminate
963 : : #define yyterminate() return YY_NULL
964 : : #endif
965 : :
966 : : /* Number of entries by which start-condition stack grows. */
967 : : #ifndef YY_START_STACK_INCR
968 : : #define YY_START_STACK_INCR 25
969 : : #endif
970 : :
971 : : /* Report a fatal error. */
972 : : #ifndef YY_FATAL_ERROR
973 : : #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
974 : : #endif
975 : :
976 : : /* end tables serialization structures and prototypes */
977 : :
978 : : /* Default declaration of generated scanner - a define so the user can
979 : : * easily add parameters.
980 : : */
981 : : #ifndef YY_DECL
982 : : #define YY_DECL_IS_OURS 1
983 : :
984 : : extern int yylex (void);
985 : :
986 : : #define YY_DECL int yylex (void)
987 : : #endif /* !YY_DECL */
988 : :
989 : : /* Code executed at the beginning of each rule, after yytext and yyleng
990 : : * have been set up.
991 : : */
992 : : #ifndef YY_USER_ACTION
993 : : #define YY_USER_ACTION
994 : : #endif
995 : :
996 : : /* Code executed at the end of each rule. */
997 : : #ifndef YY_BREAK
998 : : #define YY_BREAK /*LINTED*/break;
999 : : #endif
1000 : :
1001 : : #define YY_RULE_SETUP \
1002 : : if ( yyleng > 0 ) \
1003 : : YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
1004 : : (yytext[yyleng - 1] == '\n'); \
1005 : : YY_USER_ACTION
1006 : :
1007 : : /** The main scanner function which does all the work.
1008 : : */
1009 : 45251 : YY_DECL
1010 : : {
1011 : 45251 : yy_state_type yy_current_state;
1012 : 45251 : char *yy_cp, *yy_bp;
1013 : 45251 : int yy_act;
1014 : :
1015 [ + + ]: 45251 : if ( !(yy_init) )
1016 : : {
1017 : 2 : (yy_init) = 1;
1018 : :
1019 : : #ifdef YY_USER_INIT
1020 : : YY_USER_INIT;
1021 : : #endif
1022 : :
1023 [ + - ]: 2 : if ( ! (yy_start) )
1024 : 2 : (yy_start) = 1; /* first start state */
1025 : :
1026 [ - + ]: 2 : if ( ! yyin )
1027 : 0 : yyin = stdin;
1028 : :
1029 [ + - ]: 2 : if ( ! yyout )
1030 : 2 : yyout = stdout;
1031 : :
1032 [ - + - - ]: 2 : if ( ! YY_CURRENT_BUFFER ) {
1033 : 2 : yyensure_buffer_stack ();
1034 : 2 : YY_CURRENT_BUFFER_LVALUE =
1035 : 2 : yy_create_buffer( yyin, YY_BUF_SIZE );
1036 : : }
1037 : :
1038 : 2 : yy_load_buffer_state( );
1039 : : }
1040 : :
1041 : : {
1042 : : #line 56 "i386_lex.l"
1043 : :
1044 : :
1045 : : #line 1046 "i386_lex.c"
1046 : :
1047 : 45589 : while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
1048 : : {
1049 : 45589 : yy_cp = (yy_c_buf_p);
1050 : :
1051 : : /* Support of yytext. */
1052 : 45589 : *yy_cp = (yy_hold_char);
1053 : :
1054 : : /* yy_bp points to the position in yy_ch_buf of the start of
1055 : : * the current run.
1056 : : */
1057 : 45589 : yy_bp = yy_cp;
1058 : :
1059 : 45589 : yy_current_state = (yy_start);
1060 : 45589 : yy_current_state += YY_AT_BOL();
1061 : : yy_match:
1062 : 133225 : do
1063 : : {
1064 : 133225 : YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
1065 [ + + ]: 133225 : if ( yy_accept[yy_current_state] )
1066 : : {
1067 : 60105 : (yy_last_accepting_state) = yy_current_state;
1068 : 60105 : (yy_last_accepting_cpos) = yy_cp;
1069 : : }
1070 [ + + ]: 215760 : while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1071 : : {
1072 : 82535 : yy_current_state = (int) yy_def[yy_current_state];
1073 [ + + ]: 82535 : if ( yy_current_state >= 62 )
1074 : 35431 : yy_c = yy_meta[yy_c];
1075 : : }
1076 : 133225 : yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1077 : 133225 : ++yy_cp;
1078 : : }
1079 [ + + ]: 133225 : while ( yy_current_state != 61 );
1080 : 45601 : yy_cp = (yy_last_accepting_cpos);
1081 : 45601 : yy_current_state = (yy_last_accepting_state);
1082 : :
1083 : : yy_find_action:
1084 : 45601 : yy_act = yy_accept[yy_current_state];
1085 : :
1086 : 45601 : YY_DO_BEFORE_ACTION;
1087 : :
1088 [ + + + + ]: 45601 : if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
1089 : : {
1090 : : int yyl;
1091 [ + + ]: 6308 : for ( yyl = 0; yyl < yyleng; ++yyl )
1092 [ + + ]: 3155 : if ( yytext[yyl] == '\n' )
1093 : :
1094 : 1617 : yylineno++;
1095 : 45603 : ;
1096 : : }
1097 : :
1098 : 45601 : do_action: /* This label is used only to access EOF actions. */
1099 : :
1100 [ - + + + : 45603 : switch ( yy_act )
+ + + + +
+ + + + +
- + + + +
+ - - + -
+ ]
1101 : : { /* beginning of action switch */
1102 : 0 : case 0: /* must back up */
1103 : : /* undo the effects of YY_DO_BEFORE_ACTION */
1104 : 0 : *yy_cp = (yy_hold_char);
1105 : 0 : yy_cp = (yy_last_accepting_cpos);
1106 : 0 : yy_current_state = (yy_last_accepting_state);
1107 : 0 : goto yy_find_action;
1108 : :
1109 : 94 : case 1:
1110 [ + - ]: 94 : YY_RULE_SETUP
1111 : : #line 58 "i386_lex.l"
1112 : : { return kMASK; }
1113 : : YY_BREAK
1114 : : case 2:
1115 : : YY_RULE_SETUP
1116 : : #line 60 "i386_lex.l"
1117 : : { return kPREFIX; }
1118 : : YY_BREAK
1119 : : case 3:
1120 : : YY_RULE_SETUP
1121 : : #line 61 "i386_lex.l"
1122 : : { return kSUFFIX; }
1123 : : YY_BREAK
1124 : : case 4:
1125 : : YY_RULE_SETUP
1126 : : #line 63 "i386_lex.l"
1127 : : { return kSYNONYM; }
1128 : : YY_BREAK
1129 : : case 5:
1130 : : YY_RULE_SETUP
1131 : : #line 65 "i386_lex.l"
1132 : : { i386_lval.num = strtoul (yytext, NULL, 10);
1133 : : return kNUMBER; }
1134 : : YY_BREAK
1135 : : case 6:
1136 : : YY_RULE_SETUP
1137 : : #line 68 "i386_lex.l"
1138 : : { BEGIN (MAIN); return kPERCPERC; }
1139 : : YY_BREAK
1140 : : case 7:
1141 : : YY_RULE_SETUP
1142 : : #line 71 "i386_lex.l"
1143 : : { return '0'; }
1144 : : YY_BREAK
1145 : : case 8:
1146 : : YY_RULE_SETUP
1147 : : #line 72 "i386_lex.l"
1148 : : { return '1'; }
1149 : : YY_BREAK
1150 : : case 9:
1151 : : YY_RULE_SETUP
1152 : : #line 74 "i386_lex.l"
1153 : : { i386_lval.str = xstrndup (yytext + 1,
1154 : : yyleng - 2);
1155 : : return kBITFIELD; }
1156 : : YY_BREAK
1157 : : case 10:
1158 : : YY_RULE_SETUP
1159 : : #line 78 "i386_lex.l"
1160 : : { i386_lval.str = (void *) -1l;
1161 : : return kID; }
1162 : : YY_BREAK
1163 : : case 11:
1164 : : YY_RULE_SETUP
1165 : : #line 81 "i386_lex.l"
1166 : : { i386_lval.str = xstrndup (yytext, yyleng);
1167 : : return kID; }
1168 : : YY_BREAK
1169 : : case 12:
1170 : : YY_RULE_SETUP
1171 : : #line 84 "i386_lex.l"
1172 : : { return ','; }
1173 : : YY_BREAK
1174 : : case 13:
1175 : : YY_RULE_SETUP
1176 : : #line 86 "i386_lex.l"
1177 : : { return ':'; }
1178 : : YY_BREAK
1179 : : case 14:
1180 : : /* rule 14 can match eol */
1181 : : YY_RULE_SETUP
1182 : : #line 88 "i386_lex.l"
1183 : : { /* IGNORE */ }
1184 : : YY_BREAK
1185 : : case 15:
1186 : : /* rule 15 can match eol */
1187 : : YY_RULE_SETUP
1188 : : #line 90 "i386_lex.l"
1189 : : { return '\n'; }
1190 : : YY_BREAK
1191 : : case 16:
1192 : : YY_RULE_SETUP
1193 : : #line 92 "i386_lex.l"
1194 : : { eat_to_eol (); }
1195 : : YY_BREAK
1196 : : case 17:
1197 : : /* rule 17 can match eol */
1198 : : YY_RULE_SETUP
1199 : : #line 94 "i386_lex.l"
1200 : : { /* IGNORE */ }
1201 : : YY_BREAK
1202 : : case 18:
1203 : : /* rule 18 can match eol */
1204 : : YY_RULE_SETUP
1205 : : #line 96 "i386_lex.l"
1206 : : { return kSPACE; }
1207 : : YY_BREAK
1208 : : case 19:
1209 : : YY_RULE_SETUP
1210 : : #line 98 "i386_lex.l"
1211 : : { i386_lval.ch = *yytext; return kCHAR; }
1212 : : YY_BREAK
1213 : : case 20:
1214 : : YY_RULE_SETUP
1215 : : #line 100 "i386_lex.l"
1216 : : { invalid_char (*yytext); }
1217 : : YY_BREAK
1218 : : case 21:
1219 : : YY_RULE_SETUP
1220 : : #line 103 "i386_lex.l"
1221 : : ECHO;
1222 : : YY_BREAK
1223 : : #line 1224 "i386_lex.c"
1224 : : case YY_STATE_EOF(INITIAL):
1225 : : case YY_STATE_EOF(MAIN):
1226 : : yyterminate();
1227 : :
1228 : 14 : case YY_END_OF_BUFFER:
1229 : : {
1230 : : /* Amount of text matched not including the EOB char. */
1231 : 14 : int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1232 : :
1233 : : /* Undo the effects of YY_DO_BEFORE_ACTION. */
1234 : 14 : *yy_cp = (yy_hold_char);
1235 : : YY_RESTORE_YY_MORE_OFFSET
1236 : :
1237 [ + + ]: 14 : if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1238 : : {
1239 : : /* We're scanning a new file or input source. It's
1240 : : * possible that this happened because the user
1241 : : * just pointed yyin at a new source and called
1242 : : * yylex(). If so, then we have to assure
1243 : : * consistency between YY_CURRENT_BUFFER and our
1244 : : * globals. Here is the right place to do so, because
1245 : : * this is the first action (other than possibly a
1246 : : * back-up) that will match for the new input source.
1247 : : */
1248 : 2 : (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1249 : 2 : YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1250 : 2 : YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1251 : : }
1252 : :
1253 : : /* Note that here we test for yy_c_buf_p "<=" to the position
1254 : : * of the first EOB in the buffer, since yy_c_buf_p will
1255 : : * already have been incremented past the NUL character
1256 : : * (since all states make transitions on EOB to the
1257 : : * end-of-buffer state). Contrast this with the test
1258 : : * in input().
1259 : : */
1260 [ - + ]: 14 : if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1261 : : { /* This was really a NUL. */
1262 : 0 : yy_state_type yy_next_state;
1263 : :
1264 : 0 : (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1265 : :
1266 : 0 : yy_current_state = yy_get_previous_state( );
1267 : :
1268 : : /* Okay, we're now positioned to make the NUL
1269 : : * transition. We couldn't have
1270 : : * yy_get_previous_state() go ahead and do it
1271 : : * for us because it doesn't know how to deal
1272 : : * with the possibility of jamming (and we don't
1273 : : * want to build jamming into it because then it
1274 : : * will run more slowly).
1275 : : */
1276 : :
1277 : 0 : yy_next_state = yy_try_NUL_trans( yy_current_state );
1278 : :
1279 : 0 : yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1280 : :
1281 [ # # ]: 0 : if ( yy_next_state )
1282 : : {
1283 : : /* Consume the NUL. */
1284 : 0 : yy_cp = ++(yy_c_buf_p);
1285 : 0 : yy_current_state = yy_next_state;
1286 : 0 : goto yy_match;
1287 : : }
1288 : :
1289 : : else
1290 : : {
1291 : 0 : yy_cp = (yy_last_accepting_cpos);
1292 : 0 : yy_current_state = (yy_last_accepting_state);
1293 : 0 : goto yy_find_action;
1294 : : }
1295 : : }
1296 : :
1297 : 14 : else switch ( yy_get_next_buffer( ) )
1298 : : {
1299 : 2 : case EOB_ACT_END_OF_FILE:
1300 : : {
1301 : 2 : (yy_did_buffer_switch_on_eof) = 0;
1302 : :
1303 : 2 : if ( yywrap( ) )
1304 : : {
1305 : : /* Note: because we've taken care in
1306 : : * yy_get_next_buffer() to have set up
1307 : : * yytext, we can now set up
1308 : : * yy_c_buf_p so that if some total
1309 : : * hoser (like flex itself) wants to
1310 : : * call the scanner after we return the
1311 : : * YY_NULL, it'll still work - another
1312 : : * YY_NULL will get returned.
1313 : : */
1314 : 2 : (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1315 : :
1316 : 2 : yy_act = YY_STATE_EOF(YY_START);
1317 : 2 : goto do_action;
1318 : : }
1319 : :
1320 : : else
1321 : : {
1322 : : if ( ! (yy_did_buffer_switch_on_eof) )
1323 : : YY_NEW_FILE;
1324 : : }
1325 : : break;
1326 : : }
1327 : :
1328 : 12 : case EOB_ACT_CONTINUE_SCAN:
1329 : 12 : (yy_c_buf_p) =
1330 : 12 : (yytext_ptr) + yy_amount_of_matched_text;
1331 : :
1332 : 12 : yy_current_state = yy_get_previous_state( );
1333 : :
1334 : 12 : yy_cp = (yy_c_buf_p);
1335 : 12 : yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1336 : 12 : goto yy_match;
1337 : :
1338 : 0 : case EOB_ACT_LAST_MATCH:
1339 : 0 : (yy_c_buf_p) =
1340 : 0 : &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1341 : :
1342 : 0 : yy_current_state = yy_get_previous_state( );
1343 : :
1344 : 0 : yy_cp = (yy_c_buf_p);
1345 : 0 : yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1346 : 0 : goto yy_find_action;
1347 : : }
1348 : : break;
1349 : : }
1350 : :
1351 : 0 : default:
1352 : 0 : YY_FATAL_ERROR(
1353 : : "fatal flex scanner internal error--no action found" );
1354 : : } /* end of action switch */
1355 : : } /* end of scanning one token */
1356 : : } /* end of user's declarations */
1357 : : } /* end of yylex */
1358 : :
1359 : : /* yy_get_next_buffer - try to read in a new buffer
1360 : : *
1361 : : * Returns a code representing an action:
1362 : : * EOB_ACT_LAST_MATCH -
1363 : : * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1364 : : * EOB_ACT_END_OF_FILE - end of file
1365 : : */
1366 : 14 : static int yy_get_next_buffer (void)
1367 : : {
1368 : 14 : char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1369 : 14 : char *source = (yytext_ptr);
1370 : 14 : int number_to_move, i;
1371 : 14 : int ret_val;
1372 : :
1373 [ - + ]: 14 : if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1374 : 0 : YY_FATAL_ERROR(
1375 : : "fatal flex scanner internal error--end of buffer missed" );
1376 : :
1377 [ - + ]: 14 : if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1378 : : { /* Don't try to fill the buffer, so this is an EOF. */
1379 [ # # ]: 0 : if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1380 : : {
1381 : : /* We matched a single character, the EOB, so
1382 : : * treat this as a final EOF.
1383 : : */
1384 : : return EOB_ACT_END_OF_FILE;
1385 : : }
1386 : :
1387 : : else
1388 : : {
1389 : : /* We matched some text prior to the EOB, first
1390 : : * process it.
1391 : : */
1392 : 0 : return EOB_ACT_LAST_MATCH;
1393 : : }
1394 : : }
1395 : :
1396 : : /* Try to read more data. */
1397 : :
1398 : : /* First move last chars to start of buffer. */
1399 : 14 : number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1);
1400 : :
1401 [ + + ]: 48 : for ( i = 0; i < number_to_move; ++i )
1402 : 34 : *(dest++) = *(source++);
1403 : :
1404 [ - + ]: 14 : if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1405 : : /* don't do the read, it's not guaranteed to return an EOF,
1406 : : * just force an EOF
1407 : : */
1408 : 0 : YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1409 : :
1410 : : else
1411 : : {
1412 : 14 : int num_to_read =
1413 : 14 : YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1414 : :
1415 [ - + ]: 14 : while ( num_to_read <= 0 )
1416 : : { /* Not enough room in the buffer - grow it. */
1417 : :
1418 : : /* just a shorter name for the current buffer */
1419 : 0 : YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
1420 : :
1421 : 0 : int yy_c_buf_p_offset =
1422 : 0 : (int) ((yy_c_buf_p) - b->yy_ch_buf);
1423 : :
1424 [ # # ]: 0 : if ( b->yy_is_our_buffer )
1425 : : {
1426 : 0 : int new_size = b->yy_buf_size * 2;
1427 : :
1428 [ # # ]: 0 : if ( new_size <= 0 )
1429 : 0 : b->yy_buf_size += b->yy_buf_size / 8;
1430 : : else
1431 : 0 : b->yy_buf_size *= 2;
1432 : :
1433 : 0 : b->yy_ch_buf = (char *)
1434 : : /* Include room in for 2 EOB chars. */
1435 : 0 : yyrealloc( (void *) b->yy_ch_buf,
1436 : 0 : (yy_size_t) (b->yy_buf_size + 2) );
1437 : : }
1438 : : else
1439 : : /* Can't grow it, we don't own it. */
1440 : 0 : b->yy_ch_buf = NULL;
1441 : :
1442 [ # # ]: 0 : if ( ! b->yy_ch_buf )
1443 : 0 : YY_FATAL_ERROR(
1444 : : "fatal error - scanner input buffer overflow" );
1445 : :
1446 : 0 : (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1447 : :
1448 : 0 : num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1449 : : number_to_move - 1;
1450 : :
1451 : : }
1452 : :
1453 : 14 : if ( num_to_read > YY_READ_BUF_SIZE )
1454 : : num_to_read = YY_READ_BUF_SIZE;
1455 : :
1456 : : /* Read in more data. */
1457 [ - + - - : 28 : YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
- - - - -
- - - - -
- - - + +
+ - + ]
1458 : 14 : (yy_n_chars), num_to_read );
1459 : :
1460 : 14 : YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1461 : : }
1462 : :
1463 [ + + ]: 14 : if ( (yy_n_chars) == 0 )
1464 : : {
1465 [ + - ]: 2 : if ( number_to_move == YY_MORE_ADJ )
1466 : : {
1467 : 2 : ret_val = EOB_ACT_END_OF_FILE;
1468 : 2 : yyrestart( yyin );
1469 : : }
1470 : :
1471 : : else
1472 : : {
1473 : 0 : ret_val = EOB_ACT_LAST_MATCH;
1474 : 0 : YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1475 : : YY_BUFFER_EOF_PENDING;
1476 : : }
1477 : : }
1478 : :
1479 : : else
1480 : : ret_val = EOB_ACT_CONTINUE_SCAN;
1481 : :
1482 [ - + ]: 14 : if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1483 : : /* Extend the array by 50%, plus the number we really need. */
1484 : 0 : int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1485 : 0 : YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
1486 : 0 : (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size );
1487 [ # # ]: 0 : if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1488 : 0 : YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1489 : : /* "- 2" to take care of EOB's */
1490 : 0 : YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
1491 : : }
1492 : :
1493 : 14 : (yy_n_chars) += number_to_move;
1494 : 14 : YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1495 : 14 : YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1496 : :
1497 : 14 : (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1498 : :
1499 : 14 : return ret_val;
1500 : : }
1501 : :
1502 : : /* yy_get_previous_state - get the state just before the EOB char was reached */
1503 : :
1504 : 12 : static yy_state_type yy_get_previous_state (void)
1505 : : {
1506 : 12 : yy_state_type yy_current_state;
1507 : 12 : char *yy_cp;
1508 : :
1509 : 12 : yy_current_state = (yy_start);
1510 : 12 : yy_current_state += YY_AT_BOL();
1511 : :
1512 [ + + ]: 46 : for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1513 : : {
1514 [ + - ]: 34 : YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1515 [ + + ]: 34 : if ( yy_accept[yy_current_state] )
1516 : : {
1517 : 20 : (yy_last_accepting_state) = yy_current_state;
1518 : 20 : (yy_last_accepting_cpos) = yy_cp;
1519 : : }
1520 [ + + ]: 58 : while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1521 : : {
1522 : 24 : yy_current_state = (int) yy_def[yy_current_state];
1523 [ + - ]: 24 : if ( yy_current_state >= 62 )
1524 : 24 : yy_c = yy_meta[yy_c];
1525 : : }
1526 : 34 : yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1527 : : }
1528 : :
1529 : 12 : return yy_current_state;
1530 : : }
1531 : :
1532 : : /* yy_try_NUL_trans - try to make a transition on the NUL character
1533 : : *
1534 : : * synopsis
1535 : : * next_state = yy_try_NUL_trans( current_state );
1536 : : */
1537 : 0 : static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
1538 : : {
1539 : 0 : int yy_is_jam;
1540 : 0 : char *yy_cp = (yy_c_buf_p);
1541 : :
1542 : 0 : YY_CHAR yy_c = 1;
1543 [ # # ]: 0 : if ( yy_accept[yy_current_state] )
1544 : : {
1545 : 0 : (yy_last_accepting_state) = yy_current_state;
1546 : 0 : (yy_last_accepting_cpos) = yy_cp;
1547 : : }
1548 [ # # ]: 0 : while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1549 : : {
1550 : 0 : yy_current_state = (int) yy_def[yy_current_state];
1551 : 0 : if ( yy_current_state >= 62 )
1552 : : yy_c = yy_meta[yy_c];
1553 : : }
1554 : 0 : yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1555 : 0 : yy_is_jam = (yy_current_state == 61);
1556 : :
1557 [ # # ]: 0 : return yy_is_jam ? 0 : yy_current_state;
1558 : : }
1559 : :
1560 : : #ifndef YY_NO_UNPUT
1561 : :
1562 : : static void yyunput (int c, char * yy_bp )
1563 : : {
1564 : : char *yy_cp;
1565 : :
1566 : : yy_cp = (yy_c_buf_p);
1567 : :
1568 : : /* undo effects of setting up yytext */
1569 : : *yy_cp = (yy_hold_char);
1570 : :
1571 : : if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1572 : : { /* need to shift things up to make room */
1573 : : /* +2 for EOB chars. */
1574 : : int number_to_move = (yy_n_chars) + 2;
1575 : : char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1576 : : YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1577 : : char *source =
1578 : : &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1579 : :
1580 : : while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1581 : : *--dest = *--source;
1582 : :
1583 : : yy_cp += (int) (dest - source);
1584 : : yy_bp += (int) (dest - source);
1585 : : YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1586 : : (yy_n_chars) = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1587 : :
1588 : : if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1589 : : YY_FATAL_ERROR( "flex scanner push-back overflow" );
1590 : : }
1591 : :
1592 : : *--yy_cp = (char) c;
1593 : :
1594 : : if ( c == '\n' ){
1595 : : --yylineno;
1596 : : }
1597 : :
1598 : : (yytext_ptr) = yy_bp;
1599 : : (yy_hold_char) = *yy_cp;
1600 : : (yy_c_buf_p) = yy_cp;
1601 : : }
1602 : :
1603 : : #endif
1604 : :
1605 : : #ifndef YY_NO_INPUT
1606 : : #ifdef __cplusplus
1607 : : static int yyinput (void)
1608 : : #else
1609 : 1502 : static int input (void)
1610 : : #endif
1611 : :
1612 : : {
1613 : 1502 : int c;
1614 : :
1615 : 1502 : *(yy_c_buf_p) = (yy_hold_char);
1616 : :
1617 [ + - ]: 1502 : if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1618 : : {
1619 : : /* yy_c_buf_p now points to the character we want to return.
1620 : : * If this occurs *before* the EOB characters, then it's a
1621 : : * valid NUL; if not, then we've hit the end of the buffer.
1622 : : */
1623 [ # # ]: 0 : if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1624 : : /* This was really a NUL. */
1625 : 0 : *(yy_c_buf_p) = '\0';
1626 : :
1627 : : else
1628 : : { /* need more input */
1629 : 0 : int offset = (int) ((yy_c_buf_p) - (yytext_ptr));
1630 : 0 : ++(yy_c_buf_p);
1631 : :
1632 [ # # # # ]: 0 : switch ( yy_get_next_buffer( ) )
1633 : : {
1634 : 0 : case EOB_ACT_LAST_MATCH:
1635 : : /* This happens because yy_g_n_b()
1636 : : * sees that we've accumulated a
1637 : : * token and flags that we need to
1638 : : * try matching the token before
1639 : : * proceeding. But for input(),
1640 : : * there's no matching to consider.
1641 : : * So convert the EOB_ACT_LAST_MATCH
1642 : : * to EOB_ACT_END_OF_FILE.
1643 : : */
1644 : :
1645 : : /* Reset buffer status. */
1646 : 0 : yyrestart( yyin );
1647 : :
1648 : : /*FALLTHROUGH*/
1649 : :
1650 : : case EOB_ACT_END_OF_FILE:
1651 : : {
1652 : 0 : if ( yywrap( ) )
1653 : 0 : return 0;
1654 : :
1655 : : if ( ! (yy_did_buffer_switch_on_eof) )
1656 : : YY_NEW_FILE;
1657 : : #ifdef __cplusplus
1658 : : return yyinput();
1659 : : #else
1660 : : return input();
1661 : : #endif
1662 : : }
1663 : :
1664 : 0 : case EOB_ACT_CONTINUE_SCAN:
1665 : 0 : (yy_c_buf_p) = (yytext_ptr) + offset;
1666 : 0 : break;
1667 : : }
1668 : 1502 : }
1669 : : }
1670 : :
1671 : 1502 : c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
1672 : 1502 : *(yy_c_buf_p) = '\0'; /* preserve yytext */
1673 : 1502 : (yy_hold_char) = *++(yy_c_buf_p);
1674 : :
1675 : 1502 : YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\n');
1676 [ + + ]: 1502 : if ( YY_CURRENT_BUFFER_LVALUE->yy_at_bol )
1677 : :
1678 : 120 : yylineno++;
1679 : : ;
1680 : :
1681 : : return c;
1682 : : }
1683 : : #endif /* ifndef YY_NO_INPUT */
1684 : :
1685 : : /** Immediately switch to a different input stream.
1686 : : * @param input_file A readable stream.
1687 : : *
1688 : : * @note This function does not reset the start condition to @c INITIAL .
1689 : : */
1690 : 2 : void yyrestart (FILE * input_file )
1691 : : {
1692 : :
1693 [ + - - + ]: 2 : if ( ! YY_CURRENT_BUFFER ){
1694 : 0 : yyensure_buffer_stack ();
1695 : 0 : YY_CURRENT_BUFFER_LVALUE =
1696 : 0 : yy_create_buffer( yyin, YY_BUF_SIZE );
1697 : : }
1698 : :
1699 [ + - ]: 2 : yy_init_buffer( YY_CURRENT_BUFFER, input_file );
1700 : 2 : yy_load_buffer_state( );
1701 : 2 : }
1702 : :
1703 : : /** Switch to a different input buffer.
1704 : : * @param new_buffer The new input buffer.
1705 : : *
1706 : : */
1707 : 0 : void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer )
1708 : : {
1709 : :
1710 : : /* TODO. We should be able to replace this entire function body
1711 : : * with
1712 : : * yypop_buffer_state();
1713 : : * yypush_buffer_state(new_buffer);
1714 : : */
1715 : 0 : yyensure_buffer_stack ();
1716 [ # # # # ]: 0 : if ( YY_CURRENT_BUFFER == new_buffer )
1717 : : return;
1718 : :
1719 [ # # # # ]: 0 : if ( YY_CURRENT_BUFFER )
1720 : : {
1721 : : /* Flush out information for old buffer. */
1722 : 0 : *(yy_c_buf_p) = (yy_hold_char);
1723 : 0 : YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1724 : 0 : YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1725 : : }
1726 : :
1727 : 0 : YY_CURRENT_BUFFER_LVALUE = new_buffer;
1728 : 0 : yy_load_buffer_state( );
1729 : :
1730 : : /* We don't actually know whether we did this switch during
1731 : : * EOF (yywrap()) processing, but the only time this flag
1732 : : * is looked at is after yywrap() is called, so it's safe
1733 : : * to go ahead and always set it.
1734 : : */
1735 : 0 : (yy_did_buffer_switch_on_eof) = 1;
1736 : : }
1737 : :
1738 : 6 : static void yy_load_buffer_state (void)
1739 : : {
1740 : 6 : (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1741 : 6 : (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1742 : 6 : yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1743 : 6 : (yy_hold_char) = *(yy_c_buf_p);
1744 : 6 : }
1745 : :
1746 : : /** Allocate and initialize an input buffer state.
1747 : : * @param file A readable stream.
1748 : : * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1749 : : *
1750 : : * @return the allocated buffer state.
1751 : : */
1752 : 2 : YY_BUFFER_STATE yy_create_buffer (FILE * file, int size )
1753 : : {
1754 : 2 : YY_BUFFER_STATE b;
1755 : :
1756 : 2 : b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
1757 [ - + ]: 2 : if ( ! b )
1758 : 0 : YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1759 : :
1760 : 2 : b->yy_buf_size = size;
1761 : :
1762 : : /* yy_ch_buf has to be 2 characters longer than the size given because
1763 : : * we need to put in 2 end-of-buffer characters.
1764 : : */
1765 : 2 : b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) );
1766 [ - + ]: 2 : if ( ! b->yy_ch_buf )
1767 : 0 : YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1768 : :
1769 : 2 : b->yy_is_our_buffer = 1;
1770 : :
1771 : 2 : yy_init_buffer( b, file );
1772 : :
1773 : 2 : return b;
1774 : : }
1775 : :
1776 : : /** Destroy the buffer.
1777 : : * @param b a buffer created with yy_create_buffer()
1778 : : *
1779 : : */
1780 : 0 : void yy_delete_buffer (YY_BUFFER_STATE b )
1781 : : {
1782 : :
1783 [ # # ]: 0 : if ( ! b )
1784 : : return;
1785 : :
1786 [ # # # # ]: 0 : if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1787 : 0 : YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1788 : :
1789 [ # # ]: 0 : if ( b->yy_is_our_buffer )
1790 : 0 : yyfree( (void *) b->yy_ch_buf );
1791 : :
1792 : 0 : yyfree( (void *) b );
1793 : : }
1794 : :
1795 : : /* Initializes or reinitializes a buffer.
1796 : : * This function is sometimes called more than once on the same buffer,
1797 : : * such as during a yyrestart() or at EOF.
1798 : : */
1799 : 4 : static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file )
1800 : :
1801 : : {
1802 : 4 : int oerrno = errno;
1803 : :
1804 : 4 : yy_flush_buffer( b );
1805 : :
1806 : 4 : b->yy_input_file = file;
1807 : 4 : b->yy_fill_buffer = 1;
1808 : :
1809 : : /* If b is the current buffer, then yy_init_buffer was _probably_
1810 : : * called from yyrestart() or through yy_get_next_buffer.
1811 : : * In that case, we don't want to reset the lineno or column.
1812 : : */
1813 [ + - + + ]: 4 : if (b != YY_CURRENT_BUFFER){
1814 : 2 : b->yy_bs_lineno = 1;
1815 : 2 : b->yy_bs_column = 0;
1816 : : }
1817 : :
1818 : 4 : b->yy_is_interactive = 0;
1819 : :
1820 : 4 : errno = oerrno;
1821 : 4 : }
1822 : :
1823 : : /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1824 : : * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1825 : : *
1826 : : */
1827 : 4 : void yy_flush_buffer (YY_BUFFER_STATE b )
1828 : : {
1829 [ + - ]: 4 : if ( ! b )
1830 : : return;
1831 : :
1832 : 4 : b->yy_n_chars = 0;
1833 : :
1834 : : /* We always need two end-of-buffer characters. The first causes
1835 : : * a transition to the end-of-buffer state. The second causes
1836 : : * a jam in that state.
1837 : : */
1838 : 4 : b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1839 : 4 : b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1840 : :
1841 : 4 : b->yy_buf_pos = &b->yy_ch_buf[0];
1842 : :
1843 : 4 : b->yy_at_bol = 1;
1844 : 4 : b->yy_buffer_status = YY_BUFFER_NEW;
1845 : :
1846 [ + - + + ]: 4 : if ( b == YY_CURRENT_BUFFER )
1847 : 2 : yy_load_buffer_state( );
1848 : : }
1849 : :
1850 : : /** Pushes the new state onto the stack. The new state becomes
1851 : : * the current state. This function will allocate the stack
1852 : : * if necessary.
1853 : : * @param new_buffer The new state.
1854 : : *
1855 : : */
1856 : 0 : void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
1857 : : {
1858 [ # # ]: 0 : if (new_buffer == NULL)
1859 : : return;
1860 : :
1861 : 0 : yyensure_buffer_stack();
1862 : :
1863 : : /* This block is copied from yy_switch_to_buffer. */
1864 [ # # # # ]: 0 : if ( YY_CURRENT_BUFFER )
1865 : : {
1866 : : /* Flush out information for old buffer. */
1867 : 0 : *(yy_c_buf_p) = (yy_hold_char);
1868 : 0 : YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1869 : 0 : YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1870 : : }
1871 : :
1872 : : /* Only push if top exists. Otherwise, replace top. */
1873 [ # # # # ]: 0 : if (YY_CURRENT_BUFFER)
1874 : 0 : (yy_buffer_stack_top)++;
1875 : 0 : YY_CURRENT_BUFFER_LVALUE = new_buffer;
1876 : :
1877 : : /* copied from yy_switch_to_buffer. */
1878 : 0 : yy_load_buffer_state( );
1879 : 0 : (yy_did_buffer_switch_on_eof) = 1;
1880 : : }
1881 : :
1882 : : /** Removes and deletes the top of the stack, if present.
1883 : : * The next element becomes the new top.
1884 : : *
1885 : : */
1886 : 0 : void yypop_buffer_state (void)
1887 : : {
1888 [ # # # # ]: 0 : if (!YY_CURRENT_BUFFER)
1889 : : return;
1890 : :
1891 : 0 : yy_delete_buffer(YY_CURRENT_BUFFER );
1892 : 0 : YY_CURRENT_BUFFER_LVALUE = NULL;
1893 [ # # ]: 0 : if ((yy_buffer_stack_top) > 0)
1894 : 0 : --(yy_buffer_stack_top);
1895 : :
1896 [ # # # # ]: 0 : if (YY_CURRENT_BUFFER) {
1897 : 0 : yy_load_buffer_state( );
1898 : 0 : (yy_did_buffer_switch_on_eof) = 1;
1899 : : }
1900 : : }
1901 : :
1902 : : /* Allocates the stack if it does not exist.
1903 : : * Guarantees space for at least one push.
1904 : : */
1905 : 2 : static void yyensure_buffer_stack (void)
1906 : : {
1907 : 2 : yy_size_t num_to_alloc;
1908 : :
1909 [ + - ]: 2 : if (!(yy_buffer_stack)) {
1910 : :
1911 : : /* First allocation is just for 2 elements, since we don't know if this
1912 : : * scanner will even need a stack. We use 2 instead of 1 to avoid an
1913 : : * immediate realloc on the next call.
1914 : : */
1915 : 2 : num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
1916 : 2 : (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
1917 : : (num_to_alloc * sizeof(struct yy_buffer_state*)
1918 : : );
1919 [ - + ]: 2 : if ( ! (yy_buffer_stack) )
1920 : 0 : YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1921 : :
1922 : 2 : memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1923 : :
1924 : 2 : (yy_buffer_stack_max) = num_to_alloc;
1925 : 2 : (yy_buffer_stack_top) = 0;
1926 : 2 : return;
1927 : : }
1928 : :
1929 [ # # ]: 0 : if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1930 : :
1931 : : /* Increase the buffer to prepare for a possible push. */
1932 : 0 : yy_size_t grow_size = 8 /* arbitrary grow size */;
1933 : :
1934 : 0 : num_to_alloc = (yy_buffer_stack_max) + grow_size;
1935 : 0 : (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
1936 : : ((yy_buffer_stack),
1937 : : num_to_alloc * sizeof(struct yy_buffer_state*)
1938 : : );
1939 [ # # ]: 0 : if ( ! (yy_buffer_stack) )
1940 : 0 : YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1941 : :
1942 : : /* zero only the new slots.*/
1943 : 0 : memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
1944 : 0 : (yy_buffer_stack_max) = num_to_alloc;
1945 : : }
1946 : : }
1947 : :
1948 : : /** Setup the input buffer state to scan directly from a user-specified character buffer.
1949 : : * @param base the character buffer
1950 : : * @param size the size in bytes of the character buffer
1951 : : *
1952 : : * @return the newly allocated buffer state object.
1953 : : */
1954 : 0 : YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size )
1955 : : {
1956 : 0 : YY_BUFFER_STATE b;
1957 : :
1958 [ # # ]: 0 : if ( size < 2 ||
1959 [ # # ]: 0 : base[size-2] != YY_END_OF_BUFFER_CHAR ||
1960 [ # # ]: 0 : base[size-1] != YY_END_OF_BUFFER_CHAR )
1961 : : /* They forgot to leave room for the EOB's. */
1962 : : return NULL;
1963 : :
1964 : 0 : b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
1965 [ # # ]: 0 : if ( ! b )
1966 : 0 : YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1967 : :
1968 : 0 : b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */
1969 : 0 : b->yy_buf_pos = b->yy_ch_buf = base;
1970 : 0 : b->yy_is_our_buffer = 0;
1971 : 0 : b->yy_input_file = NULL;
1972 : 0 : b->yy_n_chars = b->yy_buf_size;
1973 : 0 : b->yy_is_interactive = 0;
1974 : 0 : b->yy_at_bol = 1;
1975 : 0 : b->yy_fill_buffer = 0;
1976 : 0 : b->yy_buffer_status = YY_BUFFER_NEW;
1977 : :
1978 : 0 : yy_switch_to_buffer( b );
1979 : :
1980 : 0 : return b;
1981 : : }
1982 : :
1983 : : /** Setup the input buffer state to scan a string. The next call to yylex() will
1984 : : * scan from a @e copy of @a str.
1985 : : * @param yystr a NUL-terminated string to scan
1986 : : *
1987 : : * @return the newly allocated buffer state object.
1988 : : * @note If you want to scan bytes that may contain NUL values, then use
1989 : : * yy_scan_bytes() instead.
1990 : : */
1991 : 0 : YY_BUFFER_STATE yy_scan_string (const char * yystr )
1992 : : {
1993 : :
1994 : 0 : return yy_scan_bytes( yystr, (int) strlen(yystr) );
1995 : : }
1996 : :
1997 : : /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
1998 : : * scan from a @e copy of @a bytes.
1999 : : * @param yybytes the byte buffer to scan
2000 : : * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
2001 : : *
2002 : : * @return the newly allocated buffer state object.
2003 : : */
2004 : 0 : YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len )
2005 : : {
2006 : 0 : YY_BUFFER_STATE b;
2007 : 0 : char *buf;
2008 : 0 : yy_size_t n;
2009 : 0 : int i;
2010 : :
2011 : : /* Get memory for full buffer, including space for trailing EOB's. */
2012 : 0 : n = (yy_size_t) (_yybytes_len + 2);
2013 : 0 : buf = (char *) yyalloc( n );
2014 [ # # ]: 0 : if ( ! buf )
2015 : 0 : YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
2016 : :
2017 [ # # ]: 0 : for ( i = 0; i < _yybytes_len; ++i )
2018 : 0 : buf[i] = yybytes[i];
2019 : :
2020 : 0 : buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
2021 : :
2022 : 0 : b = yy_scan_buffer( buf, n );
2023 [ # # ]: 0 : if ( ! b )
2024 : 0 : YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2025 : :
2026 : : /* It's okay to grow etc. this buffer, and we should throw it
2027 : : * away when we're done.
2028 : : */
2029 : 0 : b->yy_is_our_buffer = 1;
2030 : :
2031 : 0 : return b;
2032 : : }
2033 : :
2034 : : #ifndef YY_EXIT_FAILURE
2035 : : #define YY_EXIT_FAILURE 2
2036 : : #endif
2037 : :
2038 : 0 : static void yynoreturn yy_fatal_error (const char* msg )
2039 : : {
2040 : 0 : fprintf( stderr, "%s\n", msg );
2041 : 0 : exit( YY_EXIT_FAILURE );
2042 : : }
2043 : :
2044 : : /* Redefine yyless() so it works in section 3 code. */
2045 : :
2046 : : #undef yyless
2047 : : #define yyless(n) \
2048 : : do \
2049 : : { \
2050 : : /* Undo effects of setting up yytext. */ \
2051 : : int yyless_macro_arg = (n); \
2052 : : YY_LESS_LINENO(yyless_macro_arg);\
2053 : : yytext[yyleng] = (yy_hold_char); \
2054 : : (yy_c_buf_p) = yytext + yyless_macro_arg; \
2055 : : (yy_hold_char) = *(yy_c_buf_p); \
2056 : : *(yy_c_buf_p) = '\0'; \
2057 : : yyleng = yyless_macro_arg; \
2058 : : } \
2059 : : while ( 0 )
2060 : :
2061 : : /* Accessor methods (get/set functions) to struct members. */
2062 : :
2063 : : /** Get the current line number.
2064 : : *
2065 : : */
2066 : 0 : int yyget_lineno (void)
2067 : : {
2068 : :
2069 : 0 : return yylineno;
2070 : : }
2071 : :
2072 : : /** Get the input stream.
2073 : : *
2074 : : */
2075 : 0 : FILE *yyget_in (void)
2076 : : {
2077 : 0 : return yyin;
2078 : : }
2079 : :
2080 : : /** Get the output stream.
2081 : : *
2082 : : */
2083 : 0 : FILE *yyget_out (void)
2084 : : {
2085 : 0 : return yyout;
2086 : : }
2087 : :
2088 : : /** Get the length of the current token.
2089 : : *
2090 : : */
2091 : 0 : int yyget_leng (void)
2092 : : {
2093 : 0 : return yyleng;
2094 : : }
2095 : :
2096 : : /** Get the current token.
2097 : : *
2098 : : */
2099 : :
2100 : 0 : char *yyget_text (void)
2101 : : {
2102 : 0 : return yytext;
2103 : : }
2104 : :
2105 : : /** Set the current line number.
2106 : : * @param _line_number line number
2107 : : *
2108 : : */
2109 : 0 : void yyset_lineno (int _line_number )
2110 : : {
2111 : :
2112 : 0 : yylineno = _line_number;
2113 : 0 : }
2114 : :
2115 : : /** Set the input stream. This does not discard the current
2116 : : * input buffer.
2117 : : * @param _in_str A readable stream.
2118 : : *
2119 : : * @see yy_switch_to_buffer
2120 : : */
2121 : 0 : void yyset_in (FILE * _in_str )
2122 : : {
2123 : 0 : yyin = _in_str ;
2124 : 0 : }
2125 : :
2126 : 0 : void yyset_out (FILE * _out_str )
2127 : : {
2128 : 0 : yyout = _out_str ;
2129 : 0 : }
2130 : :
2131 : 0 : int yyget_debug (void)
2132 : : {
2133 : 0 : return yy_flex_debug;
2134 : : }
2135 : :
2136 : 0 : void yyset_debug (int _bdebug )
2137 : : {
2138 : 0 : yy_flex_debug = _bdebug ;
2139 : 0 : }
2140 : :
2141 : 0 : static int yy_init_globals (void)
2142 : : {
2143 : : /* Initialization is the same as for the non-reentrant scanner.
2144 : : * This function is called from yylex_destroy(), so don't allocate here.
2145 : : */
2146 : :
2147 : : /* We do not touch yylineno unless the option is enabled. */
2148 : 0 : yylineno = 1;
2149 : :
2150 : 0 : (yy_buffer_stack) = NULL;
2151 : 0 : (yy_buffer_stack_top) = 0;
2152 : 0 : (yy_buffer_stack_max) = 0;
2153 : 0 : (yy_c_buf_p) = NULL;
2154 : 0 : (yy_init) = 0;
2155 : 0 : (yy_start) = 0;
2156 : :
2157 : : /* Defined in main.c */
2158 : : #ifdef YY_STDINIT
2159 : : yyin = stdin;
2160 : : yyout = stdout;
2161 : : #else
2162 : 0 : yyin = NULL;
2163 : 0 : yyout = NULL;
2164 : : #endif
2165 : :
2166 : : /* For future reference: Set errno on error, since we are called by
2167 : : * yylex_init()
2168 : : */
2169 : 0 : return 0;
2170 : : }
2171 : :
2172 : : /* yylex_destroy is for both reentrant and non-reentrant scanners. */
2173 : 0 : int yylex_destroy (void)
2174 : : {
2175 : :
2176 : : /* Pop the buffer stack, destroying each element. */
2177 [ # # # # ]: 0 : while(YY_CURRENT_BUFFER){
2178 : 0 : yy_delete_buffer( YY_CURRENT_BUFFER );
2179 : 0 : YY_CURRENT_BUFFER_LVALUE = NULL;
2180 : 0 : yypop_buffer_state();
2181 : : }
2182 : :
2183 : : /* Destroy the stack itself. */
2184 : 0 : yyfree((yy_buffer_stack) );
2185 : 0 : (yy_buffer_stack) = NULL;
2186 : :
2187 : : /* Reset the globals. This is important in a non-reentrant scanner so the next time
2188 : : * yylex() is called, initialization will occur. */
2189 : 0 : yy_init_globals( );
2190 : :
2191 : 0 : return 0;
2192 : : }
2193 : :
2194 : : /*
2195 : : * Internal utility routines.
2196 : : */
2197 : :
2198 : : #ifndef yytext_ptr
2199 : : static void yy_flex_strncpy (char* s1, const char * s2, int n )
2200 : : {
2201 : :
2202 : : int i;
2203 : : for ( i = 0; i < n; ++i )
2204 : : s1[i] = s2[i];
2205 : : }
2206 : : #endif
2207 : :
2208 : : #ifdef YY_NEED_STRLEN
2209 : : static int yy_flex_strlen (const char * s )
2210 : : {
2211 : : int n;
2212 : : for ( n = 0; s[n]; ++n )
2213 : : ;
2214 : :
2215 : : return n;
2216 : : }
2217 : : #endif
2218 : :
2219 : 6 : void *yyalloc (yy_size_t size )
2220 : : {
2221 : 6 : return malloc(size);
2222 : : }
2223 : :
2224 : 0 : void *yyrealloc (void * ptr, yy_size_t size )
2225 : : {
2226 : :
2227 : : /* The cast to (char *) in the following accommodates both
2228 : : * implementations that use char* generic pointers, and those
2229 : : * that use void* generic pointers. It works with the latter
2230 : : * because both ANSI C and C++ allow castless assignment from
2231 : : * any pointer type to void*, and deal with argument conversions
2232 : : * as though doing an assignment.
2233 : : */
2234 : 0 : return realloc(ptr, size);
2235 : : }
2236 : :
2237 : 0 : void yyfree (void * ptr )
2238 : : {
2239 : 0 : free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
2240 : 0 : }
2241 : :
2242 : : #define YYTABLES_NAME "yytables"
2243 : :
2244 : : #line 103 "i386_lex.l"
2245 : :
2246 : :
2247 : : static void
2248 : : eat_to_eol (void)
2249 : : {
2250 : : while (1)
2251 : : {
2252 : : int c = input ();
2253 : :
2254 : : if (c == EOF || c == '\n')
2255 : : break;
2256 : : }
2257 : : }
2258 : :
2259 : : static void
2260 : : invalid_char (int ch)
2261 : : {
2262 : : error (0, 0, (isascii (ch)
2263 : : ? _("invalid character '%c' at line %d; ignored")
2264 : : : _("invalid character '\\%o' at line %d; ignored")),
2265 : : ch, yylineno);
2266 : : }
2267 : :
2268 : : // Local Variables:
2269 : : // mode: C
2270 : : // End:
2271 : :
|
