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