?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Makefile.inc1: don't build aicasm
[dragonfly.git] / contrib / binutils-2.17 / gas / itbl-lex.c
blob1180eac13a02ba28a507180a475aec8b4dd1d6ef
1 /* A lexical scanner generated by flex */
2
3 /* Scanner skeleton version:
4 * $Header: /cvs/src/src/gas/Attic/itbl-lex.c,v 1.1.16.1 2006/04/16 18:36:43 drow Exp $
5 */
6
7 #define FLEX_SCANNER
8 #define YY_FLEX_MAJOR_VERSION 2
9 #define YY_FLEX_MINOR_VERSION 5
10
11 #include <stdio.h>
12 #include <errno.h>
13
14 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
15 #ifdef c_plusplus
16 #ifndef __cplusplus
17 #define __cplusplus
18 #endif
19 #endif
20
21
22 #ifdef __cplusplus
23
24 #include <stdlib.h>
25 #ifndef _WIN32
26 #include <unistd.h>
27 #endif
28
29 /* Use prototypes in function declarations. */
30 #define YY_USE_PROTOS
31
32 /* The "const" storage-class-modifier is valid. */
33 #define YY_USE_CONST
34
35 #else /* ! __cplusplus */
36
37 #if __STDC__
38
39 #define YY_USE_PROTOS
40 #define YY_USE_CONST
41
42 #endif /* __STDC__ */
43 #endif /* ! __cplusplus */
44
45 #ifdef __TURBOC__
46 #pragma warn -rch
47 #pragma warn -use
48 #include <io.h>
49 #include <stdlib.h>
50 #define YY_USE_CONST
51 #define YY_USE_PROTOS
52 #endif
53
54 #ifdef YY_USE_CONST
55 #define yyconst const
56 #else
57 #define yyconst
58 #endif
59
60
61 #ifdef YY_USE_PROTOS
62 #define YY_PROTO(proto) proto
63 #else
64 #define YY_PROTO(proto) ()
65 #endif
66
67
68 /* Returned upon end-of-file. */
69 #define YY_NULL 0
70
71 /* Promotes a possibly negative, possibly signed char to an unsigned
72 * integer for use as an array index. If the signed char is negative,
73 * we want to instead treat it as an 8-bit unsigned char, hence the
74 * double cast.
75 */
76 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
77
78 /* Enter a start condition. This macro really ought to take a parameter,
79 * but we do it the disgusting crufty way forced on us by the ()-less
80 * definition of BEGIN.
81 */
82 #define BEGIN yy_start = 1 + 2 *
83
84 /* Translate the current start state into a value that can be later handed
85 * to BEGIN to return to the state. The YYSTATE alias is for lex
86 * compatibility.
87 */
88 #define YY_START ((yy_start - 1) / 2)
89 #define YYSTATE YY_START
90
91 /* Action number for EOF rule of a given start state. */
92 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
93
94 /* Special action meaning "start processing a new file". */
95 #define YY_NEW_FILE yyrestart( yyin )
96
97 #define YY_END_OF_BUFFER_CHAR 0
98
99 /* Size of default input buffer. */
100 #define YY_BUF_SIZE 16384
101
102 typedef struct yy_buffer_state *YY_BUFFER_STATE;
103
104 extern int yyleng;
105 extern FILE *yyin, *yyout;
106
107 #define EOB_ACT_CONTINUE_SCAN 0
108 #define EOB_ACT_END_OF_FILE 1
109 #define EOB_ACT_LAST_MATCH 2
110
111 /* The funky do-while in the following #define is used to turn the definition
112 * int a single C statement (which needs a semi-colon terminator). This
113 * avoids problems with code like:
114 *
115 * if ( condition_holds )
116 * yyless( 5 );
117 * else
118 * do_something_else();
119 *
120 * Prior to using the do-while the compiler would get upset at the
121 * "else" because it interpreted the "if" statement as being all
122 * done when it reached the ';' after the yyless() call.
123 */
124
125 /* Return all but the first 'n' matched characters back to the input stream. */
126
127 #define yyless(n) \
128 do \
129 { \
130 /* Undo effects of setting up yytext. */ \
131 *yy_cp = yy_hold_char; \
132 YY_RESTORE_YY_MORE_OFFSET \
133 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
134 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
135 } \
136 while ( 0 )
137
138 #define unput(c) yyunput( c, yytext_ptr )
139
140 /* The following is because we cannot portably get our hands on size_t
141 * (without autoconf's help, which isn't available because we want
142 * flex-generated scanners to compile on their own).
143 */
144 typedef unsigned int yy_size_t;
145
146
147 struct yy_buffer_state
148 {
149 FILE *yy_input_file;
150
151 char *yy_ch_buf; /* input buffer */
152 char *yy_buf_pos; /* current position in input buffer */
153
154 /* Size of input buffer in bytes, not including room for EOB
155 * characters.
156 */
157 yy_size_t yy_buf_size;
158
159 /* Number of characters read into yy_ch_buf, not including EOB
160 * characters.
161 */
162 int yy_n_chars;
163
164 /* Whether we "own" the buffer - i.e., we know we created it,
165 * and can realloc() it to grow it, and should free() it to
166 * delete it.
167 */
168 int yy_is_our_buffer;
169
170 /* Whether this is an "interactive" input source; if so, and
171 * if we're using stdio for input, then we want to use getc()
172 * instead of fread(), to make sure we stop fetching input after
173 * each newline.
174 */
175 int yy_is_interactive;
176
177 /* Whether we're considered to be at the beginning of a line.
178 * If so, '^' rules will be active on the next match, otherwise
179 * not.
180 */
181 int yy_at_bol;
182
183 /* Whether to try to fill the input buffer when we reach the
184 * end of it.
185 */
186 int yy_fill_buffer;
187
188 int yy_buffer_status;
189 #define YY_BUFFER_NEW 0
190 #define YY_BUFFER_NORMAL 1
191 /* When an EOF's been seen but there's still some text to process
192 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
193 * shouldn't try reading from the input source any more. We might
194 * still have a bunch of tokens to match, though, because of
195 * possible backing-up.
196 *
197 * When we actually see the EOF, we change the status to "new"
198 * (via yyrestart()), so that the user can continue scanning by
199 * just pointing yyin at a new input file.
200 */
201 #define YY_BUFFER_EOF_PENDING 2
202 };
203
204 static YY_BUFFER_STATE yy_current_buffer = 0;
205
206 /* We provide macros for accessing buffer states in case in the
207 * future we want to put the buffer states in a more general
208 * "scanner state".
209 */
210 #define YY_CURRENT_BUFFER yy_current_buffer
211
212
213 /* yy_hold_char holds the character lost when yytext is formed. */
214 static char yy_hold_char;
215
216 static int yy_n_chars; /* number of characters read into yy_ch_buf */
217
218
219 int yyleng;
220
221 /* Points to current character in buffer. */
222 static char *yy_c_buf_p = (char *) 0;
223 static int yy_init = 1; /* whether we need to initialize */
224 static int yy_start = 0; /* start state number */
225
226 /* Flag which is used to allow yywrap()'s to do buffer switches
227 * instead of setting up a fresh yyin. A bit of a hack ...
228 */
229 static int yy_did_buffer_switch_on_eof;
230
231 void yyrestart YY_PROTO(( FILE *input_file ));
232
233 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
234 void yy_load_buffer_state YY_PROTO(( void ));
235 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
236 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
237 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
238 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
239 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
240
241 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
242 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
243 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
244
245 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
246 static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
247 static void yy_flex_free YY_PROTO(( void * ));
248
249 #define yy_new_buffer yy_create_buffer
250
251 #define yy_set_interactive(is_interactive) \
252 { \
253 if ( ! yy_current_buffer ) \
254 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
255 yy_current_buffer->yy_is_interactive = is_interactive; \
256 }
257
258 #define yy_set_bol(at_bol) \
259 { \
260 if ( ! yy_current_buffer ) \
261 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
262 yy_current_buffer->yy_at_bol = at_bol; \
263 }
264
265 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
266
267 typedef unsigned char YY_CHAR;
268 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
269 typedef int yy_state_type;
270 extern char *yytext;
271 #define yytext_ptr yytext
272
273 static yy_state_type yy_get_previous_state YY_PROTO(( void ));
274 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
275 static int yy_get_next_buffer YY_PROTO(( void ));
276 static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
277
278 /* Done after the current pattern has been matched and before the
279 * corresponding action - sets up yytext.
280 */
281 #define YY_DO_BEFORE_ACTION \
282 yytext_ptr = yy_bp; \
283 yyleng = (int) (yy_cp - yy_bp); \
284 yy_hold_char = *yy_cp; \
285 *yy_cp = '\0'; \
286 yy_c_buf_p = yy_cp;
287
288 #define YY_NUM_RULES 15
289 #define YY_END_OF_BUFFER 16
290 static yyconst short int yy_accept[60] =
291 { 0,
292 0, 0, 16, 14, 13, 12, 11, 8, 8, 10,
293 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
294 10, 8, 0, 10, 10, 10, 10, 10, 10, 10,
295 10, 10, 10, 10, 10, 10, 7, 9, 10, 10,
296 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
297 5, 1, 2, 3, 10, 6, 10, 4, 0
298 } ;
299
300 static yyconst int yy_ec[256] =
301 { 0,
302 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
303 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
304 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
305 1, 4, 1, 1, 5, 1, 1, 1, 1, 1,
306 1, 1, 1, 1, 1, 1, 1, 6, 7, 7,
307 7, 7, 7, 7, 7, 7, 7, 1, 8, 1,
308 1, 1, 1, 1, 9, 10, 11, 12, 13, 10,
309 14, 15, 16, 15, 15, 15, 17, 18, 15, 15,
310 15, 19, 20, 15, 15, 15, 15, 15, 15, 15,
311 1, 1, 1, 1, 15, 1, 21, 10, 22, 23,
312
313 24, 10, 25, 15, 26, 15, 15, 15, 27, 28,
314 15, 29, 15, 30, 31, 15, 15, 15, 15, 32,
315 15, 15, 1, 1, 1, 1, 1, 1, 1, 1,
316 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
317 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
318 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
319 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
320 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
321 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
322 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
323
324 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
325 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
326 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
327 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
328 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
329 1, 1, 1, 1, 1
330 } ;
331
332 static yyconst int yy_meta[33] =
333 { 0,
334 1, 1, 1, 1, 1, 2, 2, 1, 2, 2,
335 2, 2, 2, 3, 3, 3, 3, 3, 3, 3,
336 2, 2, 2, 2, 3, 3, 3, 3, 3, 3,
337 3, 3
338 } ;
339
340 static yyconst short int yy_base[62] =
341 { 0,
342 0, 0, 83, 84, 84, 84, 84, 27, 29, 70,
343 0, 62, 61, 60, 20, 55, 47, 46, 45, 12,
344 35, 37, 0, 0, 62, 60, 59, 58, 53, 49,
345 45, 43, 42, 41, 37, 32, 0, 0, 43, 44,
346 43, 42, 42, 36, 23, 27, 26, 25, 25, 20,
347 0, 0, 0, 0, 35, 0, 23, 0, 84, 58,
348 43
349 } ;
350
351 static yyconst short int yy_def[62] =
352 { 0,
353 59, 1, 59, 59, 59, 59, 59, 59, 59, 60,
354 60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
355 60, 59, 61, 60, 60, 60, 60, 60, 60, 60,
356 60, 60, 60, 60, 60, 60, 60, 61, 60, 60,
357 60, 60, 60, 60, 60, 60, 60, 60, 60, 60,
358 60, 60, 60, 60, 60, 60, 60, 60, 0, 59,
359 59
360 } ;
361
362 static yyconst short int yy_nxt[117] =
363 { 0,
364 4, 5, 6, 5, 7, 8, 9, 7, 10, 11,
365 12, 13, 11, 14, 11, 15, 11, 11, 11, 11,
366 16, 17, 18, 11, 19, 20, 11, 11, 21, 11,
367 11, 11, 22, 22, 22, 22, 29, 30, 35, 36,
368 37, 37, 22, 22, 38, 58, 58, 56, 57, 54,
369 53, 52, 51, 56, 55, 54, 53, 52, 23, 24,
370 24, 51, 50, 49, 48, 47, 46, 45, 44, 43,
371 42, 41, 40, 39, 34, 33, 32, 31, 28, 27,
372 26, 25, 59, 3, 59, 59, 59, 59, 59, 59,
373 59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
374
375 59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
376 59, 59, 59, 59, 59, 59
377 } ;
378
379 static yyconst short int yy_chk[117] =
380 { 0,
381 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
382 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
383 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
384 1, 1, 8, 8, 9, 9, 15, 15, 20, 20,
385 21, 21, 22, 22, 61, 57, 55, 50, 49, 48,
386 47, 46, 45, 44, 43, 42, 41, 40, 8, 60,
387 60, 39, 36, 35, 34, 33, 32, 31, 30, 29,
388 28, 27, 26, 25, 19, 18, 17, 16, 14, 13,
389 12, 10, 3, 59, 59, 59, 59, 59, 59, 59,
390 59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
391
392 59, 59, 59, 59, 59, 59, 59, 59, 59, 59,
393 59, 59, 59, 59, 59, 59
394 } ;
395
396 static yy_state_type yy_last_accepting_state;
397 static char *yy_last_accepting_cpos;
398
399 /* The intent behind this definition is that it'll catch
400 * any uses of REJECT which flex missed.
401 */
402 #define REJECT reject_used_but_not_detected
403 #define yymore() yymore_used_but_not_detected
404 #define YY_MORE_ADJ 0
405 #define YY_RESTORE_YY_MORE_OFFSET
406 char *yytext;
407 #line 1 "itbl-lex.l"
408 #define INITIAL 0
409 /* itbl-lex.l
410 Copyright 1997, 1998, 2001, 2002, 2005 Free Software Foundation, Inc.
411
412 This file is part of GAS, the GNU Assembler.
413
414 GAS is free software; you can redistribute it and/or modify
415 it under the terms of the GNU General Public License as published by
416 the Free Software Foundation; either version 2, or (at your option)
417 any later version.
418
419 GAS is distributed in the hope that it will be useful,
420 but WITHOUT ANY WARRANTY; without even the implied warranty of
421 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
422 GNU General Public License for more details.
423
424 You should have received a copy of the GNU General Public License
425 along with GAS; see the file COPYING. If not, write to the Free
426 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
427 02110-1301, USA. */
428 #line 22 "itbl-lex.l"
429 #include <stdio.h>
430 #include <string.h>
431 #include <stdlib.h>
432
433 #include "itbl-lex.h"
434 #include <itbl-parse.h>
435
436 #ifdef DEBUG
437 #define DBG(x) printf x
438 #define MDBG(x) printf x
439 #else
440 #define DBG(x)
441 #define MDBG(x)
442 #endif
443
444 int insntbl_line = 1;
445 #line 446 "itbl-lex.c"
446
447 /* Macros after this point can all be overridden by user definitions in
448 * section 1.
449 */
450
451 #ifndef YY_SKIP_YYWRAP
452 #ifdef __cplusplus
453 extern "C" int yywrap YY_PROTO(( void ));
454 #else
455 extern int yywrap YY_PROTO(( void ));
456 #endif
457 #endif
458
459 #ifndef YY_NO_UNPUT
460 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
461 #endif
462
463 #ifndef yytext_ptr
464 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
465 #endif
466
467 #ifdef YY_NEED_STRLEN
468 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
469 #endif
470
471 #ifndef YY_NO_INPUT
472 #ifdef __cplusplus
473 static int yyinput YY_PROTO(( void ));
474 #else
475 static int input YY_PROTO(( void ));
476 #endif
477 #endif
478
479 #if YY_STACK_USED
480 static int yy_start_stack_ptr = 0;
481 static int yy_start_stack_depth = 0;
482 static int *yy_start_stack = 0;
483 #ifndef YY_NO_PUSH_STATE
484 static void yy_push_state YY_PROTO(( int new_state ));
485 #endif
486 #ifndef YY_NO_POP_STATE
487 static void yy_pop_state YY_PROTO(( void ));
488 #endif
489 #ifndef YY_NO_TOP_STATE
490 static int yy_top_state YY_PROTO(( void ));
491 #endif
492
493 #else
494 #define YY_NO_PUSH_STATE 1
495 #define YY_NO_POP_STATE 1
496 #define YY_NO_TOP_STATE 1
497 #endif
498
499 #ifdef YY_MALLOC_DECL
500 YY_MALLOC_DECL
501 #else
502 #if __STDC__
503 #ifndef __cplusplus
504 #include <stdlib.h>
505 #endif
506 #else
507 /* Just try to get by without declaring the routines. This will fail
508 * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
509 * or sizeof(void*) != sizeof(int).
510 */
511 #endif
512 #endif
513
514 /* Amount of stuff to slurp up with each read. */
515 #ifndef YY_READ_BUF_SIZE
516 #define YY_READ_BUF_SIZE 8192
517 #endif
518
519 /* Copy whatever the last rule matched to the standard output. */
520
521 #ifndef ECHO
522 /* This used to be an fputs(), but since the string might contain NUL's,
523 * we now use fwrite().
524 */
525 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
526 #endif
527
528 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
529 * is returned in "result".
530 */
531 #ifndef YY_INPUT
532 #define YY_INPUT(buf,result,max_size) \
533 if ( yy_current_buffer->yy_is_interactive ) \
534 { \
535 int c = '*', n; \
536 for ( n = 0; n < max_size && \
537 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
538 buf[n] = (char) c; \
539 if ( c == '\n' ) \
540 buf[n++] = (char) c; \
541 if ( c == EOF && ferror( yyin ) ) \
542 YY_FATAL_ERROR( "input in flex scanner failed" ); \
543 result = n; \
544 } \
545 else \
546 { \
547 errno=0; \
548 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
549 { \
550 if( errno != EINTR) \
551 { \
552 YY_FATAL_ERROR( "input in flex scanner failed" ); \
553 break; \
554 } \
555 errno=0; \
556 clearerr(yyin); \
557 } \
558 }
559 #endif
560
561 /* No semi-colon after return; correct usage is to write "yyterminate();" -
562 * we don't want an extra ';' after the "return" because that will cause
563 * some compilers to complain about unreachable statements.
564 */
565 #ifndef yyterminate
566 #define yyterminate() return YY_NULL
567 #endif
568
569 /* Number of entries by which start-condition stack grows. */
570 #ifndef YY_START_STACK_INCR
571 #define YY_START_STACK_INCR 25
572 #endif
573
574 /* Report a fatal error. */
575 #ifndef YY_FATAL_ERROR
576 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
577 #endif
578
579 /* Default declaration of generated scanner - a define so the user can
580 * easily add parameters.
581 */
582 #ifndef YY_DECL
583 #define YY_DECL int yylex YY_PROTO(( void ))
584 #endif
585
586 /* Code executed at the beginning of each rule, after yytext and yyleng
587 * have been set up.
588 */
589 #ifndef YY_USER_ACTION
590 #define YY_USER_ACTION
591 #endif
592
593 /* Code executed at the end of each rule. */
594 #ifndef YY_BREAK
595 #define YY_BREAK break;
596 #endif
597
598 #define YY_RULE_SETUP \
599 YY_USER_ACTION
600
601 YY_DECL
602 {
603 register yy_state_type yy_current_state;
604 register char *yy_cp, *yy_bp;
605 register int yy_act;
606
607 #line 45 "itbl-lex.l"
608
609
610 #line 611 "itbl-lex.c"
611
612 if ( yy_init )
613 {
614 yy_init = 0;
615
616 #ifdef YY_USER_INIT
617 YY_USER_INIT;
618 #endif
619
620 if ( ! yy_start )
621 yy_start = 1; /* first start state */
622
623 if ( ! yyin )
624 yyin = stdin;
625
626 if ( ! yyout )
627 yyout = stdout;
628
629 if ( ! yy_current_buffer )
630 yy_current_buffer =
631 yy_create_buffer( yyin, YY_BUF_SIZE );
632
633 yy_load_buffer_state();
634 }
635
636 while ( 1 ) /* loops until end-of-file is reached */
637 {
638 yy_cp = yy_c_buf_p;
639
640 /* Support of yytext. */
641 *yy_cp = yy_hold_char;
642
643 /* yy_bp points to the position in yy_ch_buf of the start of
644 * the current run.
645 */
646 yy_bp = yy_cp;
647
648 yy_current_state = yy_start;
649 yy_match:
650 do
651 {
652 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
653 if ( yy_accept[yy_current_state] )
654 {
655 yy_last_accepting_state = yy_current_state;
656 yy_last_accepting_cpos = yy_cp;
657 }
658 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
659 {
660 yy_current_state = (int) yy_def[yy_current_state];
661 if ( yy_current_state >= 60 )
662 yy_c = yy_meta[(unsigned int) yy_c];
663 }
664 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
665 ++yy_cp;
666 }
667 while ( yy_base[yy_current_state] != 84 );
668
669 yy_find_action:
670 yy_act = yy_accept[yy_current_state];
671 if ( yy_act == 0 )
672 { /* have to back up */
673 yy_cp = yy_last_accepting_cpos;
674 yy_current_state = yy_last_accepting_state;
675 yy_act = yy_accept[yy_current_state];
676 }
677
678 YY_DO_BEFORE_ACTION;
679
680
681 do_action: /* This label is used only to access EOF actions. */
682
683
684 switch ( yy_act )
685 { /* beginning of action switch */
686 case 0: /* must back up */
687 /* undo the effects of YY_DO_BEFORE_ACTION */
688 *yy_cp = yy_hold_char;
689 yy_cp = yy_last_accepting_cpos;
690 yy_current_state = yy_last_accepting_state;
691 goto yy_find_action;
692
693 case 1:
694 YY_RULE_SETUP
695 #line 47 "itbl-lex.l"
696 {
697 return CREG;
698 }
699 YY_BREAK
700 case 2:
701 YY_RULE_SETUP
702 #line 50 "itbl-lex.l"
703 {
704 return DREG;
705 }
706 YY_BREAK
707 case 3:
708 YY_RULE_SETUP
709 #line 53 "itbl-lex.l"
710 {
711 return GREG;
712 }
713 YY_BREAK
714 case 4:
715 YY_RULE_SETUP
716 #line 56 "itbl-lex.l"
717 {
718 return IMMED;
719 }
720 YY_BREAK
721 case 5:
722 YY_RULE_SETUP
723 #line 59 "itbl-lex.l"
724 {
725 return ADDR;
726 }
727 YY_BREAK
728 case 6:
729 YY_RULE_SETUP
730 #line 62 "itbl-lex.l"
731 {
732 return INSN;
733 }
734 YY_BREAK
735 case 7:
736 YY_RULE_SETUP
737 #line 65 "itbl-lex.l"
738 {
739 yytext[yyleng] = 0;
740 yylval.processor = strtoul (yytext+1, 0, 0);
741 return PNUM;
742 }
743 YY_BREAK
744 case 8:
745 YY_RULE_SETUP
746 #line 70 "itbl-lex.l"
747 {
748 yytext[yyleng] = 0;
749 yylval.num = strtoul (yytext, 0, 0);
750 return NUM;
751 }
752 YY_BREAK
753 case 9:
754 YY_RULE_SETUP
755 #line 75 "itbl-lex.l"
756 {
757 yytext[yyleng] = 0;
758 yylval.num = strtoul (yytext, 0, 0);
759 return NUM;
760 }
761 YY_BREAK
762 case 10:
763 YY_RULE_SETUP
764 #line 80 "itbl-lex.l"
765 {
766 yytext[yyleng] = 0;
767 yylval.str = strdup (yytext);
768 return ID;
769 }
770 YY_BREAK
771 case 11:
772 YY_RULE_SETUP
773 #line 85 "itbl-lex.l"
774 {
775 int c;
776 while ((c = input ()) != EOF)
777 {
778 if (c == '\n')
779 {
780 unput (c);
781 break;
782 }
783 }
784 }
785 YY_BREAK
786 case 12:
787 YY_RULE_SETUP
788 #line 96 "itbl-lex.l"
789 {
790 insntbl_line++;
791 MDBG (("in lex, NL = %d (x%x)\n", NL, NL));
792 return NL;
793 }
794 YY_BREAK
795 case 13:
796 YY_RULE_SETUP
797 #line 101 "itbl-lex.l"
798 {
799 }
800 YY_BREAK
801 case 14:
802 YY_RULE_SETUP
803 #line 103 "itbl-lex.l"
804 {
805 MDBG (("char = %x, %d\n", yytext[0], yytext[0]));
806 return yytext[0];
807 }
808 YY_BREAK
809 case 15:
810 YY_RULE_SETUP
811 #line 107 "itbl-lex.l"
812 ECHO;
813 YY_BREAK
814 #line 815 "itbl-lex.c"
815 case YY_STATE_EOF(INITIAL):
816 yyterminate();
817
818 case YY_END_OF_BUFFER:
819 {
820 /* Amount of text matched not including the EOB char. */
821 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
822
823 /* Undo the effects of YY_DO_BEFORE_ACTION. */
824 *yy_cp = yy_hold_char;
825 YY_RESTORE_YY_MORE_OFFSET
826
827 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
828 {
829 /* We're scanning a new file or input source. It's
830 * possible that this happened because the user
831 * just pointed yyin at a new source and called
832 * yylex(). If so, then we have to assure
833 * consistency between yy_current_buffer and our
834 * globals. Here is the right place to do so, because
835 * this is the first action (other than possibly a
836 * back-up) that will match for the new input source.
837 */
838 yy_n_chars = yy_current_buffer->yy_n_chars;
839 yy_current_buffer->yy_input_file = yyin;
840 yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
841 }
842
843 /* Note that here we test for yy_c_buf_p "<=" to the position
844 * of the first EOB in the buffer, since yy_c_buf_p will
845 * already have been incremented past the NUL character
846 * (since all states make transitions on EOB to the
847 * end-of-buffer state). Contrast this with the test
848 * in input().
849 */
850 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
851 { /* This was really a NUL. */
852 yy_state_type yy_next_state;
853
854 yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
855
856 yy_current_state = yy_get_previous_state();
857
858 /* Okay, we're now positioned to make the NUL
859 * transition. We couldn't have
860 * yy_get_previous_state() go ahead and do it
861 * for us because it doesn't know how to deal
862 * with the possibility of jamming (and we don't
863 * want to build jamming into it because then it
864 * will run more slowly).
865 */
866
867 yy_next_state = yy_try_NUL_trans( yy_current_state );
868
869 yy_bp = yytext_ptr + YY_MORE_ADJ;
870
871 if ( yy_next_state )
872 {
873 /* Consume the NUL. */
874 yy_cp = ++yy_c_buf_p;
875 yy_current_state = yy_next_state;
876 goto yy_match;
877 }
878
879 else
880 {
881 yy_cp = yy_c_buf_p;
882 goto yy_find_action;
883 }
884 }
885
886 else switch ( yy_get_next_buffer() )
887 {
888 case EOB_ACT_END_OF_FILE:
889 {
890 yy_did_buffer_switch_on_eof = 0;
891
892 if ( yywrap() )
893 {
894 /* Note: because we've taken care in
895 * yy_get_next_buffer() to have set up
896 * yytext, we can now set up
897 * yy_c_buf_p so that if some total
898 * hoser (like flex itself) wants to
899 * call the scanner after we return the
900 * YY_NULL, it'll still work - another
901 * YY_NULL will get returned.
902 */
903 yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
904
905 yy_act = YY_STATE_EOF(YY_START);
906 goto do_action;
907 }
908
909 else
910 {
911 if ( ! yy_did_buffer_switch_on_eof )
912 YY_NEW_FILE;
913 }
914 break;
915 }
916
917 case EOB_ACT_CONTINUE_SCAN:
918 yy_c_buf_p =
919 yytext_ptr + yy_amount_of_matched_text;
920
921 yy_current_state = yy_get_previous_state();
922
923 yy_cp = yy_c_buf_p;
924 yy_bp = yytext_ptr + YY_MORE_ADJ;
925 goto yy_match;
926
927 case EOB_ACT_LAST_MATCH:
928 yy_c_buf_p =
929 &yy_current_buffer->yy_ch_buf[yy_n_chars];
930
931 yy_current_state = yy_get_previous_state();
932
933 yy_cp = yy_c_buf_p;
934 yy_bp = yytext_ptr + YY_MORE_ADJ;
935 goto yy_find_action;
936 }
937 break;
938 }
939
940 default:
941 YY_FATAL_ERROR(
942 "fatal flex scanner internal error--no action found" );
943 } /* end of action switch */
944 } /* end of scanning one token */
945 } /* end of yylex */
946
947
948 /* yy_get_next_buffer - try to read in a new buffer
949 *
950 * Returns a code representing an action:
951 * EOB_ACT_LAST_MATCH -
952 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
953 * EOB_ACT_END_OF_FILE - end of file
954 */
955
956 static int yy_get_next_buffer()
957 {
958 register char *dest = yy_current_buffer->yy_ch_buf;
959 register char *source = yytext_ptr;
960 register int number_to_move, i;
961 int ret_val;
962
963 if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
964 YY_FATAL_ERROR(
965 "fatal flex scanner internal error--end of buffer missed" );
966
967 if ( yy_current_buffer->yy_fill_buffer == 0 )
968 { /* Don't try to fill the buffer, so this is an EOF. */
969 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
970 {
971 /* We matched a single character, the EOB, so
972 * treat this as a final EOF.
973 */
974 return EOB_ACT_END_OF_FILE;
975 }
976
977 else
978 {
979 /* We matched some text prior to the EOB, first
980 * process it.
981 */
982 return EOB_ACT_LAST_MATCH;
983 }
984 }
985
986 /* Try to read more data. */
987
988 /* First move last chars to start of buffer. */
989 number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
990
991 for ( i = 0; i < number_to_move; ++i )
992 *(dest++) = *(source++);
993
994 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
995 /* don't do the read, it's not guaranteed to return an EOF,
996 * just force an EOF
997 */
998 yy_current_buffer->yy_n_chars = yy_n_chars = 0;
999
1000 else
1001 {
1002 int num_to_read =
1003 yy_current_buffer->yy_buf_size - number_to_move - 1;
1004
1005 while ( num_to_read <= 0 )
1006 { /* Not enough room in the buffer - grow it. */
1007 #ifdef YY_USES_REJECT
1008 YY_FATAL_ERROR(
1009 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
1010 #else
1011
1012 /* just a shorter name for the current buffer */
1013 YY_BUFFER_STATE b = yy_current_buffer;
1014
1015 int yy_c_buf_p_offset =
1016 (int) (yy_c_buf_p - b->yy_ch_buf);
1017
1018 if ( b->yy_is_our_buffer )
1019 {
1020 int new_size = b->yy_buf_size * 2;
1021
1022 if ( new_size <= 0 )
1023 b->yy_buf_size += b->yy_buf_size / 8;
1024 else
1025 b->yy_buf_size *= 2;
1026
1027 b->yy_ch_buf = (char *)
1028 /* Include room in for 2 EOB chars. */
1029 yy_flex_realloc( (void *) b->yy_ch_buf,
1030 b->yy_buf_size + 2 );
1031 }
1032 else
1033 /* Can't grow it, we don't own it. */
1034 b->yy_ch_buf = 0;
1035
1036 if ( ! b->yy_ch_buf )
1037 YY_FATAL_ERROR(
1038 "fatal error - scanner input buffer overflow" );
1039
1040 yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1041
1042 num_to_read = yy_current_buffer->yy_buf_size -
1043 number_to_move - 1;
1044 #endif
1045 }
1046
1047 if ( num_to_read > YY_READ_BUF_SIZE )
1048 num_to_read = YY_READ_BUF_SIZE;
1049
1050 /* Read in more data. */
1051 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
1052 yy_n_chars, num_to_read );
1053
1054 yy_current_buffer->yy_n_chars = yy_n_chars;
1055 }
1056
1057 if ( yy_n_chars == 0 )
1058 {
1059 if ( number_to_move == YY_MORE_ADJ )
1060 {
1061 ret_val = EOB_ACT_END_OF_FILE;
1062 yyrestart( yyin );
1063 }
1064
1065 else
1066 {
1067 ret_val = EOB_ACT_LAST_MATCH;
1068 yy_current_buffer->yy_buffer_status =
1069 YY_BUFFER_EOF_PENDING;
1070 }
1071 }
1072
1073 else
1074 ret_val = EOB_ACT_CONTINUE_SCAN;
1075
1076 yy_n_chars += number_to_move;
1077 yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1078 yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1079
1080 yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
1081
1082 return ret_val;
1083 }
1084
1085
1086 /* yy_get_previous_state - get the state just before the EOB char was reached */
1087
1088 static yy_state_type yy_get_previous_state()
1089 {
1090 register yy_state_type yy_current_state;
1091 register char *yy_cp;
1092
1093 yy_current_state = yy_start;
1094
1095 for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
1096 {
1097 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1098 if ( yy_accept[yy_current_state] )
1099 {
1100 yy_last_accepting_state = yy_current_state;
1101 yy_last_accepting_cpos = yy_cp;
1102 }
1103 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1104 {
1105 yy_current_state = (int) yy_def[yy_current_state];
1106 if ( yy_current_state >= 60 )
1107 yy_c = yy_meta[(unsigned int) yy_c];
1108 }
1109 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1110 }
1111
1112 return yy_current_state;
1113 }
1114
1115
1116 /* yy_try_NUL_trans - try to make a transition on the NUL character
1117 *
1118 * synopsis
1119 * next_state = yy_try_NUL_trans( current_state );
1120 */
1121
1122 #ifdef YY_USE_PROTOS
1123 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
1124 #else
1125 static yy_state_type yy_try_NUL_trans( yy_current_state )
1126 yy_state_type yy_current_state;
1127 #endif
1128 {
1129 register int yy_is_jam;
1130 register char *yy_cp = yy_c_buf_p;
1131
1132 register YY_CHAR yy_c = 1;
1133 if ( yy_accept[yy_current_state] )
1134 {
1135 yy_last_accepting_state = yy_current_state;
1136 yy_last_accepting_cpos = yy_cp;
1137 }
1138 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1139 {
1140 yy_current_state = (int) yy_def[yy_current_state];
1141 if ( yy_current_state >= 60 )
1142 yy_c = yy_meta[(unsigned int) yy_c];
1143 }
1144 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1145 yy_is_jam = (yy_current_state == 59);
1146
1147 return yy_is_jam ? 0 : yy_current_state;
1148 }
1149
1150
1151 #ifndef YY_NO_UNPUT
1152 #ifdef YY_USE_PROTOS
1153 static void yyunput( int c, register char *yy_bp )
1154 #else
1155 static void yyunput( c, yy_bp )
1156 int c;
1157 register char *yy_bp;
1158 #endif
1159 {
1160 register char *yy_cp = yy_c_buf_p;
1161
1162 /* undo effects of setting up yytext */
1163 *yy_cp = yy_hold_char;
1164
1165 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1166 { /* need to shift things up to make room */
1167 /* +2 for EOB chars. */
1168 register int number_to_move = yy_n_chars + 2;
1169 register char *dest = &yy_current_buffer->yy_ch_buf[
1170 yy_current_buffer->yy_buf_size + 2];
1171 register char *source =
1172 &yy_current_buffer->yy_ch_buf[number_to_move];
1173
1174 while ( source > yy_current_buffer->yy_ch_buf )
1175 *--dest = *--source;
1176
1177 yy_cp += (int) (dest - source);
1178 yy_bp += (int) (dest - source);
1179 yy_current_buffer->yy_n_chars =
1180 yy_n_chars = yy_current_buffer->yy_buf_size;
1181
1182 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1183 YY_FATAL_ERROR( "flex scanner push-back overflow" );
1184 }
1185
1186 *--yy_cp = (char) c;
1187
1188
1189 yytext_ptr = yy_bp;
1190 yy_hold_char = *yy_cp;
1191 yy_c_buf_p = yy_cp;
1192 }
1193 #endif /* ifndef YY_NO_UNPUT */
1194
1195
1196 #ifdef __cplusplus
1197 static int yyinput()
1198 #else
1199 static int input()
1200 #endif
1201 {
1202 int c;
1203
1204 *yy_c_buf_p = yy_hold_char;
1205
1206 if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1207 {
1208 /* yy_c_buf_p now points to the character we want to return.
1209 * If this occurs *before* the EOB characters, then it's a
1210 * valid NUL; if not, then we've hit the end of the buffer.
1211 */
1212 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1213 /* This was really a NUL. */
1214 *yy_c_buf_p = '\0';
1215
1216 else
1217 { /* need more input */
1218 int offset = yy_c_buf_p - yytext_ptr;
1219 ++yy_c_buf_p;
1220
1221 switch ( yy_get_next_buffer() )
1222 {
1223 case EOB_ACT_LAST_MATCH:
1224 /* This happens because yy_g_n_b()
1225 * sees that we've accumulated a
1226 * token and flags that we need to
1227 * try matching the token before
1228 * proceeding. But for input(),
1229 * there's no matching to consider.
1230 * So convert the EOB_ACT_LAST_MATCH
1231 * to EOB_ACT_END_OF_FILE.
1232 */
1233
1234 /* Reset buffer status. */
1235 yyrestart( yyin );
1236
1237 /* fall through */
1238
1239 case EOB_ACT_END_OF_FILE:
1240 {
1241 if ( yywrap() )
1242 return EOF;
1243
1244 if ( ! yy_did_buffer_switch_on_eof )
1245 YY_NEW_FILE;
1246 #ifdef __cplusplus
1247 return yyinput();
1248 #else
1249 return input();
1250 #endif
1251 }
1252
1253 case EOB_ACT_CONTINUE_SCAN:
1254 yy_c_buf_p = yytext_ptr + offset;
1255 break;
1256 }
1257 }
1258 }
1259
1260 c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */
1261 *yy_c_buf_p = '\0'; /* preserve yytext */
1262 yy_hold_char = *++yy_c_buf_p;
1263
1264
1265 return c;
1266 }
1267
1268
1269 #ifdef YY_USE_PROTOS
1270 void yyrestart( FILE *input_file )
1271 #else
1272 void yyrestart( input_file )
1273 FILE *input_file;
1274 #endif
1275 {
1276 if ( ! yy_current_buffer )
1277 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
1278
1279 yy_init_buffer( yy_current_buffer, input_file );
1280 yy_load_buffer_state();
1281 }
1282
1283
1284 #ifdef YY_USE_PROTOS
1285 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
1286 #else
1287 void yy_switch_to_buffer( new_buffer )
1288 YY_BUFFER_STATE new_buffer;
1289 #endif
1290 {
1291 if ( yy_current_buffer == new_buffer )
1292 return;
1293
1294 if ( yy_current_buffer )
1295 {
1296 /* Flush out information for old buffer. */
1297 *yy_c_buf_p = yy_hold_char;
1298 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
1299 yy_current_buffer->yy_n_chars = yy_n_chars;
1300 }
1301
1302 yy_current_buffer = new_buffer;
1303 yy_load_buffer_state();
1304
1305 /* We don't actually know whether we did this switch during
1306 * EOF (yywrap()) processing, but the only time this flag
1307 * is looked at is after yywrap() is called, so it's safe
1308 * to go ahead and always set it.
1309 */
1310 yy_did_buffer_switch_on_eof = 1;
1311 }
1312
1313
1314 #ifdef YY_USE_PROTOS
1315 void yy_load_buffer_state( void )
1316 #else
1317 void yy_load_buffer_state()
1318 #endif
1319 {
1320 yy_n_chars = yy_current_buffer->yy_n_chars;
1321 yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
1322 yyin = yy_current_buffer->yy_input_file;
1323 yy_hold_char = *yy_c_buf_p;
1324 }
1325
1326
1327 #ifdef YY_USE_PROTOS
1328 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
1329 #else
1330 YY_BUFFER_STATE yy_create_buffer( file, size )
1331 FILE *file;
1332 int size;
1333 #endif
1334 {
1335 YY_BUFFER_STATE b;
1336
1337 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1338 if ( ! b )
1339 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1340
1341 b->yy_buf_size = size;
1342
1343 /* yy_ch_buf has to be 2 characters longer than the size given because
1344 * we need to put in 2 end-of-buffer characters.
1345 */
1346 b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
1347 if ( ! b->yy_ch_buf )
1348 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1349
1350 b->yy_is_our_buffer = 1;
1351
1352 yy_init_buffer( b, file );
1353
1354 return b;
1355 }
1356
1357
1358 #ifdef YY_USE_PROTOS
1359 void yy_delete_buffer( YY_BUFFER_STATE b )
1360 #else
1361 void yy_delete_buffer( b )
1362 YY_BUFFER_STATE b;
1363 #endif
1364 {
1365 if ( ! b )
1366 return;
1367
1368 if ( b == yy_current_buffer )
1369 yy_current_buffer = (YY_BUFFER_STATE) 0;
1370
1371 if ( b->yy_is_our_buffer )
1372 yy_flex_free( (void *) b->yy_ch_buf );
1373
1374 yy_flex_free( (void *) b );
1375 }
1376
1377
1378 #ifndef _WIN32
1379 #include <unistd.h>
1380 #else
1381 #ifndef YY_ALWAYS_INTERACTIVE
1382 #ifndef YY_NEVER_INTERACTIVE
1383 extern int isatty YY_PROTO(( int ));
1384 #endif
1385 #endif
1386 #endif
1387
1388 #ifdef YY_USE_PROTOS
1389 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
1390 #else
1391 void yy_init_buffer( b, file )
1392 YY_BUFFER_STATE b;
1393 FILE *file;
1394 #endif
1395
1396
1397 {
1398 yy_flush_buffer( b );
1399
1400 b->yy_input_file = file;
1401 b->yy_fill_buffer = 1;
1402
1403 #if YY_ALWAYS_INTERACTIVE
1404 b->yy_is_interactive = 1;
1405 #else
1406 #if YY_NEVER_INTERACTIVE
1407 b->yy_is_interactive = 0;
1408 #else
1409 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1410 #endif
1411 #endif
1412 }
1413
1414
1415 #ifdef YY_USE_PROTOS
1416 void yy_flush_buffer( YY_BUFFER_STATE b )
1417 #else
1418 void yy_flush_buffer( b )
1419 YY_BUFFER_STATE b;
1420 #endif
1421
1422 {
1423 if ( ! b )
1424 return;
1425
1426 b->yy_n_chars = 0;
1427
1428 /* We always need two end-of-buffer characters. The first causes
1429 * a transition to the end-of-buffer state. The second causes
1430 * a jam in that state.
1431 */
1432 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1433 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1434
1435 b->yy_buf_pos = &b->yy_ch_buf[0];
1436
1437 b->yy_at_bol = 1;
1438 b->yy_buffer_status = YY_BUFFER_NEW;
1439
1440 if ( b == yy_current_buffer )
1441 yy_load_buffer_state();
1442 }
1443
1444
1445 #ifndef YY_NO_SCAN_BUFFER
1446 #ifdef YY_USE_PROTOS
1447 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
1448 #else
1449 YY_BUFFER_STATE yy_scan_buffer( base, size )
1450 char *base;
1451 yy_size_t size;
1452 #endif
1453 {
1454 YY_BUFFER_STATE b;
1455
1456 if ( size < 2 ||
1457 base[size-2] != YY_END_OF_BUFFER_CHAR ||
1458 base[size-1] != YY_END_OF_BUFFER_CHAR )
1459 /* They forgot to leave room for the EOB's. */
1460 return 0;
1461
1462 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1463 if ( ! b )
1464 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1465
1466 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
1467 b->yy_buf_pos = b->yy_ch_buf = base;
1468 b->yy_is_our_buffer = 0;
1469 b->yy_input_file = 0;
1470 b->yy_n_chars = b->yy_buf_size;
1471 b->yy_is_interactive = 0;
1472 b->yy_at_bol = 1;
1473 b->yy_fill_buffer = 0;
1474 b->yy_buffer_status = YY_BUFFER_NEW;
1475
1476 yy_switch_to_buffer( b );
1477
1478 return b;
1479 }
1480 #endif
1481
1482
1483 #ifndef YY_NO_SCAN_STRING
1484 #ifdef YY_USE_PROTOS
1485 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
1486 #else
1487 YY_BUFFER_STATE yy_scan_string( yy_str )
1488 yyconst char *yy_str;
1489 #endif
1490 {
1491 int len;
1492 for ( len = 0; yy_str[len]; ++len )
1493 ;
1494
1495 return yy_scan_bytes( yy_str, len );
1496 }
1497 #endif
1498
1499
1500 #ifndef YY_NO_SCAN_BYTES
1501 #ifdef YY_USE_PROTOS
1502 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
1503 #else
1504 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
1505 yyconst char *bytes;
1506 int len;
1507 #endif
1508 {
1509 YY_BUFFER_STATE b;
1510 char *buf;
1511 yy_size_t n;
1512 int i;
1513
1514 /* Get memory for full buffer, including space for trailing EOB's. */
1515 n = len + 2;
1516 buf = (char *) yy_flex_alloc( n );
1517 if ( ! buf )
1518 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1519
1520 for ( i = 0; i < len; ++i )
1521 buf[i] = bytes[i];
1522
1523 buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
1524
1525 b = yy_scan_buffer( buf, n );
1526 if ( ! b )
1527 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1528
1529 /* It's okay to grow etc. this buffer, and we should throw it
1530 * away when we're done.
1531 */
1532 b->yy_is_our_buffer = 1;
1533
1534 return b;
1535 }
1536 #endif
1537
1538
1539 #ifndef YY_NO_PUSH_STATE
1540 #ifdef YY_USE_PROTOS
1541 static void yy_push_state( int new_state )
1542 #else
1543 static void yy_push_state( new_state )
1544 int new_state;
1545 #endif
1546 {
1547 if ( yy_start_stack_ptr >= yy_start_stack_depth )
1548 {
1549 yy_size_t new_size;
1550
1551 yy_start_stack_depth += YY_START_STACK_INCR;
1552 new_size = yy_start_stack_depth * sizeof( int );
1553
1554 if ( ! yy_start_stack )
1555 yy_start_stack = (int *) yy_flex_alloc( new_size );
1556
1557 else
1558 yy_start_stack = (int *) yy_flex_realloc(
1559 (void *) yy_start_stack, new_size );
1560
1561 if ( ! yy_start_stack )
1562 YY_FATAL_ERROR(
1563 "out of memory expanding start-condition stack" );
1564 }
1565
1566 yy_start_stack[yy_start_stack_ptr++] = YY_START;
1567
1568 BEGIN(new_state);
1569 }
1570 #endif
1571
1572
1573 #ifndef YY_NO_POP_STATE
1574 static void yy_pop_state()
1575 {
1576 if ( --yy_start_stack_ptr < 0 )
1577 YY_FATAL_ERROR( "start-condition stack underflow" );
1578
1579 BEGIN(yy_start_stack[yy_start_stack_ptr]);
1580 }
1581 #endif
1582
1583
1584 #ifndef YY_NO_TOP_STATE
1585 static int yy_top_state()
1586 {
1587 return yy_start_stack[yy_start_stack_ptr - 1];
1588 }
1589 #endif
1590
1591 #ifndef YY_EXIT_FAILURE
1592 #define YY_EXIT_FAILURE 2
1593 #endif
1594
1595 #ifdef YY_USE_PROTOS
1596 static void yy_fatal_error( yyconst char msg[] )
1597 #else
1598 static void yy_fatal_error( msg )
1599 char msg[];
1600 #endif
1601 {
1602 (void) fprintf( stderr, "%s\n", msg );
1603 exit( YY_EXIT_FAILURE );
1604 }
1605
1606
1607
1608 /* Redefine yyless() so it works in section 3 code. */
1609
1610 #undef yyless
1611 #define yyless(n) \
1612 do \
1613 { \
1614 /* Undo effects of setting up yytext. */ \
1615 yytext[yyleng] = yy_hold_char; \
1616 yy_c_buf_p = yytext + n; \
1617 yy_hold_char = *yy_c_buf_p; \
1618 *yy_c_buf_p = '\0'; \
1619 yyleng = n; \
1620 } \
1621 while ( 0 )
1622
1623
1624 /* Internal utility routines. */
1625
1626 #ifndef yytext_ptr
1627 #ifdef YY_USE_PROTOS
1628 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
1629 #else
1630 static void yy_flex_strncpy( s1, s2, n )
1631 char *s1;
1632 yyconst char *s2;
1633 int n;
1634 #endif
1635 {
1636 register int i;
1637 for ( i = 0; i < n; ++i )
1638 s1[i] = s2[i];
1639 }
1640 #endif
1641
1642 #ifdef YY_NEED_STRLEN
1643 #ifdef YY_USE_PROTOS
1644 static int yy_flex_strlen( yyconst char *s )
1645 #else
1646 static int yy_flex_strlen( s )
1647 yyconst char *s;
1648 #endif
1649 {
1650 register int n;
1651 for ( n = 0; s[n]; ++n )
1652 ;
1653
1654 return n;
1655 }
1656 #endif
1657
1658
1659 #ifdef YY_USE_PROTOS
1660 static void *yy_flex_alloc( yy_size_t size )
1661 #else
1662 static void *yy_flex_alloc( size )
1663 yy_size_t size;
1664 #endif
1665 {
1666 return (void *) malloc( size );
1667 }
1668
1669 #ifdef YY_USE_PROTOS
1670 static void *yy_flex_realloc( void *ptr, yy_size_t size )
1671 #else
1672 static void *yy_flex_realloc( ptr, size )
1673 void *ptr;
1674 yy_size_t size;
1675 #endif
1676 {
1677 /* The cast to (char *) in the following accommodates both
1678 * implementations that use char* generic pointers, and those
1679 * that use void* generic pointers. It works with the latter
1680 * because both ANSI C and C++ allow castless assignment from
1681 * any pointer type to void*, and deal with argument conversions
1682 * as though doing an assignment.
1683 */
1684 return (void *) realloc( (char *) ptr, size );
1685 }
1686
1687 #ifdef YY_USE_PROTOS
1688 static void yy_flex_free( void *ptr )
1689 #else
1690 static void yy_flex_free( ptr )
1691 void *ptr;
1692 #endif
1693 {
1694 free( ptr );
1695 }
1696
1697 #if YY_MAIN
1698 int main()
1699 {
1700 yylex();
1701 return 0;
1702 }
1703 #endif
1704 #line 107 "itbl-lex.l"
1705
1706
1707 #ifndef yywrap
1708 int
1709 yywrap ()
1710 {
1711 return 1;
1712 }
1713 #endif
DragonFly BSD