925615f244c4756a1b89a7588feb75ac44c357e9
[ira/wip.git] / source / heimdal / lib / com_err / lex.c
1 /* A lexical scanner generated by flex */
2
3 /* Scanner skeleton version:
4  * $Header: /home/daffy/u0/vern/flex/RCS/flex.skl,v 2.91 96/09/10 16:58:48 vern Exp $
5  */
6
7 #define FLEX_SCANNER
8 #define YY_FLEX_MAJOR_VERSION 2
9 #define YY_FLEX_MINOR_VERSION 5
10
11 #include <stdio.h>
12 #include <unistd.h>
13
14
15 /* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
16 #ifdef c_plusplus
17 #ifndef __cplusplus
18 #define __cplusplus
19 #endif
20 #endif
21
22
23 #ifdef __cplusplus
24
25 #include <stdlib.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 *yy_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 16
286 #define YY_END_OF_BUFFER 17
287 static yyconst short int yy_accept[46] =
288     {   0,
289         0,    0,   17,   15,   11,   12,   13,   10,    9,   14,
290        14,   14,   14,   10,    9,   14,    3,   14,   14,    1,
291         7,   14,   14,    8,   14,   14,   14,   14,   14,   14,
292        14,    6,   14,   14,    5,   14,   14,   14,   14,   14,
293        14,    4,   14,    2,    0
294     } ;
295
296 static yyconst int yy_ec[256] =
297     {   0,
298         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
299         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
300         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
301         1,    2,    1,    4,    5,    1,    1,    1,    1,    1,
302         1,    1,    1,    1,    1,    1,    1,    6,    6,    6,
303         6,    6,    6,    6,    6,    6,    6,    1,    1,    1,
304         1,    1,    1,    1,    7,    7,    7,    7,    7,    7,
305         7,    7,    7,    7,    7,    7,    7,    7,    7,    7,
306         7,    7,    7,    7,    7,    7,    7,    7,    7,    7,
307         1,    1,    1,    1,    8,    1,    9,   10,   11,   12,
308
309        13,   14,    7,    7,   15,    7,    7,   16,    7,   17,
310        18,   19,    7,   20,    7,   21,    7,    7,    7,   22,
311         7,    7,    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         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
317         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
318         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
319
320         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
321         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
322         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
323         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
324         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
325         1,    1,    1,    1,    1
326     } ;
327
328 static yyconst int yy_meta[23] =
329     {   0,
330         1,    1,    2,    1,    1,    3,    3,    3,    3,    3,
331         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
332         3,    3
333     } ;
334
335 static yyconst short int yy_base[48] =
336     {   0,
337         0,    0,   56,   57,   57,   57,   57,    0,   49,    0,
338        12,   13,   34,    0,   47,    0,    0,   40,   31,    0,
339         0,   38,   36,    0,   30,   34,   32,   25,   22,   28,
340        34,    0,   19,   13,    0,   22,   30,   26,   26,   18,
341        12,    0,   14,    0,   57,   34,   23
342     } ;
343
344 static yyconst short int yy_def[48] =
345     {   0,
346        45,    1,   45,   45,   45,   45,   45,   46,   47,   47,
347        47,   47,   47,   46,   47,   47,   47,   47,   47,   47,
348        47,   47,   47,   47,   47,   47,   47,   47,   47,   47,
349        47,   47,   47,   47,   47,   47,   47,   47,   47,   47,
350        47,   47,   47,   47,    0,   45,   45
351     } ;
352
353 static yyconst short int yy_nxt[80] =
354     {   0,
355         4,    5,    6,    7,    8,    9,   10,   10,   10,   10,
356        10,   10,   11,   10,   12,   10,   10,   10,   13,   10,
357        10,   10,   17,   36,   21,   16,   44,   43,   18,   22,
358        42,   19,   20,   37,   14,   41,   14,   40,   39,   38,
359        35,   34,   33,   32,   31,   30,   29,   28,   27,   26,
360        25,   24,   15,   23,   15,   45,    3,   45,   45,   45,
361        45,   45,   45,   45,   45,   45,   45,   45,   45,   45,
362        45,   45,   45,   45,   45,   45,   45,   45,   45
363     } ;
364
365 static yyconst short int yy_chk[80] =
366     {   0,
367         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
368         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
369         1,    1,   11,   34,   12,   47,   43,   41,   11,   12,
370        40,   11,   11,   34,   46,   39,   46,   38,   37,   36,
371        33,   31,   30,   29,   28,   27,   26,   25,   23,   22,
372        19,   18,   15,   13,    9,    3,   45,   45,   45,   45,
373        45,   45,   45,   45,   45,   45,   45,   45,   45,   45,
374        45,   45,   45,   45,   45,   45,   45,   45,   45
375     } ;
376
377 static yy_state_type yy_last_accepting_state;
378 static char *yy_last_accepting_cpos;
379
380 /* The intent behind this definition is that it'll catch
381  * any uses of REJECT which flex missed.
382  */
383 #define REJECT reject_used_but_not_detected
384 #define yymore() yymore_used_but_not_detected
385 #define YY_MORE_ADJ 0
386 #define YY_RESTORE_YY_MORE_OFFSET
387 char *yytext;
388 #line 1 "lex.l"
389 #define INITIAL 0
390 #line 2 "lex.l"
391 /*
392  * Copyright (c) 1998 - 2000 Kungliga Tekniska Högskolan
393  * (Royal Institute of Technology, Stockholm, Sweden). 
394  * All rights reserved. 
395  *
396  * Redistribution and use in source and binary forms, with or without 
397  * modification, are permitted provided that the following conditions 
398  * are met: 
399  *
400  * 1. Redistributions of source code must retain the above copyright 
401  *    notice, this list of conditions and the following disclaimer. 
402  *
403  * 2. Redistributions in binary form must reproduce the above copyright 
404  *    notice, this list of conditions and the following disclaimer in the 
405  *    documentation and/or other materials provided with the distribution. 
406  *
407  * 3. Neither the name of the Institute nor the names of its contributors 
408  *    may be used to endorse or promote products derived from this software 
409  *    without specific prior written permission. 
410  *
411  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND 
412  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
413  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
414  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE 
415  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
416  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 
417  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
418  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
419  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 
420  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
421  * SUCH DAMAGE. 
422  */
423
424 /*
425  * This is to handle the definition of this symbol in some AIX
426  * headers, which will conflict with the definition that lex will
427  * generate for it.  It's only a problem for AIX lex.
428  */
429
430 #undef ECHO
431
432 #include "compile_et.h"
433 #include "parse.h"
434 #include "lex.h"
435
436 RCSID("$Id: lex.l,v 1.8 2005/05/16 08:52:54 lha Exp $");
437
438 static unsigned lineno = 1;
439 static int getstring(void);
440
441 #define YY_NO_UNPUT
442
443 #undef ECHO
444
445 #line 446 "lex.yy.c"
446
447 /* Macros after this point can all be overridden by user definitions in
448  * section 1.
449  */
450
451 #ifndef YY_SKIP_YYWRAP
452 #ifdef __cplusplus
453 extern "C" int yywrap YY_PROTO(( void ));
454 #else
455 extern int yywrap YY_PROTO(( void ));
456 #endif
457 #endif
458
459 #ifndef YY_NO_UNPUT
460 static void yyunput YY_PROTO(( int c, char *buf_ptr ));
461 #endif
462
463 #ifndef yytext_ptr
464 static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
465 #endif
466
467 #ifdef YY_NEED_STRLEN
468 static int yy_flex_strlen YY_PROTO(( yyconst char * ));
469 #endif
470
471 #ifndef YY_NO_INPUT
472 #ifdef __cplusplus
473 static int yyinput YY_PROTO(( void ));
474 #else
475 static int input YY_PROTO(( void ));
476 #endif
477 #endif
478
479 #if YY_STACK_USED
480 static int yy_start_stack_ptr = 0;
481 static int yy_start_stack_depth = 0;
482 static int *yy_start_stack = 0;
483 #ifndef YY_NO_PUSH_STATE
484 static void yy_push_state YY_PROTO(( int new_state ));
485 #endif
486 #ifndef YY_NO_POP_STATE
487 static void yy_pop_state YY_PROTO(( void ));
488 #endif
489 #ifndef YY_NO_TOP_STATE
490 static int yy_top_state YY_PROTO(( void ));
491 #endif
492
493 #else
494 #define YY_NO_PUSH_STATE 1
495 #define YY_NO_POP_STATE 1
496 #define YY_NO_TOP_STATE 1
497 #endif
498
499 #ifdef YY_MALLOC_DECL
500 YY_MALLOC_DECL
501 #else
502 #if __STDC__
503 #ifndef __cplusplus
504 #include <stdlib.h>
505 #endif
506 #else
507 /* Just try to get by without declaring the routines.  This will fail
508  * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
509  * or sizeof(void*) != sizeof(int).
510  */
511 #endif
512 #endif
513
514 /* Amount of stuff to slurp up with each read. */
515 #ifndef YY_READ_BUF_SIZE
516 #define YY_READ_BUF_SIZE 8192
517 #endif
518
519 /* Copy whatever the last rule matched to the standard output. */
520
521 #ifndef ECHO
522 /* This used to be an fputs(), but since the string might contain NUL's,
523  * we now use fwrite().
524  */
525 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
526 #endif
527
528 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
529  * is returned in "result".
530  */
531 #ifndef YY_INPUT
532 #define YY_INPUT(buf,result,max_size) \
533         if ( yy_current_buffer->yy_is_interactive ) \
534                 { \
535                 int c = '*', n; \
536                 for ( n = 0; n < max_size && \
537                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
538                         buf[n] = (char) c; \
539                 if ( c == '\n' ) \
540                         buf[n++] = (char) c; \
541                 if ( c == EOF && ferror( yyin ) ) \
542                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
543                 result = n; \
544                 } \
545         else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
546                   && ferror( yyin ) ) \
547                 YY_FATAL_ERROR( "input in flex scanner failed" );
548 #endif
549
550 /* No semi-colon after return; correct usage is to write "yyterminate();" -
551  * we don't want an extra ';' after the "return" because that will cause
552  * some compilers to complain about unreachable statements.
553  */
554 #ifndef yyterminate
555 #define yyterminate() return YY_NULL
556 #endif
557
558 /* Number of entries by which start-condition stack grows. */
559 #ifndef YY_START_STACK_INCR
560 #define YY_START_STACK_INCR 25
561 #endif
562
563 /* Report a fatal error. */
564 #ifndef YY_FATAL_ERROR
565 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
566 #endif
567
568 /* Default declaration of generated scanner - a define so the user can
569  * easily add parameters.
570  */
571 #ifndef YY_DECL
572 #define YY_DECL int yylex YY_PROTO(( void ))
573 #endif
574
575 /* Code executed at the beginning of each rule, after yytext and yyleng
576  * have been set up.
577  */
578 #ifndef YY_USER_ACTION
579 #define YY_USER_ACTION
580 #endif
581
582 /* Code executed at the end of each rule. */
583 #ifndef YY_BREAK
584 #define YY_BREAK break;
585 #endif
586
587 #define YY_RULE_SETUP \
588         YY_USER_ACTION
589
590 YY_DECL
591         {
592         register yy_state_type yy_current_state;
593         register char *yy_cp = NULL, *yy_bp = NULL;
594         register int yy_act;
595
596 #line 59 "lex.l"
597
598 #line 599 "lex.yy.c"
599
600         if ( yy_init )
601                 {
602                 yy_init = 0;
603
604 #ifdef YY_USER_INIT
605                 YY_USER_INIT;
606 #endif
607
608                 if ( ! yy_start )
609                         yy_start = 1;   /* first start state */
610
611                 if ( ! yyin )
612                         yyin = stdin;
613
614                 if ( ! yyout )
615                         yyout = stdout;
616
617                 if ( ! yy_current_buffer )
618                         yy_current_buffer =
619                                 yy_create_buffer( yyin, YY_BUF_SIZE );
620
621                 yy_load_buffer_state();
622                 }
623
624         while ( 1 )             /* loops until end-of-file is reached */
625                 {
626                 yy_cp = yy_c_buf_p;
627
628                 /* Support of yytext. */
629                 *yy_cp = yy_hold_char;
630
631                 /* yy_bp points to the position in yy_ch_buf of the start of
632                  * the current run.
633                  */
634                 yy_bp = yy_cp;
635
636                 yy_current_state = yy_start;
637 yy_match:
638                 do
639                         {
640                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
641                         if ( yy_accept[yy_current_state] )
642                                 {
643                                 yy_last_accepting_state = yy_current_state;
644                                 yy_last_accepting_cpos = yy_cp;
645                                 }
646                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
647                                 {
648                                 yy_current_state = (int) yy_def[yy_current_state];
649                                 if ( yy_current_state >= 46 )
650                                         yy_c = yy_meta[(unsigned int) yy_c];
651                                 }
652                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
653                         ++yy_cp;
654                         }
655                 while ( yy_base[yy_current_state] != 57 );
656
657 yy_find_action:
658                 yy_act = yy_accept[yy_current_state];
659                 if ( yy_act == 0 )
660                         { /* have to back up */
661                         yy_cp = yy_last_accepting_cpos;
662                         yy_current_state = yy_last_accepting_state;
663                         yy_act = yy_accept[yy_current_state];
664                         }
665
666                 YY_DO_BEFORE_ACTION;
667
668
669 do_action:      /* This label is used only to access EOF actions. */
670
671
672                 switch ( yy_act )
673         { /* beginning of action switch */
674                         case 0: /* must back up */
675                         /* undo the effects of YY_DO_BEFORE_ACTION */
676                         *yy_cp = yy_hold_char;
677                         yy_cp = yy_last_accepting_cpos;
678                         yy_current_state = yy_last_accepting_state;
679                         goto yy_find_action;
680
681 case 1:
682 YY_RULE_SETUP
683 #line 60 "lex.l"
684 { return ET; }
685         YY_BREAK
686 case 2:
687 YY_RULE_SETUP
688 #line 61 "lex.l"
689 { return ET; }
690         YY_BREAK
691 case 3:
692 YY_RULE_SETUP
693 #line 62 "lex.l"
694 { return EC; }
695         YY_BREAK
696 case 4:
697 YY_RULE_SETUP
698 #line 63 "lex.l"
699 { return EC; }
700         YY_BREAK
701 case 5:
702 YY_RULE_SETUP
703 #line 64 "lex.l"
704 { return PREFIX; }
705         YY_BREAK
706 case 6:
707 YY_RULE_SETUP
708 #line 65 "lex.l"
709 { return INDEX; }
710         YY_BREAK
711 case 7:
712 YY_RULE_SETUP
713 #line 66 "lex.l"
714 { return ID; }
715         YY_BREAK
716 case 8:
717 YY_RULE_SETUP
718 #line 67 "lex.l"
719 { return END; }
720         YY_BREAK
721 case 9:
722 YY_RULE_SETUP
723 #line 68 "lex.l"
724 { yylval.number = atoi(yytext); return NUMBER; }
725         YY_BREAK
726 case 10:
727 YY_RULE_SETUP
728 #line 69 "lex.l"
729 ;
730         YY_BREAK
731 case 11:
732 YY_RULE_SETUP
733 #line 70 "lex.l"
734 ;
735         YY_BREAK
736 case 12:
737 YY_RULE_SETUP
738 #line 71 "lex.l"
739 { lineno++; }
740         YY_BREAK
741 case 13:
742 YY_RULE_SETUP
743 #line 72 "lex.l"
744 { return getstring(); }
745         YY_BREAK
746 case 14:
747 YY_RULE_SETUP
748 #line 73 "lex.l"
749 { yylval.string = strdup(yytext); return STRING; }
750         YY_BREAK
751 case 15:
752 YY_RULE_SETUP
753 #line 74 "lex.l"
754 { return *yytext; }
755         YY_BREAK
756 case 16:
757 YY_RULE_SETUP
758 #line 75 "lex.l"
759 ECHO;
760         YY_BREAK
761 #line 762 "lex.yy.c"
762 case YY_STATE_EOF(INITIAL):
763         yyterminate();
764
765         case YY_END_OF_BUFFER:
766                 {
767                 /* Amount of text matched not including the EOB char. */
768                 int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
769
770                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
771                 *yy_cp = yy_hold_char;
772                 YY_RESTORE_YY_MORE_OFFSET
773
774                 if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
775                         {
776                         /* We're scanning a new file or input source.  It's
777                          * possible that this happened because the user
778                          * just pointed yyin at a new source and called
779                          * yylex().  If so, then we have to assure
780                          * consistency between yy_current_buffer and our
781                          * globals.  Here is the right place to do so, because
782                          * this is the first action (other than possibly a
783                          * back-up) that will match for the new input source.
784                          */
785                         yy_n_chars = yy_current_buffer->yy_n_chars;
786                         yy_current_buffer->yy_input_file = yyin;
787                         yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
788                         }
789
790                 /* Note that here we test for yy_c_buf_p "<=" to the position
791                  * of the first EOB in the buffer, since yy_c_buf_p will
792                  * already have been incremented past the NUL character
793                  * (since all states make transitions on EOB to the
794                  * end-of-buffer state).  Contrast this with the test
795                  * in input().
796                  */
797                 if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
798                         { /* This was really a NUL. */
799                         yy_state_type yy_next_state;
800
801                         yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
802
803                         yy_current_state = yy_get_previous_state();
804
805                         /* Okay, we're now positioned to make the NUL
806                          * transition.  We couldn't have
807                          * yy_get_previous_state() go ahead and do it
808                          * for us because it doesn't know how to deal
809                          * with the possibility of jamming (and we don't
810                          * want to build jamming into it because then it
811                          * will run more slowly).
812                          */
813
814                         yy_next_state = yy_try_NUL_trans( yy_current_state );
815
816                         yy_bp = yytext_ptr + YY_MORE_ADJ;
817
818                         if ( yy_next_state )
819                                 {
820                                 /* Consume the NUL. */
821                                 yy_cp = ++yy_c_buf_p;
822                                 yy_current_state = yy_next_state;
823                                 goto yy_match;
824                                 }
825
826                         else
827                                 {
828                                 yy_cp = yy_c_buf_p;
829                                 goto yy_find_action;
830                                 }
831                         }
832
833                 else switch ( yy_get_next_buffer() )
834                         {
835                         case EOB_ACT_END_OF_FILE:
836                                 {
837                                 yy_did_buffer_switch_on_eof = 0;
838
839                                 if ( yywrap() )
840                                         {
841                                         /* Note: because we've taken care in
842                                          * yy_get_next_buffer() to have set up
843                                          * yytext, we can now set up
844                                          * yy_c_buf_p so that if some total
845                                          * hoser (like flex itself) wants to
846                                          * call the scanner after we return the
847                                          * YY_NULL, it'll still work - another
848                                          * YY_NULL will get returned.
849                                          */
850                                         yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
851
852                                         yy_act = YY_STATE_EOF(YY_START);
853                                         goto do_action;
854                                         }
855
856                                 else
857                                         {
858                                         if ( ! yy_did_buffer_switch_on_eof )
859                                                 YY_NEW_FILE;
860                                         }
861                                 break;
862                                 }
863
864                         case EOB_ACT_CONTINUE_SCAN:
865                                 yy_c_buf_p =
866                                         yytext_ptr + yy_amount_of_matched_text;
867
868                                 yy_current_state = yy_get_previous_state();
869
870                                 yy_cp = yy_c_buf_p;
871                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
872                                 goto yy_match;
873
874                         case EOB_ACT_LAST_MATCH:
875                                 yy_c_buf_p =
876                                 &yy_current_buffer->yy_ch_buf[yy_n_chars];
877
878                                 yy_current_state = yy_get_previous_state();
879
880                                 yy_cp = yy_c_buf_p;
881                                 yy_bp = yytext_ptr + YY_MORE_ADJ;
882                                 goto yy_find_action;
883                         }
884                 break;
885                 }
886
887         default:
888                 YY_FATAL_ERROR(
889                         "fatal flex scanner internal error--no action found" );
890         } /* end of action switch */
891                 } /* end of scanning one token */
892         } /* end of yylex */
893
894
895 /* yy_get_next_buffer - try to read in a new buffer
896  *
897  * Returns a code representing an action:
898  *      EOB_ACT_LAST_MATCH -
899  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
900  *      EOB_ACT_END_OF_FILE - end of file
901  */
902
903 static int yy_get_next_buffer()
904         {
905         register char *dest = yy_current_buffer->yy_ch_buf;
906         register char *source = yytext_ptr;
907         register int number_to_move, i;
908         int ret_val;
909
910         if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
911                 YY_FATAL_ERROR(
912                 "fatal flex scanner internal error--end of buffer missed" );
913
914         if ( yy_current_buffer->yy_fill_buffer == 0 )
915                 { /* Don't try to fill the buffer, so this is an EOF. */
916                 if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
917                         {
918                         /* We matched a single character, the EOB, so
919                          * treat this as a final EOF.
920                          */
921                         return EOB_ACT_END_OF_FILE;
922                         }
923
924                 else
925                         {
926                         /* We matched some text prior to the EOB, first
927                          * process it.
928                          */
929                         return EOB_ACT_LAST_MATCH;
930                         }
931                 }
932
933         /* Try to read more data. */
934
935         /* First move last chars to start of buffer. */
936         number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
937
938         for ( i = 0; i < number_to_move; ++i )
939                 *(dest++) = *(source++);
940
941         if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
942                 /* don't do the read, it's not guaranteed to return an EOF,
943                  * just force an EOF
944                  */
945                 yy_current_buffer->yy_n_chars = yy_n_chars = 0;
946
947         else
948                 {
949                 int num_to_read =
950                         yy_current_buffer->yy_buf_size - number_to_move - 1;
951
952                 while ( num_to_read <= 0 )
953                         { /* Not enough room in the buffer - grow it. */
954 #ifdef YY_USES_REJECT
955                         YY_FATAL_ERROR(
956 "input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
957 #else
958
959                         /* just a shorter name for the current buffer */
960                         YY_BUFFER_STATE b = yy_current_buffer;
961
962                         int yy_c_buf_p_offset =
963                                 (int) (yy_c_buf_p - b->yy_ch_buf);
964
965                         if ( b->yy_is_our_buffer )
966                                 {
967                                 int new_size = b->yy_buf_size * 2;
968
969                                 if ( new_size <= 0 )
970                                         b->yy_buf_size += b->yy_buf_size / 8;
971                                 else
972                                         b->yy_buf_size *= 2;
973
974                                 b->yy_ch_buf = (char *)
975                                         /* Include room in for 2 EOB chars. */
976                                         yy_flex_realloc( (void *) b->yy_ch_buf,
977                                                          b->yy_buf_size + 2 );
978                                 }
979                         else
980                                 /* Can't grow it, we don't own it. */
981                                 b->yy_ch_buf = 0;
982
983                         if ( ! b->yy_ch_buf )
984                                 YY_FATAL_ERROR(
985                                 "fatal error - scanner input buffer overflow" );
986
987                         yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
988
989                         num_to_read = yy_current_buffer->yy_buf_size -
990                                                 number_to_move - 1;
991 #endif
992                         }
993
994                 if ( num_to_read > YY_READ_BUF_SIZE )
995                         num_to_read = YY_READ_BUF_SIZE;
996
997                 /* Read in more data. */
998                 YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
999                         yy_n_chars, num_to_read );
1000
1001                 yy_current_buffer->yy_n_chars = yy_n_chars;
1002                 }
1003
1004         if ( yy_n_chars == 0 )
1005                 {
1006                 if ( number_to_move == YY_MORE_ADJ )
1007                         {
1008                         ret_val = EOB_ACT_END_OF_FILE;
1009                         yyrestart( yyin );
1010                         }
1011
1012                 else
1013                         {
1014                         ret_val = EOB_ACT_LAST_MATCH;
1015                         yy_current_buffer->yy_buffer_status =
1016                                 YY_BUFFER_EOF_PENDING;
1017                         }
1018                 }
1019
1020         else
1021                 ret_val = EOB_ACT_CONTINUE_SCAN;
1022
1023         yy_n_chars += number_to_move;
1024         yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1025         yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1026
1027         yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
1028
1029         return ret_val;
1030         }
1031
1032
1033 /* yy_get_previous_state - get the state just before the EOB char was reached */
1034
1035 static yy_state_type yy_get_previous_state()
1036         {
1037         register yy_state_type yy_current_state;
1038         register char *yy_cp;
1039
1040         yy_current_state = yy_start;
1041
1042         for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
1043                 {
1044                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1045                 if ( yy_accept[yy_current_state] )
1046                         {
1047                         yy_last_accepting_state = yy_current_state;
1048                         yy_last_accepting_cpos = yy_cp;
1049                         }
1050                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1051                         {
1052                         yy_current_state = (int) yy_def[yy_current_state];
1053                         if ( yy_current_state >= 46 )
1054                                 yy_c = yy_meta[(unsigned int) yy_c];
1055                         }
1056                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1057                 }
1058
1059         return yy_current_state;
1060         }
1061
1062
1063 /* yy_try_NUL_trans - try to make a transition on the NUL character
1064  *
1065  * synopsis
1066  *      next_state = yy_try_NUL_trans( current_state );
1067  */
1068
1069 #ifdef YY_USE_PROTOS
1070 static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
1071 #else
1072 static yy_state_type yy_try_NUL_trans( yy_current_state )
1073 yy_state_type yy_current_state;
1074 #endif
1075         {
1076         register int yy_is_jam;
1077         register char *yy_cp = yy_c_buf_p;
1078
1079         register YY_CHAR yy_c = 1;
1080         if ( yy_accept[yy_current_state] )
1081                 {
1082                 yy_last_accepting_state = yy_current_state;
1083                 yy_last_accepting_cpos = yy_cp;
1084                 }
1085         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1086                 {
1087                 yy_current_state = (int) yy_def[yy_current_state];
1088                 if ( yy_current_state >= 46 )
1089                         yy_c = yy_meta[(unsigned int) yy_c];
1090                 }
1091         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1092         yy_is_jam = (yy_current_state == 45);
1093
1094         return yy_is_jam ? 0 : yy_current_state;
1095         }
1096
1097
1098 #ifndef YY_NO_UNPUT
1099 #ifdef YY_USE_PROTOS
1100 static void yyunput( int c, register char *yy_bp )
1101 #else
1102 static void yyunput( c, yy_bp )
1103 int c;
1104 register char *yy_bp;
1105 #endif
1106         {
1107         register char *yy_cp = yy_c_buf_p;
1108
1109         /* undo effects of setting up yytext */
1110         *yy_cp = yy_hold_char;
1111
1112         if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1113                 { /* need to shift things up to make room */
1114                 /* +2 for EOB chars. */
1115                 register int number_to_move = yy_n_chars + 2;
1116                 register char *dest = &yy_current_buffer->yy_ch_buf[
1117                                         yy_current_buffer->yy_buf_size + 2];
1118                 register char *source =
1119                                 &yy_current_buffer->yy_ch_buf[number_to_move];
1120
1121                 while ( source > yy_current_buffer->yy_ch_buf )
1122                         *--dest = *--source;
1123
1124                 yy_cp += (int) (dest - source);
1125                 yy_bp += (int) (dest - source);
1126                 yy_current_buffer->yy_n_chars =
1127                         yy_n_chars = yy_current_buffer->yy_buf_size;
1128
1129                 if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
1130                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
1131                 }
1132
1133         *--yy_cp = (char) c;
1134
1135
1136         yytext_ptr = yy_bp;
1137         yy_hold_char = *yy_cp;
1138         yy_c_buf_p = yy_cp;
1139         }
1140 #endif  /* ifndef YY_NO_UNPUT */
1141
1142
1143 #ifndef YY_NO_INPUT
1144 #ifdef __cplusplus
1145 static int yyinput()
1146 #else
1147 static int input()
1148 #endif
1149         {
1150         int c;
1151
1152         *yy_c_buf_p = yy_hold_char;
1153
1154         if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1155                 {
1156                 /* yy_c_buf_p now points to the character we want to return.
1157                  * If this occurs *before* the EOB characters, then it's a
1158                  * valid NUL; if not, then we've hit the end of the buffer.
1159                  */
1160                 if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
1161                         /* This was really a NUL. */
1162                         *yy_c_buf_p = '\0';
1163
1164                 else
1165                         { /* need more input */
1166                         int offset = yy_c_buf_p - yytext_ptr;
1167                         ++yy_c_buf_p;
1168
1169                         switch ( yy_get_next_buffer() )
1170                                 {
1171                                 case EOB_ACT_LAST_MATCH:
1172                                         /* This happens because yy_g_n_b()
1173                                          * sees that we've accumulated a
1174                                          * token and flags that we need to
1175                                          * try matching the token before
1176                                          * proceeding.  But for input(),
1177                                          * there's no matching to consider.
1178                                          * So convert the EOB_ACT_LAST_MATCH
1179                                          * to EOB_ACT_END_OF_FILE.
1180                                          */
1181
1182                                         /* Reset buffer status. */
1183                                         yyrestart( yyin );
1184
1185                                         /* fall through */
1186
1187                                 case EOB_ACT_END_OF_FILE:
1188                                         {
1189                                         if ( yywrap() )
1190                                                 return EOF;
1191
1192                                         if ( ! yy_did_buffer_switch_on_eof )
1193                                                 YY_NEW_FILE;
1194 #ifdef __cplusplus
1195                                         return yyinput();
1196 #else
1197                                         return input();
1198 #endif
1199                                         }
1200
1201                                 case EOB_ACT_CONTINUE_SCAN:
1202                                         yy_c_buf_p = yytext_ptr + offset;
1203                                         break;
1204                                 }
1205                         }
1206                 }
1207
1208         c = *(unsigned char *) yy_c_buf_p;      /* cast for 8-bit char's */
1209         *yy_c_buf_p = '\0';     /* preserve yytext */
1210         yy_hold_char = *++yy_c_buf_p;
1211
1212
1213         return c;
1214         }
1215 #endif /* YY_NO_INPUT */
1216
1217 #ifdef YY_USE_PROTOS
1218 void yyrestart( FILE *input_file )
1219 #else
1220 void yyrestart( input_file )
1221 FILE *input_file;
1222 #endif
1223         {
1224         if ( ! yy_current_buffer )
1225                 yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
1226
1227         yy_init_buffer( yy_current_buffer, input_file );
1228         yy_load_buffer_state();
1229         }
1230
1231
1232 #ifdef YY_USE_PROTOS
1233 void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
1234 #else
1235 void yy_switch_to_buffer( new_buffer )
1236 YY_BUFFER_STATE new_buffer;
1237 #endif
1238         {
1239         if ( yy_current_buffer == new_buffer )
1240                 return;
1241
1242         if ( yy_current_buffer )
1243                 {
1244                 /* Flush out information for old buffer. */
1245                 *yy_c_buf_p = yy_hold_char;
1246                 yy_current_buffer->yy_buf_pos = yy_c_buf_p;
1247                 yy_current_buffer->yy_n_chars = yy_n_chars;
1248                 }
1249
1250         yy_current_buffer = new_buffer;
1251         yy_load_buffer_state();
1252
1253         /* We don't actually know whether we did this switch during
1254          * EOF (yywrap()) processing, but the only time this flag
1255          * is looked at is after yywrap() is called, so it's safe
1256          * to go ahead and always set it.
1257          */
1258         yy_did_buffer_switch_on_eof = 1;
1259         }
1260
1261
1262 #ifdef YY_USE_PROTOS
1263 void yy_load_buffer_state( void )
1264 #else
1265 void yy_load_buffer_state()
1266 #endif
1267         {
1268         yy_n_chars = yy_current_buffer->yy_n_chars;
1269         yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
1270         yyin = yy_current_buffer->yy_input_file;
1271         yy_hold_char = *yy_c_buf_p;
1272         }
1273
1274
1275 #ifdef YY_USE_PROTOS
1276 YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
1277 #else
1278 YY_BUFFER_STATE yy_create_buffer( file, size )
1279 FILE *file;
1280 int size;
1281 #endif
1282         {
1283         YY_BUFFER_STATE b;
1284
1285         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1286         if ( ! b )
1287                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1288
1289         b->yy_buf_size = size;
1290
1291         /* yy_ch_buf has to be 2 characters longer than the size given because
1292          * we need to put in 2 end-of-buffer characters.
1293          */
1294         b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
1295         if ( ! b->yy_ch_buf )
1296                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1297
1298         b->yy_is_our_buffer = 1;
1299
1300         yy_init_buffer( b, file );
1301
1302         return b;
1303         }
1304
1305
1306 #ifdef YY_USE_PROTOS
1307 void yy_delete_buffer( YY_BUFFER_STATE b )
1308 #else
1309 void yy_delete_buffer( b )
1310 YY_BUFFER_STATE b;
1311 #endif
1312         {
1313         if ( ! b )
1314                 return;
1315
1316         if ( b == yy_current_buffer )
1317                 yy_current_buffer = (YY_BUFFER_STATE) 0;
1318
1319         if ( b->yy_is_our_buffer )
1320                 yy_flex_free( (void *) b->yy_ch_buf );
1321
1322         yy_flex_free( (void *) b );
1323         }
1324
1325
1326
1327 #ifdef YY_USE_PROTOS
1328 void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
1329 #else
1330 void yy_init_buffer( b, file )
1331 YY_BUFFER_STATE b;
1332 FILE *file;
1333 #endif
1334
1335
1336         {
1337         yy_flush_buffer( b );
1338
1339         b->yy_input_file = file;
1340         b->yy_fill_buffer = 1;
1341
1342 #if YY_ALWAYS_INTERACTIVE
1343         b->yy_is_interactive = 1;
1344 #else
1345 #if YY_NEVER_INTERACTIVE
1346         b->yy_is_interactive = 0;
1347 #else
1348         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1349 #endif
1350 #endif
1351         }
1352
1353
1354 #ifdef YY_USE_PROTOS
1355 void yy_flush_buffer( YY_BUFFER_STATE b )
1356 #else
1357 void yy_flush_buffer( b )
1358 YY_BUFFER_STATE b;
1359 #endif
1360
1361         {
1362         if ( ! b )
1363                 return;
1364
1365         b->yy_n_chars = 0;
1366
1367         /* We always need two end-of-buffer characters.  The first causes
1368          * a transition to the end-of-buffer state.  The second causes
1369          * a jam in that state.
1370          */
1371         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1372         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1373
1374         b->yy_buf_pos = &b->yy_ch_buf[0];
1375
1376         b->yy_at_bol = 1;
1377         b->yy_buffer_status = YY_BUFFER_NEW;
1378
1379         if ( b == yy_current_buffer )
1380                 yy_load_buffer_state();
1381         }
1382
1383
1384 #ifndef YY_NO_SCAN_BUFFER
1385 #ifdef YY_USE_PROTOS
1386 YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
1387 #else
1388 YY_BUFFER_STATE yy_scan_buffer( base, size )
1389 char *base;
1390 yy_size_t size;
1391 #endif
1392         {
1393         YY_BUFFER_STATE b;
1394
1395         if ( size < 2 ||
1396              base[size-2] != YY_END_OF_BUFFER_CHAR ||
1397              base[size-1] != YY_END_OF_BUFFER_CHAR )
1398                 /* They forgot to leave room for the EOB's. */
1399                 return 0;
1400
1401         b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
1402         if ( ! b )
1403                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1404
1405         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
1406         b->yy_buf_pos = b->yy_ch_buf = base;
1407         b->yy_is_our_buffer = 0;
1408         b->yy_input_file = 0;
1409         b->yy_n_chars = b->yy_buf_size;
1410         b->yy_is_interactive = 0;
1411         b->yy_at_bol = 1;
1412         b->yy_fill_buffer = 0;
1413         b->yy_buffer_status = YY_BUFFER_NEW;
1414
1415         yy_switch_to_buffer( b );
1416
1417         return b;
1418         }
1419 #endif
1420
1421
1422 #ifndef YY_NO_SCAN_STRING
1423 #ifdef YY_USE_PROTOS
1424 YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
1425 #else
1426 YY_BUFFER_STATE yy_scan_string( yy_str )
1427 yyconst char *yy_str;
1428 #endif
1429         {
1430         int len;
1431         for ( len = 0; yy_str[len]; ++len )
1432                 ;
1433
1434         return yy_scan_bytes( yy_str, len );
1435         }
1436 #endif
1437
1438
1439 #ifndef YY_NO_SCAN_BYTES
1440 #ifdef YY_USE_PROTOS
1441 YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
1442 #else
1443 YY_BUFFER_STATE yy_scan_bytes( bytes, len )
1444 yyconst char *bytes;
1445 int len;
1446 #endif
1447         {
1448         YY_BUFFER_STATE b;
1449         char *buf;
1450         yy_size_t n;
1451         int i;
1452
1453         /* Get memory for full buffer, including space for trailing EOB's. */
1454         n = len + 2;
1455         buf = (char *) yy_flex_alloc( n );
1456         if ( ! buf )
1457                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1458
1459         for ( i = 0; i < len; ++i )
1460                 buf[i] = bytes[i];
1461
1462         buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
1463
1464         b = yy_scan_buffer( buf, n );
1465         if ( ! b )
1466                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1467
1468         /* It's okay to grow etc. this buffer, and we should throw it
1469          * away when we're done.
1470          */
1471         b->yy_is_our_buffer = 1;
1472
1473         return b;
1474         }
1475 #endif
1476
1477
1478 #ifndef YY_NO_PUSH_STATE
1479 #ifdef YY_USE_PROTOS
1480 static void yy_push_state( int new_state )
1481 #else
1482 static void yy_push_state( new_state )
1483 int new_state;
1484 #endif
1485         {
1486         if ( yy_start_stack_ptr >= yy_start_stack_depth )
1487                 {
1488                 yy_size_t new_size;
1489
1490                 yy_start_stack_depth += YY_START_STACK_INCR;
1491                 new_size = yy_start_stack_depth * sizeof( int );
1492
1493                 if ( ! yy_start_stack )
1494                         yy_start_stack = (int *) yy_flex_alloc( new_size );
1495
1496                 else
1497                         yy_start_stack = (int *) yy_flex_realloc(
1498                                         (void *) yy_start_stack, new_size );
1499
1500                 if ( ! yy_start_stack )
1501                         YY_FATAL_ERROR(
1502                         "out of memory expanding start-condition stack" );
1503                 }
1504
1505         yy_start_stack[yy_start_stack_ptr++] = YY_START;
1506
1507         BEGIN(new_state);
1508         }
1509 #endif
1510
1511
1512 #ifndef YY_NO_POP_STATE
1513 static void yy_pop_state()
1514         {
1515         if ( --yy_start_stack_ptr < 0 )
1516                 YY_FATAL_ERROR( "start-condition stack underflow" );
1517
1518         BEGIN(yy_start_stack[yy_start_stack_ptr]);
1519         }
1520 #endif
1521
1522
1523 #ifndef YY_NO_TOP_STATE
1524 static int yy_top_state()
1525         {
1526         return yy_start_stack[yy_start_stack_ptr - 1];
1527         }
1528 #endif
1529
1530 #ifndef YY_EXIT_FAILURE
1531 #define YY_EXIT_FAILURE 2
1532 #endif
1533
1534 #ifdef YY_USE_PROTOS
1535 static void yy_fatal_error( yyconst char msg[] )
1536 #else
1537 static void yy_fatal_error( msg )
1538 char msg[];
1539 #endif
1540         {
1541         (void) fprintf( stderr, "%s\n", msg );
1542         exit( YY_EXIT_FAILURE );
1543         }
1544
1545
1546
1547 /* Redefine yyless() so it works in section 3 code. */
1548
1549 #undef yyless
1550 #define yyless(n) \
1551         do \
1552                 { \
1553                 /* Undo effects of setting up yytext. */ \
1554                 yytext[yyleng] = yy_hold_char; \
1555                 yy_c_buf_p = yytext + n; \
1556                 yy_hold_char = *yy_c_buf_p; \
1557                 *yy_c_buf_p = '\0'; \
1558                 yyleng = n; \
1559                 } \
1560         while ( 0 )
1561
1562
1563 /* Internal utility routines. */
1564
1565 #ifndef yytext_ptr
1566 #ifdef YY_USE_PROTOS
1567 static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
1568 #else
1569 static void yy_flex_strncpy( s1, s2, n )
1570 char *s1;
1571 yyconst char *s2;
1572 int n;
1573 #endif
1574         {
1575         register int i;
1576         for ( i = 0; i < n; ++i )
1577                 s1[i] = s2[i];
1578         }
1579 #endif
1580
1581 #ifdef YY_NEED_STRLEN
1582 #ifdef YY_USE_PROTOS
1583 static int yy_flex_strlen( yyconst char *s )
1584 #else
1585 static int yy_flex_strlen( s )
1586 yyconst char *s;
1587 #endif
1588         {
1589         register int n;
1590         for ( n = 0; s[n]; ++n )
1591                 ;
1592
1593         return n;
1594         }
1595 #endif
1596
1597
1598 #ifdef YY_USE_PROTOS
1599 static void *yy_flex_alloc( yy_size_t size )
1600 #else
1601 static void *yy_flex_alloc( size )
1602 yy_size_t size;
1603 #endif
1604         {
1605         return (void *) malloc( size );
1606         }
1607
1608 #ifdef YY_USE_PROTOS
1609 static void *yy_flex_realloc( void *ptr, yy_size_t size )
1610 #else
1611 static void *yy_flex_realloc( ptr, size )
1612 void *ptr;
1613 yy_size_t size;
1614 #endif
1615         {
1616         /* The cast to (char *) in the following accommodates both
1617          * implementations that use char* generic pointers, and those
1618          * that use void* generic pointers.  It works with the latter
1619          * because both ANSI C and C++ allow castless assignment from
1620          * any pointer type to void*, and deal with argument conversions
1621          * as though doing an assignment.
1622          */
1623         return (void *) realloc( (char *) ptr, size );
1624         }
1625
1626 #ifdef YY_USE_PROTOS
1627 static void yy_flex_free( void *ptr )
1628 #else
1629 static void yy_flex_free( ptr )
1630 void *ptr;
1631 #endif
1632         {
1633         free( ptr );
1634         }
1635
1636 #if YY_MAIN
1637 int main()
1638         {
1639         yylex();
1640         return 0;
1641         }
1642 #endif
1643 #line 75 "lex.l"
1644
1645
1646 #ifndef yywrap /* XXX */
1647 int
1648 yywrap () 
1649 {
1650      return 1;
1651 }
1652 #endif
1653
1654 static int
1655 getstring(void)
1656 {
1657     char x[128];
1658     int i = 0;
1659     int c;
1660     int quote = 0;
1661     while(i < sizeof(x) - 1 && (c = input()) != EOF){
1662         if(quote) {
1663             x[i++] = c;
1664             quote = 0;
1665             continue;
1666         }
1667         if(c == '\n'){
1668             error_message("unterminated string");
1669             lineno++;
1670             break;
1671         }
1672         if(c == '\\'){
1673             quote++;
1674             continue;
1675         }
1676         if(c == '\"')
1677             break;
1678         x[i++] = c;
1679     }
1680     x[i] = '\0';
1681     yylval.string = strdup(x);
1682     if (yylval.string == NULL)
1683         err(1, "malloc");
1684     return STRING;
1685 }
1686
1687 void
1688 error_message (const char *format, ...)
1689 {
1690      va_list args;
1691
1692      va_start (args, format);
1693      fprintf (stderr, "%s:%d:", filename, lineno);
1694      vfprintf (stderr, format, args);
1695      va_end (args);
1696      numerror++;
1697 }