1 #define yy_create_buffer IfqParser_create_buffer
\r
2 #define yy_delete_buffer IfqParser_delete_buffer
\r
3 #define yy_scan_buffer IfqParser_scan_buffer
\r
4 #define yy_scan_string IfqParser_scan_string
\r
5 #define yy_scan_bytes IfqParser_scan_bytes
\r
6 #define yy_flex_debug IfqParser_flex_debug
\r
7 #define yy_init_buffer IfqParser_init_buffer
\r
8 #define yy_flush_buffer IfqParser_flush_buffer
\r
9 #define yy_load_buffer_state IfqParser_load_buffer_state
\r
10 #define yy_switch_to_buffer IfqParser_switch_to_buffer
\r
11 #define yyin IfqParserin
\r
12 #define yyleng IfqParserleng
\r
13 #define yylex IfqParserlex
\r
14 #define yyout IfqParserout
\r
15 #define yyrestart IfqParserrestart
\r
16 #define yytext IfqParsertext
\r
18 #line 19 "ifqlexer.cc"
\r
19 /* A lexical scanner generated by flex */
\r
21 /* Scanner skeleton version:
\r
22 * $Header: /cvsroot/gscpv4/src/ftacmp/ifqlexer.cc,v 1.1.1.1 2013/12/02 17:44:57 spatsch Exp $
\r
25 #define FLEX_SCANNER
\r
26 #define YY_FLEX_MAJOR_VERSION 2
\r
27 #define YY_FLEX_MINOR_VERSION 5
\r
33 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
\r
45 /* Use prototypes in function declarations. */
\r
46 #define YY_USE_PROTOS
\r
48 /* The "const" storage-class-modifier is valid. */
\r
49 #define YY_USE_CONST
\r
51 #else /* ! __cplusplus */
\r
55 #define YY_USE_PROTOS
\r
56 #define YY_USE_CONST
\r
58 #endif /* __STDC__ */
\r
59 #endif /* ! __cplusplus */
\r
66 #define YY_USE_CONST
\r
67 #define YY_USE_PROTOS
\r
71 #define yyconst const
\r
77 #ifdef YY_USE_PROTOS
\r
78 #define YY_PROTO(proto) proto
\r
80 #define YY_PROTO(proto) ()
\r
83 /* Returned upon end-of-file. */
\r
86 /* Promotes a possibly negative, possibly signed char to an unsigned
\r
87 * integer for use as an array index. If the signed char is negative,
\r
88 * we want to instead treat it as an 8-bit unsigned char, hence the
\r
91 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
\r
93 /* Enter a start condition. This macro really ought to take a parameter,
\r
94 * but we do it the disgusting crufty way forced on us by the ()-less
\r
95 * definition of BEGIN.
\r
97 #define BEGIN yy_start = 1 + 2 *
\r
99 /* Translate the current start state into a value that can be later handed
\r
100 * to BEGIN to return to the state. The YYSTATE alias is for lex
\r
103 #define YY_START ((yy_start - 1) / 2)
\r
104 #define YYSTATE YY_START
\r
106 /* Action number for EOF rule of a given start state. */
\r
107 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
\r
109 /* Special action meaning "start processing a new file". */
\r
110 #define YY_NEW_FILE yyrestart( yyin )
\r
112 #define YY_END_OF_BUFFER_CHAR 0
\r
114 /* Size of default input buffer. */
\r
115 #define YY_BUF_SIZE 16384
\r
117 typedef struct yy_buffer_state *YY_BUFFER_STATE;
\r
120 extern FILE *yyin, *yyout;
\r
122 #define EOB_ACT_CONTINUE_SCAN 0
\r
123 #define EOB_ACT_END_OF_FILE 1
\r
124 #define EOB_ACT_LAST_MATCH 2
\r
126 /* The funky do-while in the following #define is used to turn the definition
\r
127 * int a single C statement (which needs a semi-colon terminator). This
\r
128 * avoids problems with code like:
\r
130 * if ( condition_holds )
\r
133 * do_something_else();
\r
135 * Prior to using the do-while the compiler would get upset at the
\r
136 * "else" because it interpreted the "if" statement as being all
\r
137 * done when it reached the ';' after the yyless() call.
\r
140 /* Return all but the first 'n' matched characters back to the input stream. */
\r
142 #define yyless(n) \
\r
145 /* Undo effects of setting up yytext. */ \
\r
146 *yy_cp = yy_hold_char; \
\r
147 YY_RESTORE_YY_MORE_OFFSET \
\r
148 yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
\r
149 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
\r
153 #define unput(c) yyunput( c, yytext_ptr )
\r
155 /* The following is because we cannot portably get our hands on size_t
\r
156 * (without autoconf's help, which isn't available because we want
\r
157 * flex-generated scanners to compile on their own).
\r
159 typedef unsigned int yy_size_t;
\r
162 struct yy_buffer_state
\r
164 FILE *yy_input_file;
\r
166 char *yy_ch_buf; /* input buffer */
\r
167 char *yy_buf_pos; /* current position in input buffer */
\r
169 /* Size of input buffer in bytes, not including room for EOB
\r
172 yy_size_t yy_buf_size;
\r
174 /* Number of characters read into yy_ch_buf, not including EOB
\r
179 /* Whether we "own" the buffer - i.e., we know we created it,
\r
180 * and can realloc() it to grow it, and should free() it to
\r
183 int yy_is_our_buffer;
\r
185 /* Whether this is an "interactive" input source; if so, and
\r
186 * if we're using stdio for input, then we want to use getc()
\r
187 * instead of fread(), to make sure we stop fetching input after
\r
190 int yy_is_interactive;
\r
192 /* Whether we're considered to be at the beginning of a line.
\r
193 * If so, '^' rules will be active on the next match, otherwise
\r
198 /* Whether to try to fill the input buffer when we reach the
\r
201 int yy_fill_buffer;
\r
203 int yy_buffer_status;
\r
204 #define YY_BUFFER_NEW 0
\r
205 #define YY_BUFFER_NORMAL 1
\r
206 /* When an EOF's been seen but there's still some text to process
\r
207 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
\r
208 * shouldn't try reading from the input source any more. We might
\r
209 * still have a bunch of tokens to match, though, because of
\r
210 * possible backing-up.
\r
212 * When we actually see the EOF, we change the status to "new"
\r
213 * (via yyrestart()), so that the user can continue scanning by
\r
214 * just pointing yyin at a new input file.
\r
216 #define YY_BUFFER_EOF_PENDING 2
\r
219 static YY_BUFFER_STATE yy_current_buffer = 0;
\r
221 /* We provide macros for accessing buffer states in case in the
\r
222 * future we want to put the buffer states in a more general
\r
225 #define YY_CURRENT_BUFFER yy_current_buffer
\r
228 /* yy_hold_char holds the character lost when yytext is formed. */
\r
229 static char yy_hold_char;
\r
231 static int yy_n_chars; /* number of characters read into yy_ch_buf */
\r
236 /* Points to current character in buffer. */
\r
237 static char *yy_c_buf_p = (char *) 0;
\r
238 static int yy_init = 1; /* whether we need to initialize */
\r
239 static int yy_start = 0; /* start state number */
\r
241 /* Flag which is used to allow yywrap()'s to do buffer switches
\r
242 * instead of setting up a fresh yyin. A bit of a hack ...
\r
244 static int yy_did_buffer_switch_on_eof;
\r
246 void yyrestart YY_PROTO(( FILE *input_file ));
\r
248 void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
\r
249 void yy_load_buffer_state YY_PROTO(( void ));
\r
250 YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
\r
251 void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
\r
252 void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
\r
253 void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
\r
254 #define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
\r
256 YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
\r
257 YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
\r
258 YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
\r
260 static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
\r
261 static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
\r
262 static void yy_flex_free YY_PROTO(( void * ));
\r
264 #define yy_new_buffer yy_create_buffer
\r
266 #define yy_set_interactive(is_interactive) \
\r
268 if ( ! yy_current_buffer ) \
\r
269 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
\r
270 yy_current_buffer->yy_is_interactive = is_interactive; \
\r
273 #define yy_set_bol(at_bol) \
\r
275 if ( ! yy_current_buffer ) \
\r
276 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
\r
277 yy_current_buffer->yy_at_bol = at_bol; \
\r
280 #define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
\r
284 #define YY_SKIP_YYWRAP
\r
285 typedef unsigned char YY_CHAR;
\r
286 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
\r
287 typedef int yy_state_type;
\r
288 extern char *yytext;
\r
289 #define yytext_ptr yytext
\r
291 static yy_state_type yy_get_previous_state YY_PROTO(( void ));
\r
292 static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
\r
293 static int yy_get_next_buffer YY_PROTO(( void ));
\r
294 static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
\r
296 /* Done after the current pattern has been matched and before the
\r
297 * corresponding action - sets up yytext.
\r
299 #define YY_DO_BEFORE_ACTION \
\r
300 yytext_ptr = yy_bp; \
\r
301 yytext_ptr -= yy_more_len; \
\r
302 yyleng = (int) (yy_cp - yytext_ptr); \
\r
303 yy_hold_char = *yy_cp; \
\r
305 yy_c_buf_p = yy_cp;
\r
307 #define YY_NUM_RULES 27
\r
308 #define YY_END_OF_BUFFER 28
\r
309 static yyconst short int yy_accept[86] =
\r
311 0, 0, 28, 26, 23, 22, 8, 26, 9, 8,
\r
312 8, 12, 7, 11, 11, 11, 11, 11, 11, 11,
\r
313 11, 11, 11, 11, 10, 23, 22, 0, 21, 20,
\r
314 0, 16, 0, 0, 15, 12, 0, 0, 11, 11,
\r
315 11, 11, 11, 11, 11, 11, 11, 3, 11, 11,
\r
316 11, 0, 24, 0, 19, 0, 25, 15, 0, 0,
\r
317 17, 13, 1, 11, 11, 11, 11, 2, 11, 0,
\r
318 18, 14, 11, 11, 11, 11, 4, 11, 11, 11,
\r
322 static yyconst int yy_ec[256] =
\r
324 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
\r
325 1, 1, 2, 1, 1, 1, 1, 1, 1, 1,
\r
326 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
\r
327 1, 2, 4, 1, 1, 4, 1, 4, 5, 4,
\r
328 4, 4, 6, 4, 7, 8, 9, 10, 10, 10,
\r
329 10, 10, 10, 10, 10, 10, 10, 4, 11, 1,
\r
330 1, 1, 1, 1, 12, 13, 14, 15, 16, 17,
\r
331 13, 13, 13, 13, 13, 18, 13, 19, 20, 13,
\r
332 13, 21, 22, 23, 24, 13, 13, 13, 13, 13,
\r
333 4, 1, 4, 1, 13, 1, 25, 13, 13, 26,
\r
335 27, 13, 13, 13, 28, 13, 13, 29, 13, 30,
\r
336 31, 13, 32, 33, 34, 35, 36, 13, 13, 37,
\r
337 13, 13, 1, 4, 1, 38, 1, 1, 1, 1,
\r
338 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
\r
339 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
\r
340 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
\r
341 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
\r
342 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
\r
343 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
\r
344 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
\r
346 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
\r
347 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
\r
348 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
\r
349 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
\r
350 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
\r
354 static yyconst int yy_meta[39] =
\r
356 1, 1, 2, 1, 1, 1, 1, 1, 1, 3,
\r
357 1, 3, 3, 3, 3, 3, 3, 3, 3, 3,
\r
358 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
\r
359 3, 3, 3, 3, 3, 3, 3, 1
\r
362 static yyconst short int yy_base[91] =
\r
364 0, 0, 141, 142, 138, 0, 142, 36, 132, 30,
\r
365 129, 34, 142, 24, 0, 106, 15, 124, 25, 27,
\r
366 114, 104, 102, 99, 142, 129, 0, 46, 142, 142,
\r
367 127, 43, 56, 126, 55, 59, 66, 110, 0, 112,
\r
368 100, 95, 88, 95, 104, 98, 85, 0, 95, 92,
\r
369 82, 113, 142, 105, 104, 110, 142, 58, 71, 102,
\r
370 101, 92, 0, 74, 83, 73, 84, 0, 89, 94,
\r
371 93, 142, 77, 72, 65, 83, 0, 60, 50, 46,
\r
372 0, 49, 0, 30, 142, 86, 89, 52, 92, 95
\r
375 static yyconst short int yy_def[91] =
\r
377 85, 1, 85, 85, 85, 86, 85, 87, 85, 85,
\r
378 85, 85, 85, 88, 88, 88, 88, 88, 88, 88,
\r
379 88, 88, 88, 88, 85, 85, 86, 87, 85, 85,
\r
380 89, 85, 85, 90, 85, 85, 85, 85, 88, 88,
\r
381 88, 88, 88, 88, 88, 88, 88, 88, 88, 88,
\r
382 88, 89, 85, 85, 85, 90, 85, 85, 85, 85,
\r
383 85, 85, 88, 88, 88, 88, 88, 88, 88, 85,
\r
384 85, 85, 88, 88, 88, 88, 88, 88, 88, 88,
\r
385 88, 88, 88, 88, 0, 85, 85, 85, 85, 85
\r
388 static yyconst short int yy_nxt[181] =
\r
390 4, 5, 6, 7, 8, 7, 9, 10, 11, 12,
\r
391 13, 14, 15, 16, 15, 17, 18, 15, 19, 20,
\r
392 15, 15, 21, 15, 22, 15, 15, 15, 15, 23,
\r
393 24, 15, 15, 15, 15, 15, 15, 25, 29, 32,
\r
394 30, 35, 40, 36, 46, 33, 43, 48, 29, 37,
\r
395 30, 44, 32, 41, 39, 47, 33, 38, 33, 48,
\r
396 37, 54, 54, 83, 58, 55, 35, 58, 36, 33,
\r
397 59, 60, 60, 59, 37, 61, 70, 70, 84, 83,
\r
398 71, 59, 38, 83, 59, 37, 27, 82, 27, 28,
\r
399 28, 28, 52, 52, 52, 56, 56, 56, 81, 80,
\r
401 79, 78, 71, 71, 77, 76, 75, 74, 73, 72,
\r
402 61, 61, 57, 55, 55, 53, 68, 63, 69, 68,
\r
403 68, 67, 66, 65, 64, 63, 63, 62, 57, 53,
\r
404 26, 48, 51, 50, 49, 45, 42, 34, 31, 26,
\r
405 85, 3, 85, 85, 85, 85, 85, 85, 85, 85,
\r
406 85, 85, 85, 85, 85, 85, 85, 85, 85, 85,
\r
407 85, 85, 85, 85, 85, 85, 85, 85, 85, 85,
\r
408 85, 85, 85, 85, 85, 85, 85, 85, 85, 85
\r
411 static yyconst short int yy_chk[181] =
\r
413 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
\r
414 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
\r
415 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
\r
416 1, 1, 1, 1, 1, 1, 1, 1, 8, 10,
\r
417 8, 12, 14, 12, 19, 10, 17, 20, 28, 12,
\r
418 28, 17, 32, 14, 88, 19, 10, 12, 32, 20,
\r
419 12, 33, 33, 84, 35, 33, 36, 58, 36, 32,
\r
420 35, 37, 37, 58, 36, 37, 59, 59, 82, 80,
\r
421 59, 35, 36, 79, 58, 36, 86, 78, 86, 87,
\r
422 87, 87, 89, 89, 89, 90, 90, 90, 76, 75,
\r
424 74, 73, 71, 70, 69, 67, 66, 65, 64, 62,
\r
425 61, 60, 56, 55, 54, 52, 51, 50, 49, 47,
\r
426 46, 45, 44, 43, 42, 41, 40, 38, 34, 31,
\r
427 26, 24, 23, 22, 21, 18, 16, 11, 9, 5,
\r
428 3, 85, 85, 85, 85, 85, 85, 85, 85, 85,
\r
429 85, 85, 85, 85, 85, 85, 85, 85, 85, 85,
\r
430 85, 85, 85, 85, 85, 85, 85, 85, 85, 85,
\r
431 85, 85, 85, 85, 85, 85, 85, 85, 85, 85
\r
434 static yy_state_type yy_last_accepting_state;
\r
435 static char *yy_last_accepting_cpos;
\r
437 /* The intent behind this definition is that it'll catch
\r
438 * any uses of REJECT which flex missed.
\r
440 #define REJECT reject_used_but_not_detected
\r
441 static int yy_more_flag = 0;
\r
442 static int yy_more_len = 0;
\r
443 #define yymore() (yy_more_flag = 1)
\r
444 #define YY_MORE_ADJ yy_more_len
\r
445 #define YY_RESTORE_YY_MORE_OFFSET
\r
451 flex -PIfqParser -oifqlexer.cc ifq.l
\r
456 * AT&T lex can't handle this lexer due to lex bugs. It works with flex
\r
457 * 2.3.7, pclex 2.0.5, and MKS lex 3.1a.
\r
460 #include "parse_fta.h"
\r
461 #include <string.h>
\r
465 #include "ifq.tab.cc.h"
\r
468 Some includes that flex doesn't include as standard,
\r
469 but which are needed.
\r
472 #include <stdlib.h>
\r
473 #include <string.h>
\r
476 // Prevent flex from defining yywrap as extern "C"
\r
478 #define YY_SKIP_YYWRAP
\r
480 /* No lex lib, supply the yywrap fcn. that normally resides there
\r
483 int IfqParserwrap(){return(1);}
\r
485 extern int IfqParserdebug;
\r
489 These variables are used for error reporting:
\r
490 flex_ifq_lineno : the line currently being parsed when the error occurs.
\r
491 flex_ifq_ch : the character on the line where the error occurs
\r
492 flex_ifq_linebuf : store the line for reporting.
\r
494 NOTE : 1) the fixed size flex_ifq_linebuf buffer is dangerous.
\r
495 2) You might get pointed to a place shortly after
\r
496 where the syntax error occurs. It is close enough
\r
500 int flex_ifq_lineno = 1;
\r
501 int flex_ifq_ch = 0;
\r
502 char flex_ifq_linebuf[20000];
\r
504 char *flex_ifq_stringinput = NULL;
\r
505 int flex_ifq_stringinput_ptr = 0;
\r
506 FILE *flex_ifq_fileinput = NULL;
\r
507 int my_IfqParser_yyinput(char *buf, int max_size);
\r
511 void IfqParsererror(char *s){
\r
513 fprintf(stderr,"On line %d, char %d: %s (token %s):\n%s\n",
\r
514 flex_ifq_lineno, flex_ifq_ch, s, IfqParsertext, flex_ifq_linebuf );
\r
515 for(i=0;i<flex_ifq_ch;i++){
\r
516 if(flex_ifq_linebuf[i] == '\t'){
\r
517 fprintf(stderr,"\t");
\r
519 fprintf(stderr," ");
\r
522 fprintf(stderr,"^\n");
\r
523 // fprintf(stderr,"%*s\n",1+flex_ifq_ch,"^");
\r
527 #define YY_INPUT(b, r, ms) (r = my_IfqParser_yyinput(b,ms))
\r
529 /* MKS needs the next line to increase the NFA table */
\r
530 #line 531 "ifqlexer.cc"
\r
532 /* Macros after this point can all be overridden by user definitions in
\r
536 #ifndef YY_SKIP_YYWRAP
\r
538 extern "C" int yywrap YY_PROTO(( void ));
\r
540 extern int yywrap YY_PROTO(( void ));
\r
544 #ifndef YY_NO_UNPUT
\r
545 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
\r
549 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
\r
552 #ifdef YY_NEED_STRLEN
\r
553 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
\r
556 #ifndef YY_NO_INPUT
\r
558 static int yyinput YY_PROTO(( void ));
\r
560 static int input YY_PROTO(( void ));
\r
565 static int yy_start_stack_ptr = 0;
\r
566 static int yy_start_stack_depth = 0;
\r
567 static int *yy_start_stack = 0;
\r
568 #ifndef YY_NO_PUSH_STATE
\r
569 static void yy_push_state YY_PROTO(( int new_state ));
\r
571 #ifndef YY_NO_POP_STATE
\r
572 static void yy_pop_state YY_PROTO(( void ));
\r
574 #ifndef YY_NO_TOP_STATE
\r
575 static int yy_top_state YY_PROTO(( void ));
\r
579 #define YY_NO_PUSH_STATE 1
\r
580 #define YY_NO_POP_STATE 1
\r
581 #define YY_NO_TOP_STATE 1
\r
584 #ifdef YY_MALLOC_DECL
\r
588 #ifndef __cplusplus
\r
589 #include <stdlib.h>
\r
592 /* Just try to get by without declaring the routines. This will fail
\r
593 * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
\r
594 * or sizeof(void*) != sizeof(int).
\r
599 /* Amount of stuff to slurp up with each read. */
\r
600 #ifndef YY_READ_BUF_SIZE
\r
601 #define YY_READ_BUF_SIZE 8192
\r
604 /* Copy whatever the last rule matched to the standard output. */
\r
607 /* This used to be an fputs(), but since the string might contain NUL's,
\r
608 * we now use fwrite().
\r
610 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
\r
613 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
\r
614 * is returned in "result".
\r
617 #define YY_INPUT(buf,result,max_size) \
\r
618 if ( yy_current_buffer->yy_is_interactive ) \
\r
621 for ( n = 0; n < max_size && \
\r
622 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
\r
623 buf[n] = (char) c; \
\r
625 buf[n++] = (char) c; \
\r
626 if ( c == EOF && ferror( yyin ) ) \
\r
627 YY_FATAL_ERROR( "input in flex scanner failed" ); \
\r
630 else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
\r
631 && ferror( yyin ) ) \
\r
632 YY_FATAL_ERROR( "input in flex scanner failed" );
\r
635 /* No semi-colon after return; correct usage is to write "yyterminate();" -
\r
636 * we don't want an extra ';' after the "return" because that will cause
\r
637 * some compilers to complain about unreachable statements.
\r
639 #ifndef yyterminate
\r
640 #define yyterminate() return YY_NULL
\r
643 /* Number of entries by which start-condition stack grows. */
\r
644 #ifndef YY_START_STACK_INCR
\r
645 #define YY_START_STACK_INCR 25
\r
648 /* Report a fatal error. */
\r
649 #ifndef YY_FATAL_ERROR
\r
650 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
\r
653 /* Default declaration of generated scanner - a define so the user can
\r
654 * easily add parameters.
\r
657 #define YY_DECL int yylex YY_PROTO(( void ))
\r
660 /* Code executed at the beginning of each rule, after yytext and yyleng
\r
661 * have been set up.
\r
663 #ifndef YY_USER_ACTION
\r
664 #define YY_USER_ACTION
\r
667 /* Code executed at the end of each rule. */
\r
669 #define YY_BREAK break;
\r
672 #define YY_RULE_SETUP \
\r
677 register yy_state_type yy_current_state;
\r
678 register char *yy_cp = NULL, *yy_bp = NULL;
\r
679 register int yy_act;
\r
684 /* literal keyword tokens */
\r
687 The actions associated with each text token are to
\r
688 keep track of the current location (for syntax error reporting)
\r
689 and to report any necessary info to the emf.y parse tree builder
\r
691 Its likely that there are a number of omissions, inconsistencies
\r
692 (some keywords do not need to be in caps), and relics
\r
693 (keywords such as BETWEEN, INDICATOR, etc., are not used
\r
695 This parser is somewhat of a work in progress.
\r
698 /* Query keywords */
\r
700 #line 701 "ifqlexer.cc"
\r
706 #ifdef YY_USER_INIT
\r
711 yy_start = 1; /* first start state */
\r
719 if ( ! yy_current_buffer )
\r
720 yy_current_buffer =
\r
721 yy_create_buffer( yyin, YY_BUF_SIZE );
\r
723 yy_load_buffer_state();
\r
726 while ( 1 ) /* loops until end-of-file is reached */
\r
729 if ( yy_more_flag )
\r
731 yy_more_len = yy_c_buf_p - yytext_ptr;
\r
734 yy_cp = yy_c_buf_p;
\r
736 /* Support of yytext. */
\r
737 *yy_cp = yy_hold_char;
\r
739 /* yy_bp points to the position in yy_ch_buf of the start of
\r
744 yy_current_state = yy_start;
\r
748 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
\r
749 if ( yy_accept[yy_current_state] )
\r
751 yy_last_accepting_state = yy_current_state;
\r
752 yy_last_accepting_cpos = yy_cp;
\r
754 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
\r
756 yy_current_state = (int) yy_def[yy_current_state];
\r
757 if ( yy_current_state >= 86 )
\r
758 yy_c = yy_meta[(unsigned int) yy_c];
\r
760 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
\r
763 while ( yy_base[yy_current_state] != 142 );
\r
766 yy_act = yy_accept[yy_current_state];
\r
768 { /* have to back up */
\r
769 yy_cp = yy_last_accepting_cpos;
\r
770 yy_current_state = yy_last_accepting_state;
\r
771 yy_act = yy_accept[yy_current_state];
\r
774 YY_DO_BEFORE_ACTION;
\r
777 do_action: /* This label is used only to access EOF actions. */
\r
781 { /* beginning of action switch */
\r
782 case 0: /* must back up */
\r
783 /* undo the effects of YY_DO_BEFORE_ACTION */
\r
784 *yy_cp = yy_hold_char;
\r
785 yy_cp = yy_last_accepting_cpos;
\r
786 yy_current_state = yy_last_accepting_state;
\r
787 goto yy_find_action;
\r
792 { flex_ifq_ch+=IfqParserleng; return AND; }
\r
797 { flex_ifq_ch+=IfqParserleng; return NOT; }
\r
802 { flex_ifq_ch+=IfqParserleng; return OR; }
\r
807 { flex_ifq_ch+=IfqParserleng; return TRUE_V;}
\r
812 { flex_ifq_ch+=IfqParserleng; return FALSE_V;}
\r
817 {flex_ifq_ch+=IfqParserleng; IfqParserlval.strval = strdup(yytext); return PRED; }
\r
822 {flex_ifq_ch+=IfqParserleng; return SEMICOLON;}
\r
827 { flex_ifq_ch+=IfqParserleng; return yytext[0]; }
\r
832 { flex_ifq_ch+=IfqParserleng; return yytext[0]; }
\r
837 { flex_ifq_ch+=IfqParserleng; return yytext[0]; }
\r
843 { flex_ifq_ch+=IfqParserleng; IfqParserlval.strval = strdup(yytext); return NAME; }
\r
851 { flex_ifq_ch+=IfqParserleng; IfqParserlval.strval = strdup(yytext); return INTNUM; }
\r
856 { flex_ifq_ch+=IfqParserleng; IfqParserlval.strval = strdup(yytext); return LONGINTNUM; }
\r
869 { flex_ifq_ch+=IfqParserleng; IfqParserlval.strval = strdup(yytext); return APPROXNUM; }
\r
879 IfqParserlval.strval = strdup(IfqParsertext+1);
\r
883 unput(c); /* just peeking */
\r
885 flex_ifq_ch+=IfqParserleng;
\r
886 IfqParserlval.strval[IfqParserleng-2] = '\0';
\r
887 return STRING_TOKEN;
\r
893 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
\r
894 yy_c_buf_p = yy_cp -= 1;
\r
895 YY_DO_BEFORE_ACTION; /* set up yytext again */
\r
898 { flex_ifq_ch+=IfqParserleng; IfqParsererror("Unterminated string"); }
\r
901 /* Newline : advance the error reporting line number */
\r
902 /* and grab the next line into flex_ifq_linebuf */
\r
907 {flex_ifq_ch=0; flex_ifq_lineno++;
\r
908 strcpy(flex_ifq_linebuf,IfqParsertext+1);
\r
915 {flex_ifq_ch+=IfqParserleng; } /* white space */
\r
918 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
\r
919 yy_c_buf_p = yy_cp -= 1;
\r
920 YY_DO_BEFORE_ACTION; /* set up yytext again */
\r
923 {flex_ifq_ch+=IfqParserleng; }; /* comment */
\r
926 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
\r
927 yy_c_buf_p = yy_cp -= 1;
\r
928 YY_DO_BEFORE_ACTION; /* set up yytext again */
\r
931 {flex_ifq_ch+=IfqParserleng; }; /* comment */
\r
936 {flex_ifq_ch+=IfqParserleng; fprintf(stderr,"Warning: unknown token (ignored)\n"); IfqParsererror(yytext);}
\r
943 #line 944 "ifqlexer.cc"
\r
944 case YY_STATE_EOF(INITIAL):
\r
947 case YY_END_OF_BUFFER:
\r
949 /* Amount of text matched not including the EOB char. */
\r
950 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
\r
952 /* Undo the effects of YY_DO_BEFORE_ACTION. */
\r
953 *yy_cp = yy_hold_char;
\r
954 YY_RESTORE_YY_MORE_OFFSET
\r
956 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
\r
958 /* We're scanning a new file or input source. It's
\r
959 * possible that this happened because the user
\r
960 * just pointed yyin at a new source and called
\r
961 * yylex(). If so, then we have to assure
\r
962 * consistency between yy_current_buffer and our
\r
963 * globals. Here is the right place to do so, because
\r
964 * this is the first action (other than possibly a
\r
965 * back-up) that will match for the new input source.
\r
967 yy_n_chars = yy_current_buffer->yy_n_chars;
\r
968 yy_current_buffer->yy_input_file = yyin;
\r
969 yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
\r
972 /* Note that here we test for yy_c_buf_p "<=" to the position
\r
973 * of the first EOB in the buffer, since yy_c_buf_p will
\r
974 * already have been incremented past the NUL character
\r
975 * (since all states make transitions on EOB to the
\r
976 * end-of-buffer state). Contrast this with the test
\r
979 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
\r
980 { /* This was really a NUL. */
\r
981 yy_state_type yy_next_state;
\r
983 yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
\r
985 yy_current_state = yy_get_previous_state();
\r
987 /* Okay, we're now positioned to make the NUL
\r
988 * transition. We couldn't have
\r
989 * yy_get_previous_state() go ahead and do it
\r
990 * for us because it doesn't know how to deal
\r
991 * with the possibility of jamming (and we don't
\r
992 * want to build jamming into it because then it
\r
993 * will run more slowly).
\r
996 yy_next_state = yy_try_NUL_trans( yy_current_state );
\r
998 yy_bp = yytext_ptr + YY_MORE_ADJ;
\r
1000 if ( yy_next_state )
\r
1002 /* Consume the NUL. */
\r
1003 yy_cp = ++yy_c_buf_p;
\r
1004 yy_current_state = yy_next_state;
\r
1010 yy_cp = yy_c_buf_p;
\r
1011 goto yy_find_action;
\r
1015 else switch ( yy_get_next_buffer() )
\r
1017 case EOB_ACT_END_OF_FILE:
\r
1019 yy_did_buffer_switch_on_eof = 0;
\r
1023 /* Note: because we've taken care in
\r
1024 * yy_get_next_buffer() to have set up
\r
1025 * yytext, we can now set up
\r
1026 * yy_c_buf_p so that if some total
\r
1027 * hoser (like flex itself) wants to
\r
1028 * call the scanner after we return the
\r
1029 * YY_NULL, it'll still work - another
\r
1030 * YY_NULL will get returned.
\r
1032 yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
\r
1034 yy_act = YY_STATE_EOF(YY_START);
\r
1040 if ( ! yy_did_buffer_switch_on_eof )
\r
1046 case EOB_ACT_CONTINUE_SCAN:
\r
1048 yytext_ptr + yy_amount_of_matched_text;
\r
1050 yy_current_state = yy_get_previous_state();
\r
1052 yy_cp = yy_c_buf_p;
\r
1053 yy_bp = yytext_ptr + YY_MORE_ADJ;
\r
1056 case EOB_ACT_LAST_MATCH:
\r
1058 &yy_current_buffer->yy_ch_buf[yy_n_chars];
\r
1060 yy_current_state = yy_get_previous_state();
\r
1062 yy_cp = yy_c_buf_p;
\r
1063 yy_bp = yytext_ptr + YY_MORE_ADJ;
\r
1064 goto yy_find_action;
\r
1071 "fatal flex scanner internal error--no action found" );
\r
1072 } /* end of action switch */
\r
1073 } /* end of scanning one token */
\r
1074 } /* end of yylex */
\r
1077 /* yy_get_next_buffer - try to read in a new buffer
\r
1079 * Returns a code representing an action:
\r
1080 * EOB_ACT_LAST_MATCH -
\r
1081 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
\r
1082 * EOB_ACT_END_OF_FILE - end of file
\r
1085 static int yy_get_next_buffer()
\r
1087 register char *dest = yy_current_buffer->yy_ch_buf;
\r
1088 register char *source = yytext_ptr;
\r
1089 register int number_to_move, i;
\r
1092 if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
\r
1094 "fatal flex scanner internal error--end of buffer missed" );
\r
1096 if ( yy_current_buffer->yy_fill_buffer == 0 )
\r
1097 { /* Don't try to fill the buffer, so this is an EOF. */
\r
1098 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
\r
1100 /* We matched a single character, the EOB, so
\r
1101 * treat this as a final EOF.
\r
1103 return EOB_ACT_END_OF_FILE;
\r
1108 /* We matched some text prior to the EOB, first
\r
1111 return EOB_ACT_LAST_MATCH;
\r
1115 /* Try to read more data. */
\r
1117 /* First move last chars to start of buffer. */
\r
1118 number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
\r
1120 for ( i = 0; i < number_to_move; ++i )
\r
1121 *(dest++) = *(source++);
\r
1123 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
\r
1124 /* don't do the read, it's not guaranteed to return an EOF,
\r
1125 * just force an EOF
\r
1127 yy_current_buffer->yy_n_chars = yy_n_chars = 0;
\r
1132 yy_current_buffer->yy_buf_size - number_to_move - 1;
\r
1134 while ( num_to_read <= 0 )
\r
1135 { /* Not enough room in the buffer - grow it. */
\r
1136 #ifdef YY_USES_REJECT
\r
1138 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
\r
1141 /* just a shorter name for the current buffer */
\r
1142 YY_BUFFER_STATE b = yy_current_buffer;
\r
1144 int yy_c_buf_p_offset =
\r
1145 (int) (yy_c_buf_p - b->yy_ch_buf);
\r
1147 if ( b->yy_is_our_buffer )
\r
1149 int new_size = b->yy_buf_size * 2;
\r
1151 if ( new_size <= 0 )
\r
1152 b->yy_buf_size += b->yy_buf_size / 8;
\r
1154 b->yy_buf_size *= 2;
\r
1156 b->yy_ch_buf = (char *)
\r
1157 /* Include room in for 2 EOB chars. */
\r
1158 yy_flex_realloc( (void *) b->yy_ch_buf,
\r
1159 b->yy_buf_size + 2 );
\r
1162 /* Can't grow it, we don't own it. */
\r
1165 if ( ! b->yy_ch_buf )
\r
1167 "fatal error - scanner input buffer overflow" );
\r
1169 yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
\r
1171 num_to_read = yy_current_buffer->yy_buf_size -
\r
1172 number_to_move - 1;
\r
1176 if ( num_to_read > YY_READ_BUF_SIZE )
\r
1177 num_to_read = YY_READ_BUF_SIZE;
\r
1179 /* Read in more data. */
\r
1180 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
\r
1181 yy_n_chars, num_to_read );
\r
1183 yy_current_buffer->yy_n_chars = yy_n_chars;
\r
1186 if ( yy_n_chars == 0 )
\r
1188 if ( number_to_move == YY_MORE_ADJ )
\r
1190 ret_val = EOB_ACT_END_OF_FILE;
\r
1191 yyrestart( yyin );
\r
1196 ret_val = EOB_ACT_LAST_MATCH;
\r
1197 yy_current_buffer->yy_buffer_status =
\r
1198 YY_BUFFER_EOF_PENDING;
\r
1203 ret_val = EOB_ACT_CONTINUE_SCAN;
\r
1205 yy_n_chars += number_to_move;
\r
1206 yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
\r
1207 yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
\r
1209 yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
\r
1215 /* yy_get_previous_state - get the state just before the EOB char was reached */
\r
1217 static yy_state_type yy_get_previous_state()
\r
1219 register yy_state_type yy_current_state;
\r
1220 register char *yy_cp;
\r
1222 yy_current_state = yy_start;
\r
1224 for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
\r
1226 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
\r
1227 if ( yy_accept[yy_current_state] )
\r
1229 yy_last_accepting_state = yy_current_state;
\r
1230 yy_last_accepting_cpos = yy_cp;
\r
1232 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
\r
1234 yy_current_state = (int) yy_def[yy_current_state];
\r
1235 if ( yy_current_state >= 86 )
\r
1236 yy_c = yy_meta[(unsigned int) yy_c];
\r
1238 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
\r
1241 return yy_current_state;
\r
1245 /* yy_try_NUL_trans - try to make a transition on the NUL character
\r
1248 * next_state = yy_try_NUL_trans( current_state );
\r
1251 #ifdef YY_USE_PROTOS
\r
1252 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
\r
1254 static yy_state_type yy_try_NUL_trans( yy_current_state )
\r
1255 yy_state_type yy_current_state;
\r
1258 register int yy_is_jam;
\r
1259 register char *yy_cp = yy_c_buf_p;
\r
1261 register YY_CHAR yy_c = 1;
\r
1262 if ( yy_accept[yy_current_state] )
\r
1264 yy_last_accepting_state = yy_current_state;
\r
1265 yy_last_accepting_cpos = yy_cp;
\r
1267 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
\r
1269 yy_current_state = (int) yy_def[yy_current_state];
\r
1270 if ( yy_current_state >= 86 )
\r
1271 yy_c = yy_meta[(unsigned int) yy_c];
\r
1273 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
\r
1274 yy_is_jam = (yy_current_state == 85);
\r
1276 return yy_is_jam ? 0 : yy_current_state;
\r
1280 #ifndef YY_NO_UNPUT
\r
1281 #ifdef YY_USE_PROTOS
\r
1282 static void yyunput( int c, register char *yy_bp )
\r
1284 static void yyunput( c, yy_bp )
\r
1286 register char *yy_bp;
\r
1289 register char *yy_cp = yy_c_buf_p;
\r
1291 /* undo effects of setting up yytext */
\r
1292 *yy_cp = yy_hold_char;
\r
1294 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
\r
1295 { /* need to shift things up to make room */
\r
1296 /* +2 for EOB chars. */
\r
1297 register int number_to_move = yy_n_chars + 2;
\r
1298 register char *dest = &yy_current_buffer->yy_ch_buf[
\r
1299 yy_current_buffer->yy_buf_size + 2];
\r
1300 register char *source =
\r
1301 &yy_current_buffer->yy_ch_buf[number_to_move];
\r
1303 while ( source > yy_current_buffer->yy_ch_buf )
\r
1304 *--dest = *--source;
\r
1306 yy_cp += (int) (dest - source);
\r
1307 yy_bp += (int) (dest - source);
\r
1308 yy_current_buffer->yy_n_chars =
\r
1309 yy_n_chars = yy_current_buffer->yy_buf_size;
\r
1311 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
\r
1312 YY_FATAL_ERROR( "flex scanner push-back overflow" );
\r
1315 *--yy_cp = (char) c;
\r
1318 yytext_ptr = yy_bp;
\r
1319 yy_hold_char = *yy_cp;
\r
1320 yy_c_buf_p = yy_cp;
\r
1322 #endif /* ifndef YY_NO_UNPUT */
\r
1325 #ifndef YY_NO_INPUT
\r
1326 #ifdef __cplusplus
\r
1327 static int yyinput()
\r
1329 static int input()
\r
1334 *yy_c_buf_p = yy_hold_char;
\r
1336 if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
\r
1338 /* yy_c_buf_p now points to the character we want to return.
\r
1339 * If this occurs *before* the EOB characters, then it's a
\r
1340 * valid NUL; if not, then we've hit the end of the buffer.
\r
1342 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
\r
1343 /* This was really a NUL. */
\r
1344 *yy_c_buf_p = '\0';
\r
1347 { /* need more input */
\r
1348 int offset = yy_c_buf_p - yytext_ptr;
\r
1351 switch ( yy_get_next_buffer() )
\r
1353 case EOB_ACT_LAST_MATCH:
\r
1354 /* This happens because yy_g_n_b()
\r
1355 * sees that we've accumulated a
\r
1356 * token and flags that we need to
\r
1357 * try matching the token before
\r
1358 * proceeding. But for input(),
\r
1359 * there's no matching to consider.
\r
1360 * So convert the EOB_ACT_LAST_MATCH
\r
1361 * to EOB_ACT_END_OF_FILE.
\r
1364 /* Reset buffer status. */
\r
1365 yyrestart( yyin );
\r
1367 /* fall through */
\r
1369 case EOB_ACT_END_OF_FILE:
\r
1374 if ( ! yy_did_buffer_switch_on_eof )
\r
1376 #ifdef __cplusplus
\r
1383 case EOB_ACT_CONTINUE_SCAN:
\r
1384 yy_c_buf_p = yytext_ptr + offset;
\r
1390 c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */
\r
1391 *yy_c_buf_p = '\0'; /* preserve yytext */
\r
1392 yy_hold_char = *++yy_c_buf_p;
\r
1397 #endif /* YY_NO_INPUT */
\r
1399 #ifdef YY_USE_PROTOS
\r
1400 void yyrestart( FILE *input_file )
\r
1402 void yyrestart( input_file )
\r
1406 if ( ! yy_current_buffer )
\r
1407 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
\r
1409 yy_init_buffer( yy_current_buffer, input_file );
\r
1410 yy_load_buffer_state();
\r
1414 #ifdef YY_USE_PROTOS
\r
1415 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
\r
1417 void yy_switch_to_buffer( new_buffer )
\r
1418 YY_BUFFER_STATE new_buffer;
\r
1421 if ( yy_current_buffer == new_buffer )
\r
1424 if ( yy_current_buffer )
\r
1426 /* Flush out information for old buffer. */
\r
1427 *yy_c_buf_p = yy_hold_char;
\r
1428 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
\r
1429 yy_current_buffer->yy_n_chars = yy_n_chars;
\r
1432 yy_current_buffer = new_buffer;
\r
1433 yy_load_buffer_state();
\r
1435 /* We don't actually know whether we did this switch during
\r
1436 * EOF (yywrap()) processing, but the only time this flag
\r
1437 * is looked at is after yywrap() is called, so it's safe
\r
1438 * to go ahead and always set it.
\r
1440 yy_did_buffer_switch_on_eof = 1;
\r
1444 #ifdef YY_USE_PROTOS
\r
1445 void yy_load_buffer_state( void )
\r
1447 void yy_load_buffer_state()
\r
1450 yy_n_chars = yy_current_buffer->yy_n_chars;
\r
1451 yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
\r
1452 yyin = yy_current_buffer->yy_input_file;
\r
1453 yy_hold_char = *yy_c_buf_p;
\r
1457 #ifdef YY_USE_PROTOS
\r
1458 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
\r
1460 YY_BUFFER_STATE yy_create_buffer( file, size )
\r
1465 YY_BUFFER_STATE b;
\r
1467 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
\r
1469 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
\r
1471 b->yy_buf_size = size;
\r
1473 /* yy_ch_buf has to be 2 characters longer than the size given because
\r
1474 * we need to put in 2 end-of-buffer characters.
\r
1476 b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
\r
1477 if ( ! b->yy_ch_buf )
\r
1478 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
\r
1480 b->yy_is_our_buffer = 1;
\r
1482 yy_init_buffer( b, file );
\r
1488 #ifdef YY_USE_PROTOS
\r
1489 void yy_delete_buffer( YY_BUFFER_STATE b )
\r
1491 void yy_delete_buffer( b )
\r
1492 YY_BUFFER_STATE b;
\r
1498 if ( b == yy_current_buffer )
\r
1499 yy_current_buffer = (YY_BUFFER_STATE) 0;
\r
1501 if ( b->yy_is_our_buffer )
\r
1502 yy_flex_free( (void *) b->yy_ch_buf );
\r
1504 yy_flex_free( (void *) b );
\r
1509 #ifdef YY_USE_PROTOS
\r
1510 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
\r
1512 void yy_init_buffer( b, file )
\r
1513 YY_BUFFER_STATE b;
\r
1519 yy_flush_buffer( b );
\r
1521 b->yy_input_file = file;
\r
1522 b->yy_fill_buffer = 1;
\r
1524 #if YY_ALWAYS_INTERACTIVE
\r
1525 b->yy_is_interactive = 1;
\r
1527 #if YY_NEVER_INTERACTIVE
\r
1528 b->yy_is_interactive = 0;
\r
1530 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
\r
1536 #ifdef YY_USE_PROTOS
\r
1537 void yy_flush_buffer( YY_BUFFER_STATE b )
\r
1539 void yy_flush_buffer( b )
\r
1540 YY_BUFFER_STATE b;
\r
1547 b->yy_n_chars = 0;
\r
1549 /* We always need two end-of-buffer characters. The first causes
\r
1550 * a transition to the end-of-buffer state. The second causes
\r
1551 * a jam in that state.
\r
1553 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
\r
1554 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
\r
1556 b->yy_buf_pos = &b->yy_ch_buf[0];
\r
1559 b->yy_buffer_status = YY_BUFFER_NEW;
\r
1561 if ( b == yy_current_buffer )
\r
1562 yy_load_buffer_state();
\r
1566 #ifndef YY_NO_SCAN_BUFFER
\r
1567 #ifdef YY_USE_PROTOS
\r
1568 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
\r
1570 YY_BUFFER_STATE yy_scan_buffer( base, size )
\r
1575 YY_BUFFER_STATE b;
\r
1578 base[size-2] != YY_END_OF_BUFFER_CHAR ||
\r
1579 base[size-1] != YY_END_OF_BUFFER_CHAR )
\r
1580 /* They forgot to leave room for the EOB's. */
\r
1583 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
\r
1585 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
\r
1587 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
\r
1588 b->yy_buf_pos = b->yy_ch_buf = base;
\r
1589 b->yy_is_our_buffer = 0;
\r
1590 b->yy_input_file = 0;
\r
1591 b->yy_n_chars = b->yy_buf_size;
\r
1592 b->yy_is_interactive = 0;
\r
1594 b->yy_fill_buffer = 0;
\r
1595 b->yy_buffer_status = YY_BUFFER_NEW;
\r
1597 yy_switch_to_buffer( b );
\r
1604 #ifndef YY_NO_SCAN_STRING
\r
1605 #ifdef YY_USE_PROTOS
\r
1606 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
\r
1608 YY_BUFFER_STATE yy_scan_string( yy_str )
\r
1609 yyconst char *yy_str;
\r
1613 for ( len = 0; yy_str[len]; ++len )
\r
1616 return yy_scan_bytes( yy_str, len );
\r
1621 #ifndef YY_NO_SCAN_BYTES
\r
1622 #ifdef YY_USE_PROTOS
\r
1623 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
\r
1625 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
\r
1626 yyconst char *bytes;
\r
1630 YY_BUFFER_STATE b;
\r
1635 /* Get memory for full buffer, including space for trailing EOB's. */
\r
1637 buf = (char *) yy_flex_alloc( n );
\r
1639 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
\r
1641 for ( i = 0; i < len; ++i )
\r
1642 buf[i] = bytes[i];
\r
1644 buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
\r
1646 b = yy_scan_buffer( buf, n );
\r
1648 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
\r
1650 /* It's okay to grow etc. this buffer, and we should throw it
\r
1651 * away when we're done.
\r
1653 b->yy_is_our_buffer = 1;
\r
1660 #ifndef YY_NO_PUSH_STATE
\r
1661 #ifdef YY_USE_PROTOS
\r
1662 static void yy_push_state( int new_state )
\r
1664 static void yy_push_state( new_state )
\r
1668 if ( yy_start_stack_ptr >= yy_start_stack_depth )
\r
1670 yy_size_t new_size;
\r
1672 yy_start_stack_depth += YY_START_STACK_INCR;
\r
1673 new_size = yy_start_stack_depth * sizeof( int );
\r
1675 if ( ! yy_start_stack )
\r
1676 yy_start_stack = (int *) yy_flex_alloc( new_size );
\r
1679 yy_start_stack = (int *) yy_flex_realloc(
\r
1680 (void *) yy_start_stack, new_size );
\r
1682 if ( ! yy_start_stack )
\r
1684 "out of memory expanding start-condition stack" );
\r
1687 yy_start_stack[yy_start_stack_ptr++] = YY_START;
\r
1694 #ifndef YY_NO_POP_STATE
\r
1695 static void yy_pop_state()
\r
1697 if ( --yy_start_stack_ptr < 0 )
\r
1698 YY_FATAL_ERROR( "start-condition stack underflow" );
\r
1700 BEGIN(yy_start_stack[yy_start_stack_ptr]);
\r
1705 #ifndef YY_NO_TOP_STATE
\r
1706 static int yy_top_state()
\r
1708 return yy_start_stack[yy_start_stack_ptr - 1];
\r
1712 #ifndef YY_EXIT_FAILURE
\r
1713 #define YY_EXIT_FAILURE 2
\r
1716 #ifdef YY_USE_PROTOS
\r
1717 static void yy_fatal_error( yyconst char msg[] )
\r
1719 static void yy_fatal_error( msg )
\r
1723 (void) fprintf( stderr, "%s\n", msg );
\r
1724 exit( YY_EXIT_FAILURE );
\r
1729 /* Redefine yyless() so it works in section 3 code. */
\r
1732 #define yyless(n) \
\r
1735 /* Undo effects of setting up yytext. */ \
\r
1736 yytext[yyleng] = yy_hold_char; \
\r
1737 yy_c_buf_p = yytext + n; \
\r
1738 yy_hold_char = *yy_c_buf_p; \
\r
1739 *yy_c_buf_p = '\0'; \
\r
1745 /* Internal utility routines. */
\r
1747 #ifndef yytext_ptr
\r
1748 #ifdef YY_USE_PROTOS
\r
1749 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
\r
1751 static void yy_flex_strncpy( s1, s2, n )
\r
1758 for ( i = 0; i < n; ++i )
\r
1763 #ifdef YY_NEED_STRLEN
\r
1764 #ifdef YY_USE_PROTOS
\r
1765 static int yy_flex_strlen( yyconst char *s )
\r
1767 static int yy_flex_strlen( s )
\r
1772 for ( n = 0; s[n]; ++n )
\r
1780 #ifdef YY_USE_PROTOS
\r
1781 static void *yy_flex_alloc( yy_size_t size )
\r
1783 static void *yy_flex_alloc( size )
\r
1787 return (void *) malloc( size );
\r
1790 #ifdef YY_USE_PROTOS
\r
1791 static void *yy_flex_realloc( void *ptr, yy_size_t size )
\r
1793 static void *yy_flex_realloc( ptr, size )
\r
1798 /* The cast to (char *) in the following accommodates both
\r
1799 * implementations that use char* generic pointers, and those
\r
1800 * that use void* generic pointers. It works with the latter
\r
1801 * because both ANSI C and C++ allow castless assignment from
\r
1802 * any pointer type to void*, and deal with argument conversions
\r
1803 * as though doing an assignment.
\r
1805 return (void *) realloc( (char *) ptr, size );
\r
1808 #ifdef YY_USE_PROTOS
\r
1809 static void yy_flex_free( void *ptr )
\r
1811 static void yy_flex_free( ptr )
\r
1828 int my_IfqParser_yyinput(char *buf, int max_size){
\r
1832 if(flex_ifq_stringinput != NULL){
\r
1833 while(c<max_size){
\r
1834 if(flex_ifq_stringinput[flex_ifq_stringinput_ptr] != '\0'){
\r
1835 buf[c++] = flex_ifq_stringinput[flex_ifq_stringinput_ptr++];
\r
1843 if(flex_ifq_fileinput != NULL){
\r
1844 while(c < max_size){
\r
1845 inchar = getc(flex_ifq_fileinput);
\r
1846 if(inchar != EOF){
\r
1847 buf[c++] = inchar;
\r
1858 void IfqParser_setfileinput(FILE *f){
\r
1859 IfqParserrestart(NULL);
\r
1861 flex_ifq_fileinput = f;
\r
1862 flex_ifq_stringinput = NULL;
\r
1863 flex_ifq_lineno = 1;
\r
1867 void IfqParser_setstringinput(char *s){
\r
1868 IfqParserrestart(NULL);
\r
1870 flex_ifq_fileinput = NULL;
\r
1871 flex_ifq_stringinput = s;
\r
1872 flex_ifq_stringinput_ptr = 0;
\r
1873 flex_ifq_lineno = 1;
\r