1 #define yy_create_buffer NicParser_create_buffer
\r
2 #define yy_delete_buffer NicParser_delete_buffer
\r
3 #define yy_scan_buffer NicParser_scan_buffer
\r
4 #define yy_scan_string NicParser_scan_string
\r
5 #define yy_scan_bytes NicParser_scan_bytes
\r
6 #define yy_flex_debug NicParser_flex_debug
\r
7 #define yy_init_buffer NicParser_init_buffer
\r
8 #define yy_flush_buffer NicParser_flush_buffer
\r
9 #define yy_load_buffer_state NicParser_load_buffer_state
\r
10 #define yy_switch_to_buffer NicParser_switch_to_buffer
\r
11 #define yyin NicParserin
\r
12 #define yyleng NicParserleng
\r
13 #define yylex NicParserlex
\r
14 #define yyout NicParserout
\r
15 #define yyrestart NicParserrestart
\r
16 #define yytext NicParsertext
\r
18 #line 19 "niclexer.cc"
\r
19 /* A lexical scanner generated by flex */
\r
21 /* Scanner skeleton version:
\r
22 * $Header: /cvsroot/gscpv4/src/ftacmp/niclexer.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 16
\r
308 #define YY_END_OF_BUFFER 17
\r
309 static yyconst short int yy_accept[85] =
\r
311 0, 0, 17, 15, 12, 11, 15, 7, 15, 15,
\r
312 8, 8, 8, 8, 8, 8, 8, 12, 11, 0,
\r
313 10, 9, 0, 0, 8, 8, 8, 8, 8, 8,
\r
314 8, 0, 13, 0, 14, 8, 8, 8, 8, 8,
\r
315 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
\r
316 8, 8, 8, 8, 8, 8, 8, 3, 8, 8,
\r
317 8, 8, 8, 8, 8, 8, 8, 1, 8, 8,
\r
318 8, 8, 8, 8, 2, 8, 4, 5, 8, 8,
\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, 1, 1, 1, 1, 1, 1, 4, 1,
\r
328 1, 1, 1, 5, 6, 1, 7, 8, 8, 8,
\r
329 8, 8, 8, 8, 8, 8, 8, 9, 5, 1,
\r
330 5, 1, 1, 1, 10, 11, 12, 13, 14, 15,
\r
331 16, 17, 18, 17, 17, 19, 20, 21, 22, 23,
\r
332 17, 24, 25, 26, 27, 17, 17, 17, 28, 17,
\r
333 1, 1, 1, 1, 29, 1, 17, 17, 17, 17,
\r
335 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
\r
336 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,
\r
337 17, 17, 1, 1, 1, 1, 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[30] =
\r
356 1, 1, 2, 1, 1, 1, 1, 3, 1, 3,
\r
357 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
\r
358 3, 3, 3, 3, 3, 3, 3, 3, 3
\r
361 static yyconst short int yy_base[90] =
\r
363 0, 0, 108, 109, 105, 0, 27, 109, 100, 98,
\r
364 0, 86, 76, 84, 78, 72, 78, 96, 0, 29,
\r
365 109, 109, 94, 93, 0, 74, 73, 68, 66, 68,
\r
366 80, 86, 109, 85, 109, 77, 74, 60, 66, 69,
\r
367 58, 57, 54, 61, 56, 52, 48, 47, 56, 52,
\r
368 51, 62, 41, 40, 46, 51, 41, 109, 43, 42,
\r
369 42, 33, 52, 37, 36, 33, 42, 109, 31, 30,
\r
370 45, 35, 43, 42, 109, 36, 109, 109, 30, 35,
\r
371 22, 37, 109, 109, 33, 36, 32, 39, 42
\r
374 static yyconst short int yy_def[90] =
\r
376 84, 1, 84, 84, 84, 85, 86, 84, 84, 84,
\r
377 87, 87, 87, 87, 87, 87, 87, 84, 85, 86,
\r
378 84, 84, 88, 89, 87, 87, 87, 87, 87, 87,
\r
379 87, 88, 84, 89, 84, 87, 87, 87, 87, 87,
\r
380 87, 87, 87, 87, 87, 87, 87, 87, 87, 87,
\r
381 87, 87, 87, 87, 87, 87, 87, 84, 87, 87,
\r
382 87, 87, 87, 87, 87, 87, 87, 84, 87, 87,
\r
383 87, 87, 87, 87, 84, 87, 84, 84, 87, 87,
\r
384 87, 87, 84, 0, 84, 84, 84, 84, 84
\r
387 static yyconst short int yy_nxt[139] =
\r
389 4, 5, 6, 7, 8, 9, 10, 4, 4, 11,
\r
390 12, 11, 11, 11, 13, 11, 11, 11, 11, 14,
\r
391 11, 15, 11, 11, 11, 16, 17, 11, 11, 21,
\r
392 22, 21, 22, 19, 25, 19, 20, 20, 20, 32,
\r
393 32, 32, 34, 34, 34, 83, 82, 81, 80, 79,
\r
394 78, 77, 76, 75, 74, 73, 72, 71, 70, 69,
\r
395 68, 67, 66, 65, 64, 63, 62, 61, 60, 59,
\r
396 58, 57, 56, 55, 54, 53, 52, 51, 50, 49,
\r
397 48, 47, 46, 45, 44, 43, 42, 35, 33, 41,
\r
398 40, 39, 38, 37, 36, 35, 33, 18, 31, 30,
\r
400 29, 28, 27, 26, 24, 23, 18, 84, 3, 84,
\r
401 84, 84, 84, 84, 84, 84, 84, 84, 84, 84,
\r
402 84, 84, 84, 84, 84, 84, 84, 84, 84, 84,
\r
403 84, 84, 84, 84, 84, 84, 84, 84
\r
406 static yyconst short int yy_chk[139] =
\r
408 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
\r
409 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
\r
410 1, 1, 1, 1, 1, 1, 1, 1, 1, 7,
\r
411 7, 20, 20, 85, 87, 85, 86, 86, 86, 88,
\r
412 88, 88, 89, 89, 89, 82, 81, 80, 79, 76,
\r
413 74, 73, 72, 71, 70, 69, 67, 66, 65, 64,
\r
414 63, 62, 61, 60, 59, 57, 56, 55, 54, 53,
\r
415 52, 51, 50, 49, 48, 47, 46, 45, 44, 43,
\r
416 42, 41, 40, 39, 38, 37, 36, 34, 32, 31,
\r
417 30, 29, 28, 27, 26, 24, 23, 18, 17, 16,
\r
419 15, 14, 13, 12, 10, 9, 5, 3, 84, 84,
\r
420 84, 84, 84, 84, 84, 84, 84, 84, 84, 84,
\r
421 84, 84, 84, 84, 84, 84, 84, 84, 84, 84,
\r
422 84, 84, 84, 84, 84, 84, 84, 84
\r
425 static yy_state_type yy_last_accepting_state;
\r
426 static char *yy_last_accepting_cpos;
\r
428 /* The intent behind this definition is that it'll catch
\r
429 * any uses of REJECT which flex missed.
\r
431 #define REJECT reject_used_but_not_detected
\r
432 static int yy_more_flag = 0;
\r
433 static int yy_more_len = 0;
\r
434 #define yymore() (yy_more_flag = 1)
\r
435 #define YY_MORE_ADJ yy_more_len
\r
436 #define YY_RESTORE_YY_MORE_OFFSET
\r
442 flex -PNicParser -oniclexer.cc nic.l
\r
447 * AT&T lex can't handle this lexer due to lex bugs. It works with flex
\r
448 * 2.3.7, pclex 2.0.5, and MKS lex 3.1a.
\r
451 #include "nic_def.h"
\r
452 #include <string.h>
\r
456 #include "nic.tab.cc.h"
\r
459 Some includes that flex doesn't include as standard,
\r
460 but which are needed.
\r
463 #include <stdlib.h>
\r
464 #include <string.h>
\r
467 // Prevent flex from defining yywrap as extern "C"
\r
469 #define YY_SKIP_YYWRAP
\r
471 /* No lex lib, supply the yywrap fcn. that normally resides there
\r
474 int NicParserwrap(){return(1);}
\r
476 extern int NicParserdebug;
\r
480 These variables are used for error reporting:
\r
481 flex_nic_lineno : the line currently being parsed when the error occurs.
\r
482 flex_nic_ch : the character on the line where the error occurs
\r
483 flex_nic_linebuf : store the line for reporting.
\r
485 NOTE : 1) the fixed size flex_nic_linebuf buffer is dangerous.
\r
486 2) You might get pointed to a place shortly after
\r
487 where the syntax error occurs. It is close enough
\r
491 int flex_nic_lineno = 1;
\r
492 int flex_nic_ch = 0;
\r
493 char flex_nic_linebuf[20000];
\r
495 char *flex_nic_stringinput = NULL;
\r
496 int flex_nic_stringinput_ptr = 0;
\r
497 FILE *flex_nic_fileinput = NULL;
\r
498 int my_NicParser_yyinput(char *buf, int max_size);
\r
502 void NicParsererror(char *s){
\r
504 fprintf(stderr,"On line %d, char %d: %s (token %s):\n%s\n",
\r
505 flex_nic_lineno, flex_nic_ch, s, NicParsertext, flex_nic_linebuf );
\r
506 for(i=0;i<flex_nic_ch;i++){
\r
507 if(flex_nic_linebuf[i] == '\t'){
\r
508 fprintf(stderr,"\t");
\r
510 fprintf(stderr," ");
\r
513 fprintf(stderr,"^\n");
\r
514 // fprintf(stderr,"%*s\n",1+flex_nic_ch,"^");
\r
518 #define YY_INPUT(b, r, ms) (r = my_NicParser_yyinput(b,ms))
\r
520 /* MKS needs the next line to increase the NFA table */
\r
521 #line 522 "niclexer.cc"
\r
523 /* Macros after this point can all be overridden by user definitions in
\r
527 #ifndef YY_SKIP_YYWRAP
\r
529 extern "C" int yywrap YY_PROTO(( void ));
\r
531 extern int yywrap YY_PROTO(( void ));
\r
535 #ifndef YY_NO_UNPUT
\r
536 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
\r
540 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
\r
543 #ifdef YY_NEED_STRLEN
\r
544 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
\r
547 #ifndef YY_NO_INPUT
\r
549 static int yyinput YY_PROTO(( void ));
\r
551 static int input YY_PROTO(( void ));
\r
556 static int yy_start_stack_ptr = 0;
\r
557 static int yy_start_stack_depth = 0;
\r
558 static int *yy_start_stack = 0;
\r
559 #ifndef YY_NO_PUSH_STATE
\r
560 static void yy_push_state YY_PROTO(( int new_state ));
\r
562 #ifndef YY_NO_POP_STATE
\r
563 static void yy_pop_state YY_PROTO(( void ));
\r
565 #ifndef YY_NO_TOP_STATE
\r
566 static int yy_top_state YY_PROTO(( void ));
\r
570 #define YY_NO_PUSH_STATE 1
\r
571 #define YY_NO_POP_STATE 1
\r
572 #define YY_NO_TOP_STATE 1
\r
575 #ifdef YY_MALLOC_DECL
\r
579 #ifndef __cplusplus
\r
580 #include <stdlib.h>
\r
583 /* Just try to get by without declaring the routines. This will fail
\r
584 * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
\r
585 * or sizeof(void*) != sizeof(int).
\r
590 /* Amount of stuff to slurp up with each read. */
\r
591 #ifndef YY_READ_BUF_SIZE
\r
592 #define YY_READ_BUF_SIZE 8192
\r
595 /* Copy whatever the last rule matched to the standard output. */
\r
598 /* This used to be an fputs(), but since the string might contain NUL's,
\r
599 * we now use fwrite().
\r
601 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
\r
604 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
\r
605 * is returned in "result".
\r
608 #define YY_INPUT(buf,result,max_size) \
\r
609 if ( yy_current_buffer->yy_is_interactive ) \
\r
612 for ( n = 0; n < max_size && \
\r
613 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
\r
614 buf[n] = (char) c; \
\r
616 buf[n++] = (char) c; \
\r
617 if ( c == EOF && ferror( yyin ) ) \
\r
618 YY_FATAL_ERROR( "input in flex scanner failed" ); \
\r
621 else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
\r
622 && ferror( yyin ) ) \
\r
623 YY_FATAL_ERROR( "input in flex scanner failed" );
\r
626 /* No semi-colon after return; correct usage is to write "yyterminate();" -
\r
627 * we don't want an extra ';' after the "return" because that will cause
\r
628 * some compilers to complain about unreachable statements.
\r
630 #ifndef yyterminate
\r
631 #define yyterminate() return YY_NULL
\r
634 /* Number of entries by which start-condition stack grows. */
\r
635 #ifndef YY_START_STACK_INCR
\r
636 #define YY_START_STACK_INCR 25
\r
639 /* Report a fatal error. */
\r
640 #ifndef YY_FATAL_ERROR
\r
641 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
\r
644 /* Default declaration of generated scanner - a define so the user can
\r
645 * easily add parameters.
\r
648 #define YY_DECL int yylex YY_PROTO(( void ))
\r
651 /* Code executed at the beginning of each rule, after yytext and yyleng
\r
652 * have been set up.
\r
654 #ifndef YY_USER_ACTION
\r
655 #define YY_USER_ACTION
\r
658 /* Code executed at the end of each rule. */
\r
660 #define YY_BREAK break;
\r
663 #define YY_RULE_SETUP \
\r
668 register yy_state_type yy_current_state;
\r
669 register char *yy_cp = NULL, *yy_bp = NULL;
\r
670 register int yy_act;
\r
675 /* literal keyword tokens */
\r
678 The actions associated with each text token are to
\r
679 keep track of the current location (for syntax error reporting)
\r
680 and to report any necessary info to the emf.y parse tree builder
\r
682 Its likely that there are a number of omissions, inconsistencies
\r
683 (some keywords do not need to be in caps), and relics
\r
684 (keywords such as BETWEEN, INDICATOR, etc., are not used
\r
686 This parser is somewhat of a work in progress.
\r
689 /* Query keywords */
\r
691 #line 692 "niclexer.cc"
\r
697 #ifdef YY_USER_INIT
\r
702 yy_start = 1; /* first start state */
\r
710 if ( ! yy_current_buffer )
\r
711 yy_current_buffer =
\r
712 yy_create_buffer( yyin, YY_BUF_SIZE );
\r
714 yy_load_buffer_state();
\r
717 while ( 1 ) /* loops until end-of-file is reached */
\r
720 if ( yy_more_flag )
\r
722 yy_more_len = yy_c_buf_p - yytext_ptr;
\r
725 yy_cp = yy_c_buf_p;
\r
727 /* Support of yytext. */
\r
728 *yy_cp = yy_hold_char;
\r
730 /* yy_bp points to the position in yy_ch_buf of the start of
\r
735 yy_current_state = yy_start;
\r
739 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
\r
740 if ( yy_accept[yy_current_state] )
\r
742 yy_last_accepting_state = yy_current_state;
\r
743 yy_last_accepting_cpos = yy_cp;
\r
745 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
\r
747 yy_current_state = (int) yy_def[yy_current_state];
\r
748 if ( yy_current_state >= 85 )
\r
749 yy_c = yy_meta[(unsigned int) yy_c];
\r
751 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
\r
754 while ( yy_base[yy_current_state] != 109 );
\r
757 yy_act = yy_accept[yy_current_state];
\r
759 { /* have to back up */
\r
760 yy_cp = yy_last_accepting_cpos;
\r
761 yy_current_state = yy_last_accepting_state;
\r
762 yy_act = yy_accept[yy_current_state];
\r
765 YY_DO_BEFORE_ACTION;
\r
768 do_action: /* This label is used only to access EOF actions. */
\r
772 { /* beginning of action switch */
\r
773 case 0: /* must back up */
\r
774 /* undo the effects of YY_DO_BEFORE_ACTION */
\r
775 *yy_cp = yy_hold_char;
\r
776 yy_cp = yy_last_accepting_cpos;
\r
777 yy_current_state = yy_last_accepting_state;
\r
778 goto yy_find_action;
\r
783 { flex_nic_ch+=NicParserleng; return OPTIONS; }
\r
788 { flex_nic_ch+=NicParserleng; return FUNC; }
\r
793 { flex_nic_ch+=NicParserleng; return TYPES; }
\r
798 { flex_nic_ch+=NicParserleng; return UNARY_OPS; }
\r
803 { flex_nic_ch+=NicParserleng; return BINARY_OPS; }
\r
808 { flex_nic_ch+=NicParserleng; return FIELDS; }
\r
813 { flex_nic_ch+=NicParserleng; return yytext[0]; }
\r
819 { flex_nic_ch+=NicParserleng; NicParserlval.strval = strdup(yytext); return NAME; }
\r
829 NicParserlval.strval = strdup(NicParsertext+1);
\r
833 unput(c); /* just peeking */
\r
835 flex_nic_ch+=NicParserleng;
\r
836 NicParserlval.strval[NicParserleng-2] = '\0';
\r
837 return STRING_TOKEN;
\r
843 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
\r
844 yy_c_buf_p = yy_cp -= 1;
\r
845 YY_DO_BEFORE_ACTION; /* set up yytext again */
\r
848 { flex_nic_ch+=NicParserleng; NicParsererror("Unterminated string"); }
\r
851 /* Newline : advance the error reporting line number */
\r
852 /* and grab the next line into flex_nic_linebuf */
\r
857 {flex_nic_ch=0; flex_nic_lineno++;
\r
858 strcpy(flex_nic_linebuf,NicParsertext+1);
\r
865 {flex_nic_ch+=NicParserleng; } /* white space */
\r
868 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
\r
869 yy_c_buf_p = yy_cp -= 1;
\r
870 YY_DO_BEFORE_ACTION; /* set up yytext again */
\r
873 {flex_nic_ch+=NicParserleng; }; /* comment */
\r
876 *yy_cp = yy_hold_char; /* undo effects of setting up yytext */
\r
877 yy_c_buf_p = yy_cp -= 1;
\r
878 YY_DO_BEFORE_ACTION; /* set up yytext again */
\r
881 {flex_nic_ch+=NicParserleng; }; /* comment */
\r
886 {flex_nic_ch+=NicParserleng; fprintf(stderr,"Warning: unknown token (ignored)\n"); NicParsererror(yytext);}
\r
893 #line 894 "niclexer.cc"
\r
894 case YY_STATE_EOF(INITIAL):
\r
897 case YY_END_OF_BUFFER:
\r
899 /* Amount of text matched not including the EOB char. */
\r
900 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
\r
902 /* Undo the effects of YY_DO_BEFORE_ACTION. */
\r
903 *yy_cp = yy_hold_char;
\r
904 YY_RESTORE_YY_MORE_OFFSET
\r
906 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
\r
908 /* We're scanning a new file or input source. It's
\r
909 * possible that this happened because the user
\r
910 * just pointed yyin at a new source and called
\r
911 * yylex(). If so, then we have to assure
\r
912 * consistency between yy_current_buffer and our
\r
913 * globals. Here is the right place to do so, because
\r
914 * this is the first action (other than possibly a
\r
915 * back-up) that will match for the new input source.
\r
917 yy_n_chars = yy_current_buffer->yy_n_chars;
\r
918 yy_current_buffer->yy_input_file = yyin;
\r
919 yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
\r
922 /* Note that here we test for yy_c_buf_p "<=" to the position
\r
923 * of the first EOB in the buffer, since yy_c_buf_p will
\r
924 * already have been incremented past the NUL character
\r
925 * (since all states make transitions on EOB to the
\r
926 * end-of-buffer state). Contrast this with the test
\r
929 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
\r
930 { /* This was really a NUL. */
\r
931 yy_state_type yy_next_state;
\r
933 yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
\r
935 yy_current_state = yy_get_previous_state();
\r
937 /* Okay, we're now positioned to make the NUL
\r
938 * transition. We couldn't have
\r
939 * yy_get_previous_state() go ahead and do it
\r
940 * for us because it doesn't know how to deal
\r
941 * with the possibility of jamming (and we don't
\r
942 * want to build jamming into it because then it
\r
943 * will run more slowly).
\r
946 yy_next_state = yy_try_NUL_trans( yy_current_state );
\r
948 yy_bp = yytext_ptr + YY_MORE_ADJ;
\r
950 if ( yy_next_state )
\r
952 /* Consume the NUL. */
\r
953 yy_cp = ++yy_c_buf_p;
\r
954 yy_current_state = yy_next_state;
\r
960 yy_cp = yy_c_buf_p;
\r
961 goto yy_find_action;
\r
965 else switch ( yy_get_next_buffer() )
\r
967 case EOB_ACT_END_OF_FILE:
\r
969 yy_did_buffer_switch_on_eof = 0;
\r
973 /* Note: because we've taken care in
\r
974 * yy_get_next_buffer() to have set up
\r
975 * yytext, we can now set up
\r
976 * yy_c_buf_p so that if some total
\r
977 * hoser (like flex itself) wants to
\r
978 * call the scanner after we return the
\r
979 * YY_NULL, it'll still work - another
\r
980 * YY_NULL will get returned.
\r
982 yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
\r
984 yy_act = YY_STATE_EOF(YY_START);
\r
990 if ( ! yy_did_buffer_switch_on_eof )
\r
996 case EOB_ACT_CONTINUE_SCAN:
\r
998 yytext_ptr + yy_amount_of_matched_text;
\r
1000 yy_current_state = yy_get_previous_state();
\r
1002 yy_cp = yy_c_buf_p;
\r
1003 yy_bp = yytext_ptr + YY_MORE_ADJ;
\r
1006 case EOB_ACT_LAST_MATCH:
\r
1008 &yy_current_buffer->yy_ch_buf[yy_n_chars];
\r
1010 yy_current_state = yy_get_previous_state();
\r
1012 yy_cp = yy_c_buf_p;
\r
1013 yy_bp = yytext_ptr + YY_MORE_ADJ;
\r
1014 goto yy_find_action;
\r
1021 "fatal flex scanner internal error--no action found" );
\r
1022 } /* end of action switch */
\r
1023 } /* end of scanning one token */
\r
1024 } /* end of yylex */
\r
1027 /* yy_get_next_buffer - try to read in a new buffer
\r
1029 * Returns a code representing an action:
\r
1030 * EOB_ACT_LAST_MATCH -
\r
1031 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
\r
1032 * EOB_ACT_END_OF_FILE - end of file
\r
1035 static int yy_get_next_buffer()
\r
1037 register char *dest = yy_current_buffer->yy_ch_buf;
\r
1038 register char *source = yytext_ptr;
\r
1039 register int number_to_move, i;
\r
1042 if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
\r
1044 "fatal flex scanner internal error--end of buffer missed" );
\r
1046 if ( yy_current_buffer->yy_fill_buffer == 0 )
\r
1047 { /* Don't try to fill the buffer, so this is an EOF. */
\r
1048 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
\r
1050 /* We matched a single character, the EOB, so
\r
1051 * treat this as a final EOF.
\r
1053 return EOB_ACT_END_OF_FILE;
\r
1058 /* We matched some text prior to the EOB, first
\r
1061 return EOB_ACT_LAST_MATCH;
\r
1065 /* Try to read more data. */
\r
1067 /* First move last chars to start of buffer. */
\r
1068 number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
\r
1070 for ( i = 0; i < number_to_move; ++i )
\r
1071 *(dest++) = *(source++);
\r
1073 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
\r
1074 /* don't do the read, it's not guaranteed to return an EOF,
\r
1075 * just force an EOF
\r
1077 yy_current_buffer->yy_n_chars = yy_n_chars = 0;
\r
1082 yy_current_buffer->yy_buf_size - number_to_move - 1;
\r
1084 while ( num_to_read <= 0 )
\r
1085 { /* Not enough room in the buffer - grow it. */
\r
1086 #ifdef YY_USES_REJECT
\r
1088 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
\r
1091 /* just a shorter name for the current buffer */
\r
1092 YY_BUFFER_STATE b = yy_current_buffer;
\r
1094 int yy_c_buf_p_offset =
\r
1095 (int) (yy_c_buf_p - b->yy_ch_buf);
\r
1097 if ( b->yy_is_our_buffer )
\r
1099 int new_size = b->yy_buf_size * 2;
\r
1101 if ( new_size <= 0 )
\r
1102 b->yy_buf_size += b->yy_buf_size / 8;
\r
1104 b->yy_buf_size *= 2;
\r
1106 b->yy_ch_buf = (char *)
\r
1107 /* Include room in for 2 EOB chars. */
\r
1108 yy_flex_realloc( (void *) b->yy_ch_buf,
\r
1109 b->yy_buf_size + 2 );
\r
1112 /* Can't grow it, we don't own it. */
\r
1115 if ( ! b->yy_ch_buf )
\r
1117 "fatal error - scanner input buffer overflow" );
\r
1119 yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
\r
1121 num_to_read = yy_current_buffer->yy_buf_size -
\r
1122 number_to_move - 1;
\r
1126 if ( num_to_read > YY_READ_BUF_SIZE )
\r
1127 num_to_read = YY_READ_BUF_SIZE;
\r
1129 /* Read in more data. */
\r
1130 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
\r
1131 yy_n_chars, num_to_read );
\r
1133 yy_current_buffer->yy_n_chars = yy_n_chars;
\r
1136 if ( yy_n_chars == 0 )
\r
1138 if ( number_to_move == YY_MORE_ADJ )
\r
1140 ret_val = EOB_ACT_END_OF_FILE;
\r
1141 yyrestart( yyin );
\r
1146 ret_val = EOB_ACT_LAST_MATCH;
\r
1147 yy_current_buffer->yy_buffer_status =
\r
1148 YY_BUFFER_EOF_PENDING;
\r
1153 ret_val = EOB_ACT_CONTINUE_SCAN;
\r
1155 yy_n_chars += number_to_move;
\r
1156 yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
\r
1157 yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
\r
1159 yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
\r
1165 /* yy_get_previous_state - get the state just before the EOB char was reached */
\r
1167 static yy_state_type yy_get_previous_state()
\r
1169 register yy_state_type yy_current_state;
\r
1170 register char *yy_cp;
\r
1172 yy_current_state = yy_start;
\r
1174 for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
\r
1176 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
\r
1177 if ( yy_accept[yy_current_state] )
\r
1179 yy_last_accepting_state = yy_current_state;
\r
1180 yy_last_accepting_cpos = yy_cp;
\r
1182 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
\r
1184 yy_current_state = (int) yy_def[yy_current_state];
\r
1185 if ( yy_current_state >= 85 )
\r
1186 yy_c = yy_meta[(unsigned int) yy_c];
\r
1188 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
\r
1191 return yy_current_state;
\r
1195 /* yy_try_NUL_trans - try to make a transition on the NUL character
\r
1198 * next_state = yy_try_NUL_trans( current_state );
\r
1201 #ifdef YY_USE_PROTOS
\r
1202 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
\r
1204 static yy_state_type yy_try_NUL_trans( yy_current_state )
\r
1205 yy_state_type yy_current_state;
\r
1208 register int yy_is_jam;
\r
1209 register char *yy_cp = yy_c_buf_p;
\r
1211 register YY_CHAR yy_c = 1;
\r
1212 if ( yy_accept[yy_current_state] )
\r
1214 yy_last_accepting_state = yy_current_state;
\r
1215 yy_last_accepting_cpos = yy_cp;
\r
1217 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
\r
1219 yy_current_state = (int) yy_def[yy_current_state];
\r
1220 if ( yy_current_state >= 85 )
\r
1221 yy_c = yy_meta[(unsigned int) yy_c];
\r
1223 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
\r
1224 yy_is_jam = (yy_current_state == 84);
\r
1226 return yy_is_jam ? 0 : yy_current_state;
\r
1230 #ifndef YY_NO_UNPUT
\r
1231 #ifdef YY_USE_PROTOS
\r
1232 static void yyunput( int c, register char *yy_bp )
\r
1234 static void yyunput( c, yy_bp )
\r
1236 register char *yy_bp;
\r
1239 register char *yy_cp = yy_c_buf_p;
\r
1241 /* undo effects of setting up yytext */
\r
1242 *yy_cp = yy_hold_char;
\r
1244 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
\r
1245 { /* need to shift things up to make room */
\r
1246 /* +2 for EOB chars. */
\r
1247 register int number_to_move = yy_n_chars + 2;
\r
1248 register char *dest = &yy_current_buffer->yy_ch_buf[
\r
1249 yy_current_buffer->yy_buf_size + 2];
\r
1250 register char *source =
\r
1251 &yy_current_buffer->yy_ch_buf[number_to_move];
\r
1253 while ( source > yy_current_buffer->yy_ch_buf )
\r
1254 *--dest = *--source;
\r
1256 yy_cp += (int) (dest - source);
\r
1257 yy_bp += (int) (dest - source);
\r
1258 yy_current_buffer->yy_n_chars =
\r
1259 yy_n_chars = yy_current_buffer->yy_buf_size;
\r
1261 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
\r
1262 YY_FATAL_ERROR( "flex scanner push-back overflow" );
\r
1265 *--yy_cp = (char) c;
\r
1268 yytext_ptr = yy_bp;
\r
1269 yy_hold_char = *yy_cp;
\r
1270 yy_c_buf_p = yy_cp;
\r
1272 #endif /* ifndef YY_NO_UNPUT */
\r
1275 #ifndef YY_NO_INPUT
\r
1276 #ifdef __cplusplus
\r
1277 static int yyinput()
\r
1279 static int input()
\r
1284 *yy_c_buf_p = yy_hold_char;
\r
1286 if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
\r
1288 /* yy_c_buf_p now points to the character we want to return.
\r
1289 * If this occurs *before* the EOB characters, then it's a
\r
1290 * valid NUL; if not, then we've hit the end of the buffer.
\r
1292 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
\r
1293 /* This was really a NUL. */
\r
1294 *yy_c_buf_p = '\0';
\r
1297 { /* need more input */
\r
1298 int offset = yy_c_buf_p - yytext_ptr;
\r
1301 switch ( yy_get_next_buffer() )
\r
1303 case EOB_ACT_LAST_MATCH:
\r
1304 /* This happens because yy_g_n_b()
\r
1305 * sees that we've accumulated a
\r
1306 * token and flags that we need to
\r
1307 * try matching the token before
\r
1308 * proceeding. But for input(),
\r
1309 * there's no matching to consider.
\r
1310 * So convert the EOB_ACT_LAST_MATCH
\r
1311 * to EOB_ACT_END_OF_FILE.
\r
1314 /* Reset buffer status. */
\r
1315 yyrestart( yyin );
\r
1317 /* fall through */
\r
1319 case EOB_ACT_END_OF_FILE:
\r
1324 if ( ! yy_did_buffer_switch_on_eof )
\r
1326 #ifdef __cplusplus
\r
1333 case EOB_ACT_CONTINUE_SCAN:
\r
1334 yy_c_buf_p = yytext_ptr + offset;
\r
1340 c = *(unsigned char *) yy_c_buf_p; /* cast for 8-bit char's */
\r
1341 *yy_c_buf_p = '\0'; /* preserve yytext */
\r
1342 yy_hold_char = *++yy_c_buf_p;
\r
1347 #endif /* YY_NO_INPUT */
\r
1349 #ifdef YY_USE_PROTOS
\r
1350 void yyrestart( FILE *input_file )
\r
1352 void yyrestart( input_file )
\r
1356 if ( ! yy_current_buffer )
\r
1357 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
\r
1359 yy_init_buffer( yy_current_buffer, input_file );
\r
1360 yy_load_buffer_state();
\r
1364 #ifdef YY_USE_PROTOS
\r
1365 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
\r
1367 void yy_switch_to_buffer( new_buffer )
\r
1368 YY_BUFFER_STATE new_buffer;
\r
1371 if ( yy_current_buffer == new_buffer )
\r
1374 if ( yy_current_buffer )
\r
1376 /* Flush out information for old buffer. */
\r
1377 *yy_c_buf_p = yy_hold_char;
\r
1378 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
\r
1379 yy_current_buffer->yy_n_chars = yy_n_chars;
\r
1382 yy_current_buffer = new_buffer;
\r
1383 yy_load_buffer_state();
\r
1385 /* We don't actually know whether we did this switch during
\r
1386 * EOF (yywrap()) processing, but the only time this flag
\r
1387 * is looked at is after yywrap() is called, so it's safe
\r
1388 * to go ahead and always set it.
\r
1390 yy_did_buffer_switch_on_eof = 1;
\r
1394 #ifdef YY_USE_PROTOS
\r
1395 void yy_load_buffer_state( void )
\r
1397 void yy_load_buffer_state()
\r
1400 yy_n_chars = yy_current_buffer->yy_n_chars;
\r
1401 yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
\r
1402 yyin = yy_current_buffer->yy_input_file;
\r
1403 yy_hold_char = *yy_c_buf_p;
\r
1407 #ifdef YY_USE_PROTOS
\r
1408 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
\r
1410 YY_BUFFER_STATE yy_create_buffer( file, size )
\r
1415 YY_BUFFER_STATE b;
\r
1417 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
\r
1419 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
\r
1421 b->yy_buf_size = size;
\r
1423 /* yy_ch_buf has to be 2 characters longer than the size given because
\r
1424 * we need to put in 2 end-of-buffer characters.
\r
1426 b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
\r
1427 if ( ! b->yy_ch_buf )
\r
1428 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
\r
1430 b->yy_is_our_buffer = 1;
\r
1432 yy_init_buffer( b, file );
\r
1438 #ifdef YY_USE_PROTOS
\r
1439 void yy_delete_buffer( YY_BUFFER_STATE b )
\r
1441 void yy_delete_buffer( b )
\r
1442 YY_BUFFER_STATE b;
\r
1448 if ( b == yy_current_buffer )
\r
1449 yy_current_buffer = (YY_BUFFER_STATE) 0;
\r
1451 if ( b->yy_is_our_buffer )
\r
1452 yy_flex_free( (void *) b->yy_ch_buf );
\r
1454 yy_flex_free( (void *) b );
\r
1459 #ifdef YY_USE_PROTOS
\r
1460 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
\r
1462 void yy_init_buffer( b, file )
\r
1463 YY_BUFFER_STATE b;
\r
1469 yy_flush_buffer( b );
\r
1471 b->yy_input_file = file;
\r
1472 b->yy_fill_buffer = 1;
\r
1474 #if YY_ALWAYS_INTERACTIVE
\r
1475 b->yy_is_interactive = 1;
\r
1477 #if YY_NEVER_INTERACTIVE
\r
1478 b->yy_is_interactive = 0;
\r
1480 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
\r
1486 #ifdef YY_USE_PROTOS
\r
1487 void yy_flush_buffer( YY_BUFFER_STATE b )
\r
1489 void yy_flush_buffer( b )
\r
1490 YY_BUFFER_STATE b;
\r
1497 b->yy_n_chars = 0;
\r
1499 /* We always need two end-of-buffer characters. The first causes
\r
1500 * a transition to the end-of-buffer state. The second causes
\r
1501 * a jam in that state.
\r
1503 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
\r
1504 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
\r
1506 b->yy_buf_pos = &b->yy_ch_buf[0];
\r
1509 b->yy_buffer_status = YY_BUFFER_NEW;
\r
1511 if ( b == yy_current_buffer )
\r
1512 yy_load_buffer_state();
\r
1516 #ifndef YY_NO_SCAN_BUFFER
\r
1517 #ifdef YY_USE_PROTOS
\r
1518 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
\r
1520 YY_BUFFER_STATE yy_scan_buffer( base, size )
\r
1525 YY_BUFFER_STATE b;
\r
1528 base[size-2] != YY_END_OF_BUFFER_CHAR ||
\r
1529 base[size-1] != YY_END_OF_BUFFER_CHAR )
\r
1530 /* They forgot to leave room for the EOB's. */
\r
1533 b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
\r
1535 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
\r
1537 b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
\r
1538 b->yy_buf_pos = b->yy_ch_buf = base;
\r
1539 b->yy_is_our_buffer = 0;
\r
1540 b->yy_input_file = 0;
\r
1541 b->yy_n_chars = b->yy_buf_size;
\r
1542 b->yy_is_interactive = 0;
\r
1544 b->yy_fill_buffer = 0;
\r
1545 b->yy_buffer_status = YY_BUFFER_NEW;
\r
1547 yy_switch_to_buffer( b );
\r
1554 #ifndef YY_NO_SCAN_STRING
\r
1555 #ifdef YY_USE_PROTOS
\r
1556 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
\r
1558 YY_BUFFER_STATE yy_scan_string( yy_str )
\r
1559 yyconst char *yy_str;
\r
1563 for ( len = 0; yy_str[len]; ++len )
\r
1566 return yy_scan_bytes( yy_str, len );
\r
1571 #ifndef YY_NO_SCAN_BYTES
\r
1572 #ifdef YY_USE_PROTOS
\r
1573 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
\r
1575 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
\r
1576 yyconst char *bytes;
\r
1580 YY_BUFFER_STATE b;
\r
1585 /* Get memory for full buffer, including space for trailing EOB's. */
\r
1587 buf = (char *) yy_flex_alloc( n );
\r
1589 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
\r
1591 for ( i = 0; i < len; ++i )
\r
1592 buf[i] = bytes[i];
\r
1594 buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
\r
1596 b = yy_scan_buffer( buf, n );
\r
1598 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
\r
1600 /* It's okay to grow etc. this buffer, and we should throw it
\r
1601 * away when we're done.
\r
1603 b->yy_is_our_buffer = 1;
\r
1610 #ifndef YY_NO_PUSH_STATE
\r
1611 #ifdef YY_USE_PROTOS
\r
1612 static void yy_push_state( int new_state )
\r
1614 static void yy_push_state( new_state )
\r
1618 if ( yy_start_stack_ptr >= yy_start_stack_depth )
\r
1620 yy_size_t new_size;
\r
1622 yy_start_stack_depth += YY_START_STACK_INCR;
\r
1623 new_size = yy_start_stack_depth * sizeof( int );
\r
1625 if ( ! yy_start_stack )
\r
1626 yy_start_stack = (int *) yy_flex_alloc( new_size );
\r
1629 yy_start_stack = (int *) yy_flex_realloc(
\r
1630 (void *) yy_start_stack, new_size );
\r
1632 if ( ! yy_start_stack )
\r
1634 "out of memory expanding start-condition stack" );
\r
1637 yy_start_stack[yy_start_stack_ptr++] = YY_START;
\r
1644 #ifndef YY_NO_POP_STATE
\r
1645 static void yy_pop_state()
\r
1647 if ( --yy_start_stack_ptr < 0 )
\r
1648 YY_FATAL_ERROR( "start-condition stack underflow" );
\r
1650 BEGIN(yy_start_stack[yy_start_stack_ptr]);
\r
1655 #ifndef YY_NO_TOP_STATE
\r
1656 static int yy_top_state()
\r
1658 return yy_start_stack[yy_start_stack_ptr - 1];
\r
1662 #ifndef YY_EXIT_FAILURE
\r
1663 #define YY_EXIT_FAILURE 2
\r
1666 #ifdef YY_USE_PROTOS
\r
1667 static void yy_fatal_error( yyconst char msg[] )
\r
1669 static void yy_fatal_error( msg )
\r
1673 (void) fprintf( stderr, "%s\n", msg );
\r
1674 exit( YY_EXIT_FAILURE );
\r
1679 /* Redefine yyless() so it works in section 3 code. */
\r
1682 #define yyless(n) \
\r
1685 /* Undo effects of setting up yytext. */ \
\r
1686 yytext[yyleng] = yy_hold_char; \
\r
1687 yy_c_buf_p = yytext + n; \
\r
1688 yy_hold_char = *yy_c_buf_p; \
\r
1689 *yy_c_buf_p = '\0'; \
\r
1695 /* Internal utility routines. */
\r
1697 #ifndef yytext_ptr
\r
1698 #ifdef YY_USE_PROTOS
\r
1699 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
\r
1701 static void yy_flex_strncpy( s1, s2, n )
\r
1708 for ( i = 0; i < n; ++i )
\r
1713 #ifdef YY_NEED_STRLEN
\r
1714 #ifdef YY_USE_PROTOS
\r
1715 static int yy_flex_strlen( yyconst char *s )
\r
1717 static int yy_flex_strlen( s )
\r
1722 for ( n = 0; s[n]; ++n )
\r
1730 #ifdef YY_USE_PROTOS
\r
1731 static void *yy_flex_alloc( yy_size_t size )
\r
1733 static void *yy_flex_alloc( size )
\r
1737 return (void *) malloc( size );
\r
1740 #ifdef YY_USE_PROTOS
\r
1741 static void *yy_flex_realloc( void *ptr, yy_size_t size )
\r
1743 static void *yy_flex_realloc( ptr, size )
\r
1748 /* The cast to (char *) in the following accommodates both
\r
1749 * implementations that use char* generic pointers, and those
\r
1750 * that use void* generic pointers. It works with the latter
\r
1751 * because both ANSI C and C++ allow castless assignment from
\r
1752 * any pointer type to void*, and deal with argument conversions
\r
1753 * as though doing an assignment.
\r
1755 return (void *) realloc( (char *) ptr, size );
\r
1758 #ifdef YY_USE_PROTOS
\r
1759 static void yy_flex_free( void *ptr )
\r
1761 static void yy_flex_free( ptr )
\r
1778 int my_NicParser_yyinput(char *buf, int max_size){
\r
1782 if(flex_nic_stringinput != NULL){
\r
1783 while(c<max_size){
\r
1784 if(flex_nic_stringinput[flex_nic_stringinput_ptr] != '\0'){
\r
1785 buf[c++] = flex_nic_stringinput[flex_nic_stringinput_ptr++];
\r
1793 if(flex_nic_fileinput != NULL){
\r
1794 while(c < max_size){
\r
1795 inchar = getc(flex_nic_fileinput);
\r
1796 if(inchar != EOF){
\r
1797 buf[c++] = inchar;
\r
1808 void NicParser_setfileinput(FILE *f){
\r
1809 NicParserrestart(NULL);
\r
1811 flex_nic_fileinput = f;
\r
1812 flex_nic_stringinput = NULL;
\r
1813 flex_nic_lineno = 1;
\r
1817 void NicParser_setstringinput(char *s){
\r
1818 NicParserrestart(NULL);
\r
1820 flex_nic_fileinput = NULL;
\r
1821 flex_nic_stringinput = s;
\r
1822 flex_nic_stringinput_ptr = 0;
\r
1823 flex_nic_lineno = 1;
\r