77e79d4eae6791bf813c7ec94b7d36ae537c4ce6
[ira/wip.git] / source / heimdal / lib / com_err / lex.c
1 #include "config.h"
2
3 #line 3 "heimdal/lib/com_err/lex.c"
4
5 #define  YY_INT_ALIGNED short int
6
7 /* A lexical scanner generated by flex */
8
9 #define FLEX_SCANNER
10 #define YY_FLEX_MAJOR_VERSION 2
11 #define YY_FLEX_MINOR_VERSION 5
12 #define YY_FLEX_SUBMINOR_VERSION 33
13 #if YY_FLEX_SUBMINOR_VERSION > 0
14 #define FLEX_BETA
15 #endif
16
17 /* First, we deal with  platform-specific or compiler-specific issues. */
18
19 /* begin standard C headers. */
20 #include <stdio.h>
21 #include <string.h>
22 #include <errno.h>
23 #include <stdlib.h>
24
25 /* end standard C headers. */
26
27 /* flex integer type definitions */
28
29 #ifndef FLEXINT_H
30 #define FLEXINT_H
31
32 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
33
34 #if __STDC_VERSION__ >= 199901L
35
36 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
37  * if you want the limit (max/min) macros for int types. 
38  */
39 #ifndef __STDC_LIMIT_MACROS
40 #define __STDC_LIMIT_MACROS 1
41 #endif
42
43 #include <inttypes.h>
44 typedef int8_t flex_int8_t;
45 typedef uint8_t flex_uint8_t;
46 typedef int16_t flex_int16_t;
47 typedef uint16_t flex_uint16_t;
48 typedef int32_t flex_int32_t;
49 typedef uint32_t flex_uint32_t;
50 #else
51 typedef signed char flex_int8_t;
52 typedef short int flex_int16_t;
53 typedef int flex_int32_t;
54 typedef unsigned char flex_uint8_t; 
55 typedef unsigned short int flex_uint16_t;
56 typedef unsigned int flex_uint32_t;
57 #endif /* ! C99 */
58
59 /* Limits of integral types. */
60 #ifndef INT8_MIN
61 #define INT8_MIN               (-128)
62 #endif
63 #ifndef INT16_MIN
64 #define INT16_MIN              (-32767-1)
65 #endif
66 #ifndef INT32_MIN
67 #define INT32_MIN              (-2147483647-1)
68 #endif
69 #ifndef INT8_MAX
70 #define INT8_MAX               (127)
71 #endif
72 #ifndef INT16_MAX
73 #define INT16_MAX              (32767)
74 #endif
75 #ifndef INT32_MAX
76 #define INT32_MAX              (2147483647)
77 #endif
78 #ifndef UINT8_MAX
79 #define UINT8_MAX              (255U)
80 #endif
81 #ifndef UINT16_MAX
82 #define UINT16_MAX             (65535U)
83 #endif
84 #ifndef UINT32_MAX
85 #define UINT32_MAX             (4294967295U)
86 #endif
87
88 #endif /* ! FLEXINT_H */
89
90 #ifdef __cplusplus
91
92 /* The "const" storage-class-modifier is valid. */
93 #define YY_USE_CONST
94
95 #else   /* ! __cplusplus */
96
97 #if __STDC__
98
99 #define YY_USE_CONST
100
101 #endif  /* __STDC__ */
102 #endif  /* ! __cplusplus */
103
104 #ifdef YY_USE_CONST
105 #define yyconst const
106 #else
107 #define yyconst
108 #endif
109
110 /* Returned upon end-of-file. */
111 #define YY_NULL 0
112
113 /* Promotes a possibly negative, possibly signed char to an unsigned
114  * integer for use as an array index.  If the signed char is negative,
115  * we want to instead treat it as an 8-bit unsigned char, hence the
116  * double cast.
117  */
118 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
119
120 /* Enter a start condition.  This macro really ought to take a parameter,
121  * but we do it the disgusting crufty way forced on us by the ()-less
122  * definition of BEGIN.
123  */
124 #define BEGIN (yy_start) = 1 + 2 *
125
126 /* Translate the current start state into a value that can be later handed
127  * to BEGIN to return to the state.  The YYSTATE alias is for lex
128  * compatibility.
129  */
130 #define YY_START (((yy_start) - 1) / 2)
131 #define YYSTATE YY_START
132
133 /* Action number for EOF rule of a given start state. */
134 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
135
136 /* Special action meaning "start processing a new file". */
137 #define YY_NEW_FILE yyrestart(yyin  )
138
139 #define YY_END_OF_BUFFER_CHAR 0
140
141 /* Size of default input buffer. */
142 #ifndef YY_BUF_SIZE
143 #define YY_BUF_SIZE 16384
144 #endif
145
146 /* The state buf must be large enough to hold one state per character in the main buffer.
147  */
148 #define YY_STATE_BUF_SIZE   ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
149
150 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
151 #define YY_TYPEDEF_YY_BUFFER_STATE
152 typedef struct yy_buffer_state *YY_BUFFER_STATE;
153 #endif
154
155 extern int yyleng;
156
157 extern FILE *yyin, *yyout;
158
159 #define EOB_ACT_CONTINUE_SCAN 0
160 #define EOB_ACT_END_OF_FILE 1
161 #define EOB_ACT_LAST_MATCH 2
162
163     #define YY_LESS_LINENO(n)
164     
165 /* Return all but the first "n" matched characters back to the input stream. */
166 #define yyless(n) \
167         do \
168                 { \
169                 /* Undo effects of setting up yytext. */ \
170         int yyless_macro_arg = (n); \
171         YY_LESS_LINENO(yyless_macro_arg);\
172                 *yy_cp = (yy_hold_char); \
173                 YY_RESTORE_YY_MORE_OFFSET \
174                 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
175                 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
176                 } \
177         while ( 0 )
178
179 #define unput(c) yyunput( c, (yytext_ptr)  )
180
181 /* The following is because we cannot portably get our hands on size_t
182  * (without autoconf's help, which isn't available because we want
183  * flex-generated scanners to compile on their own).
184  */
185
186 #ifndef YY_TYPEDEF_YY_SIZE_T
187 #define YY_TYPEDEF_YY_SIZE_T
188 typedef unsigned int yy_size_t;
189 #endif
190
191 #ifndef YY_STRUCT_YY_BUFFER_STATE
192 #define YY_STRUCT_YY_BUFFER_STATE
193 struct yy_buffer_state
194         {
195         FILE *yy_input_file;
196
197         char *yy_ch_buf;                /* input buffer */
198         char *yy_buf_pos;               /* current position in input buffer */
199
200         /* Size of input buffer in bytes, not including room for EOB
201          * characters.
202          */
203         yy_size_t yy_buf_size;
204
205         /* Number of characters read into yy_ch_buf, not including EOB
206          * characters.
207          */
208         int yy_n_chars;
209
210         /* Whether we "own" the buffer - i.e., we know we created it,
211          * and can realloc() it to grow it, and should free() it to
212          * delete it.
213          */
214         int yy_is_our_buffer;
215
216         /* Whether this is an "interactive" input source; if so, and
217          * if we're using stdio for input, then we want to use getc()
218          * instead of fread(), to make sure we stop fetching input after
219          * each newline.
220          */
221         int yy_is_interactive;
222
223         /* Whether we're considered to be at the beginning of a line.
224          * If so, '^' rules will be active on the next match, otherwise
225          * not.
226          */
227         int yy_at_bol;
228
229     int yy_bs_lineno; /**< The line count. */
230     int yy_bs_column; /**< The column count. */
231     
232         /* Whether to try to fill the input buffer when we reach the
233          * end of it.
234          */
235         int yy_fill_buffer;
236
237         int yy_buffer_status;
238
239 #define YY_BUFFER_NEW 0
240 #define YY_BUFFER_NORMAL 1
241         /* When an EOF's been seen but there's still some text to process
242          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
243          * shouldn't try reading from the input source any more.  We might
244          * still have a bunch of tokens to match, though, because of
245          * possible backing-up.
246          *
247          * When we actually see the EOF, we change the status to "new"
248          * (via yyrestart()), so that the user can continue scanning by
249          * just pointing yyin at a new input file.
250          */
251 #define YY_BUFFER_EOF_PENDING 2
252
253         };
254 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
255
256 /* Stack of input buffers. */
257 static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
258 static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
259 static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
260
261 /* We provide macros for accessing buffer states in case in the
262  * future we want to put the buffer states in a more general
263  * "scanner state".
264  *
265  * Returns the top of the stack, or NULL.
266  */
267 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
268                           ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
269                           : NULL)
270
271 /* Same as previous macro, but useful when we know that the buffer stack is not
272  * NULL or when we need an lvalue. For internal use only.
273  */
274 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
275
276 /* yy_hold_char holds the character lost when yytext is formed. */
277 static char yy_hold_char;
278 static int yy_n_chars;          /* number of characters read into yy_ch_buf */
279 int yyleng;
280
281 /* Points to current character in buffer. */
282 static char *yy_c_buf_p = (char *) 0;
283 static int yy_init = 0;         /* whether we need to initialize */
284 static int yy_start = 0;        /* start state number */
285
286 /* Flag which is used to allow yywrap()'s to do buffer switches
287  * instead of setting up a fresh yyin.  A bit of a hack ...
288  */
289 static int yy_did_buffer_switch_on_eof;
290
291 void yyrestart (FILE *input_file  );
292 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
293 YY_BUFFER_STATE yy_create_buffer (FILE *file,int size  );
294 void yy_delete_buffer (YY_BUFFER_STATE b  );
295 void yy_flush_buffer (YY_BUFFER_STATE b  );
296 void yypush_buffer_state (YY_BUFFER_STATE new_buffer  );
297 void yypop_buffer_state (void );
298
299 static void yyensure_buffer_stack (void );
300 static void yy_load_buffer_state (void );
301 static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file  );
302
303 #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
304
305 YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size  );
306 YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str  );
307 YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len  );
308
309 void *yyalloc (yy_size_t  );
310 void *yyrealloc (void *,yy_size_t  );
311 void yyfree (void *  );
312
313 #define yy_new_buffer yy_create_buffer
314
315 #define yy_set_interactive(is_interactive) \
316         { \
317         if ( ! YY_CURRENT_BUFFER ){ \
318         yyensure_buffer_stack (); \
319                 YY_CURRENT_BUFFER_LVALUE =    \
320             yy_create_buffer(yyin,YY_BUF_SIZE ); \
321         } \
322         YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
323         }
324
325 #define yy_set_bol(at_bol) \
326         { \
327         if ( ! YY_CURRENT_BUFFER ){\
328         yyensure_buffer_stack (); \
329                 YY_CURRENT_BUFFER_LVALUE =    \
330             yy_create_buffer(yyin,YY_BUF_SIZE ); \
331         } \
332         YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
333         }
334
335 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
336
337 /* Begin user sect3 */
338
339 typedef unsigned char YY_CHAR;
340
341 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
342
343 typedef int yy_state_type;
344
345 extern int yylineno;
346 extern char *yytext;
347 #define yytext_ptr yytext
348
349 static yy_state_type yy_get_previous_state (void );
350 static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
351 static int yy_get_next_buffer (void );
352 static void yy_fatal_error (yyconst char msg[]  );
353
354 /* Done after the current pattern has been matched and before the
355  * corresponding action - sets up yytext.
356  */
357 #define YY_DO_BEFORE_ACTION \
358         (yytext_ptr) = yy_bp; \
359         yyleng = (size_t) (yy_cp - yy_bp); \
360         (yy_hold_char) = *yy_cp; \
361         *yy_cp = '\0'; \
362         (yy_c_buf_p) = yy_cp;
363
364 #define YY_NUM_RULES 16
365 #define YY_END_OF_BUFFER 17
366 /* This struct is not used in this scanner,
367    but its presence is necessary. */
368 struct yy_trans_info
369         {
370         flex_int32_t yy_verify;
371         flex_int32_t yy_nxt;
372         };
373 static yyconst flex_int16_t yy_accept[46] =
374     {   0,
375         0,    0,   17,   15,   11,   12,   13,   10,    9,   14,
376        14,   14,   14,   10,    9,   14,    3,   14,   14,    1,
377         7,   14,   14,    8,   14,   14,   14,   14,   14,   14,
378        14,    6,   14,   14,    5,   14,   14,   14,   14,   14,
379        14,    4,   14,    2,    0
380     } ;
381
382 static yyconst flex_int32_t yy_ec[256] =
383     {   0,
384         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
385         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
386         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
387         1,    2,    1,    4,    5,    1,    1,    1,    1,    1,
388         1,    1,    1,    1,    1,    1,    1,    6,    6,    6,
389         6,    6,    6,    6,    6,    6,    6,    1,    1,    1,
390         1,    1,    1,    1,    7,    7,    7,    7,    7,    7,
391         7,    7,    7,    7,    7,    7,    7,    7,    7,    7,
392         7,    7,    7,    7,    7,    7,    7,    7,    7,    7,
393         1,    1,    1,    1,    8,    1,    9,   10,   11,   12,
394
395        13,   14,    7,    7,   15,    7,    7,   16,    7,   17,
396        18,   19,    7,   20,    7,   21,    7,    7,    7,   22,
397         7,    7,    1,    1,    1,    1,    1,    1,    1,    1,
398         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
399         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
400         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
401         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
402         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
403         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
404         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
405
406         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
407         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
408         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
409         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
410         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
411         1,    1,    1,    1,    1
412     } ;
413
414 static yyconst flex_int32_t yy_meta[23] =
415     {   0,
416         1,    1,    2,    1,    1,    3,    3,    3,    3,    3,
417         3,    3,    3,    3,    3,    3,    3,    3,    3,    3,
418         3,    3
419     } ;
420
421 static yyconst flex_int16_t yy_base[48] =
422     {   0,
423         0,    0,   56,   57,   57,   57,   57,    0,   49,    0,
424        12,   13,   34,    0,   47,    0,    0,   40,   31,    0,
425         0,   38,   36,    0,   30,   34,   32,   25,   22,   28,
426        34,    0,   19,   13,    0,   22,   30,   26,   26,   18,
427        12,    0,   14,    0,   57,   34,   23
428     } ;
429
430 static yyconst flex_int16_t yy_def[48] =
431     {   0,
432        45,    1,   45,   45,   45,   45,   45,   46,   47,   47,
433        47,   47,   47,   46,   47,   47,   47,   47,   47,   47,
434        47,   47,   47,   47,   47,   47,   47,   47,   47,   47,
435        47,   47,   47,   47,   47,   47,   47,   47,   47,   47,
436        47,   47,   47,   47,    0,   45,   45
437     } ;
438
439 static yyconst flex_int16_t yy_nxt[80] =
440     {   0,
441         4,    5,    6,    7,    8,    9,   10,   10,   10,   10,
442        10,   10,   11,   10,   12,   10,   10,   10,   13,   10,
443        10,   10,   17,   36,   21,   16,   44,   43,   18,   22,
444        42,   19,   20,   37,   14,   41,   14,   40,   39,   38,
445        35,   34,   33,   32,   31,   30,   29,   28,   27,   26,
446        25,   24,   15,   23,   15,   45,    3,   45,   45,   45,
447        45,   45,   45,   45,   45,   45,   45,   45,   45,   45,
448        45,   45,   45,   45,   45,   45,   45,   45,   45
449     } ;
450
451 static yyconst flex_int16_t yy_chk[80] =
452     {   0,
453         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
454         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
455         1,    1,   11,   34,   12,   47,   43,   41,   11,   12,
456        40,   11,   11,   34,   46,   39,   46,   38,   37,   36,
457        33,   31,   30,   29,   28,   27,   26,   25,   23,   22,
458        19,   18,   15,   13,    9,    3,   45,   45,   45,   45,
459        45,   45,   45,   45,   45,   45,   45,   45,   45,   45,
460        45,   45,   45,   45,   45,   45,   45,   45,   45
461     } ;
462
463 static yy_state_type yy_last_accepting_state;
464 static char *yy_last_accepting_cpos;
465
466 extern int yy_flex_debug;
467 int yy_flex_debug = 0;
468
469 /* The intent behind this definition is that it'll catch
470  * any uses of REJECT which flex missed.
471  */
472 #define REJECT reject_used_but_not_detected
473 #define yymore() yymore_used_but_not_detected
474 #define YY_MORE_ADJ 0
475 #define YY_RESTORE_YY_MORE_OFFSET
476 char *yytext;
477 #line 1 "lex.l"
478 #line 2 "lex.l"
479 /*
480  * Copyright (c) 1998 - 2000 Kungliga Tekniska Högskolan
481  * (Royal Institute of Technology, Stockholm, Sweden). 
482  * All rights reserved. 
483  *
484  * Redistribution and use in source and binary forms, with or without 
485  * modification, are permitted provided that the following conditions 
486  * are met: 
487  *
488  * 1. Redistributions of source code must retain the above copyright 
489  *    notice, this list of conditions and the following disclaimer. 
490  *
491  * 2. Redistributions in binary form must reproduce the above copyright 
492  *    notice, this list of conditions and the following disclaimer in the 
493  *    documentation and/or other materials provided with the distribution. 
494  *
495  * 3. Neither the name of the Institute nor the names of its contributors 
496  *    may be used to endorse or promote products derived from this software 
497  *    without specific prior written permission. 
498  *
499  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND 
500  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
501  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 
502  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE 
503  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 
504  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 
505  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
506  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 
507  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 
508  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
509  * SUCH DAMAGE. 
510  */
511
512 /*
513  * This is to handle the definition of this symbol in some AIX
514  * headers, which will conflict with the definition that lex will
515  * generate for it.  It's only a problem for AIX lex.
516  */
517
518 #undef ECHO
519
520 #include "compile_et.h"
521 #include "parse.h"
522 #include "lex.h"
523
524 RCSID("$Id: lex.l,v 1.8 2005/05/16 08:52:54 lha Exp $");
525
526 static unsigned lineno = 1;
527 static int getstring(void);
528
529 #define YY_NO_UNPUT
530
531 #undef ECHO
532
533 #line 533 "heimdal/lib/com_err/lex.c"
534
535 #define INITIAL 0
536
537 #ifndef YY_NO_UNISTD_H
538 /* Special case for "unistd.h", since it is non-ANSI. We include it way
539  * down here because we want the user's section 1 to have been scanned first.
540  * The user has a chance to override it with an option.
541  */
542 #include <unistd.h>
543 #endif
544
545 #ifndef YY_EXTRA_TYPE
546 #define YY_EXTRA_TYPE void *
547 #endif
548
549 static int yy_init_globals (void );
550
551 /* Macros after this point can all be overridden by user definitions in
552  * section 1.
553  */
554
555 #ifndef YY_SKIP_YYWRAP
556 #ifdef __cplusplus
557 extern "C" int yywrap (void );
558 #else
559 extern int yywrap (void );
560 #endif
561 #endif
562
563     static void yyunput (int c,char *buf_ptr  );
564     
565 #ifndef yytext_ptr
566 static void yy_flex_strncpy (char *,yyconst char *,int );
567 #endif
568
569 #ifdef YY_NEED_STRLEN
570 static int yy_flex_strlen (yyconst char * );
571 #endif
572
573 #ifndef YY_NO_INPUT
574
575 #ifdef __cplusplus
576 static int yyinput (void );
577 #else
578 static int input (void );
579 #endif
580
581 #endif
582
583 /* Amount of stuff to slurp up with each read. */
584 #ifndef YY_READ_BUF_SIZE
585 #define YY_READ_BUF_SIZE 8192
586 #endif
587
588 /* Copy whatever the last rule matched to the standard output. */
589 #ifndef ECHO
590 /* This used to be an fputs(), but since the string might contain NUL's,
591  * we now use fwrite().
592  */
593 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
594 #endif
595
596 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
597  * is returned in "result".
598  */
599 #ifndef YY_INPUT
600 #define YY_INPUT(buf,result,max_size) \
601         if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
602                 { \
603                 int c = '*'; \
604                 size_t n; \
605                 for ( n = 0; n < max_size && \
606                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
607                         buf[n] = (char) c; \
608                 if ( c == '\n' ) \
609                         buf[n++] = (char) c; \
610                 if ( c == EOF && ferror( yyin ) ) \
611                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
612                 result = n; \
613                 } \
614         else \
615                 { \
616                 errno=0; \
617                 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
618                         { \
619                         if( errno != EINTR) \
620                                 { \
621                                 YY_FATAL_ERROR( "input in flex scanner failed" ); \
622                                 break; \
623                                 } \
624                         errno=0; \
625                         clearerr(yyin); \
626                         } \
627                 }\
628 \
629
630 #endif
631
632 /* No semi-colon after return; correct usage is to write "yyterminate();" -
633  * we don't want an extra ';' after the "return" because that will cause
634  * some compilers to complain about unreachable statements.
635  */
636 #ifndef yyterminate
637 #define yyterminate() return YY_NULL
638 #endif
639
640 /* Number of entries by which start-condition stack grows. */
641 #ifndef YY_START_STACK_INCR
642 #define YY_START_STACK_INCR 25
643 #endif
644
645 /* Report a fatal error. */
646 #ifndef YY_FATAL_ERROR
647 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
648 #endif
649
650 /* end tables serialization structures and prototypes */
651
652 /* Default declaration of generated scanner - a define so the user can
653  * easily add parameters.
654  */
655 #ifndef YY_DECL
656 #define YY_DECL_IS_OURS 1
657
658 extern int yylex (void);
659
660 #define YY_DECL int yylex (void)
661 #endif /* !YY_DECL */
662
663 /* Code executed at the beginning of each rule, after yytext and yyleng
664  * have been set up.
665  */
666 #ifndef YY_USER_ACTION
667 #define YY_USER_ACTION
668 #endif
669
670 /* Code executed at the end of each rule. */
671 #ifndef YY_BREAK
672 #define YY_BREAK break;
673 #endif
674
675 #define YY_RULE_SETUP \
676         YY_USER_ACTION
677
678 /** The main scanner function which does all the work.
679  */
680 YY_DECL
681 {
682         register yy_state_type yy_current_state;
683         register char *yy_cp, *yy_bp;
684         register int yy_act;
685     
686 #line 59 "lex.l"
687
688 #line 688 "heimdal/lib/com_err/lex.c"
689
690         if ( !(yy_init) )
691                 {
692                 (yy_init) = 1;
693
694 #ifdef YY_USER_INIT
695                 YY_USER_INIT;
696 #endif
697
698                 if ( ! (yy_start) )
699                         (yy_start) = 1; /* first start state */
700
701                 if ( ! yyin )
702                         yyin = stdin;
703
704                 if ( ! yyout )
705                         yyout = stdout;
706
707                 if ( ! YY_CURRENT_BUFFER ) {
708                         yyensure_buffer_stack ();
709                         YY_CURRENT_BUFFER_LVALUE =
710                                 yy_create_buffer(yyin,YY_BUF_SIZE );
711                 }
712
713                 yy_load_buffer_state( );
714                 }
715
716         while ( 1 )             /* loops until end-of-file is reached */
717                 {
718                 yy_cp = (yy_c_buf_p);
719
720                 /* Support of yytext. */
721                 *yy_cp = (yy_hold_char);
722
723                 /* yy_bp points to the position in yy_ch_buf of the start of
724                  * the current run.
725                  */
726                 yy_bp = yy_cp;
727
728                 yy_current_state = (yy_start);
729 yy_match:
730                 do
731                         {
732                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
733                         if ( yy_accept[yy_current_state] )
734                                 {
735                                 (yy_last_accepting_state) = yy_current_state;
736                                 (yy_last_accepting_cpos) = yy_cp;
737                                 }
738                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
739                                 {
740                                 yy_current_state = (int) yy_def[yy_current_state];
741                                 if ( yy_current_state >= 46 )
742                                         yy_c = yy_meta[(unsigned int) yy_c];
743                                 }
744                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
745                         ++yy_cp;
746                         }
747                 while ( yy_base[yy_current_state] != 57 );
748
749 yy_find_action:
750                 yy_act = yy_accept[yy_current_state];
751                 if ( yy_act == 0 )
752                         { /* have to back up */
753                         yy_cp = (yy_last_accepting_cpos);
754                         yy_current_state = (yy_last_accepting_state);
755                         yy_act = yy_accept[yy_current_state];
756                         }
757
758                 YY_DO_BEFORE_ACTION;
759
760 do_action:      /* This label is used only to access EOF actions. */
761
762                 switch ( yy_act )
763         { /* beginning of action switch */
764                         case 0: /* must back up */
765                         /* undo the effects of YY_DO_BEFORE_ACTION */
766                         *yy_cp = (yy_hold_char);
767                         yy_cp = (yy_last_accepting_cpos);
768                         yy_current_state = (yy_last_accepting_state);
769                         goto yy_find_action;
770
771 case 1:
772 YY_RULE_SETUP
773 #line 60 "lex.l"
774 { return ET; }
775         YY_BREAK
776 case 2:
777 YY_RULE_SETUP
778 #line 61 "lex.l"
779 { return ET; }
780         YY_BREAK
781 case 3:
782 YY_RULE_SETUP
783 #line 62 "lex.l"
784 { return EC; }
785         YY_BREAK
786 case 4:
787 YY_RULE_SETUP
788 #line 63 "lex.l"
789 { return EC; }
790         YY_BREAK
791 case 5:
792 YY_RULE_SETUP
793 #line 64 "lex.l"
794 { return PREFIX; }
795         YY_BREAK
796 case 6:
797 YY_RULE_SETUP
798 #line 65 "lex.l"
799 { return INDEX; }
800         YY_BREAK
801 case 7:
802 YY_RULE_SETUP
803 #line 66 "lex.l"
804 { return ID; }
805         YY_BREAK
806 case 8:
807 YY_RULE_SETUP
808 #line 67 "lex.l"
809 { return END; }
810         YY_BREAK
811 case 9:
812 YY_RULE_SETUP
813 #line 68 "lex.l"
814 { yylval.number = atoi(yytext); return NUMBER; }
815         YY_BREAK
816 case 10:
817 YY_RULE_SETUP
818 #line 69 "lex.l"
819 ;
820         YY_BREAK
821 case 11:
822 YY_RULE_SETUP
823 #line 70 "lex.l"
824 ;
825         YY_BREAK
826 case 12:
827 /* rule 12 can match eol */
828 YY_RULE_SETUP
829 #line 71 "lex.l"
830 { lineno++; }
831         YY_BREAK
832 case 13:
833 YY_RULE_SETUP
834 #line 72 "lex.l"
835 { return getstring(); }
836         YY_BREAK
837 case 14:
838 YY_RULE_SETUP
839 #line 73 "lex.l"
840 { yylval.string = strdup(yytext); return STRING; }
841         YY_BREAK
842 case 15:
843 YY_RULE_SETUP
844 #line 74 "lex.l"
845 { return *yytext; }
846         YY_BREAK
847 case 16:
848 YY_RULE_SETUP
849 #line 75 "lex.l"
850 ECHO;
851         YY_BREAK
852 #line 852 "heimdal/lib/com_err/lex.c"
853 case YY_STATE_EOF(INITIAL):
854         yyterminate();
855
856         case YY_END_OF_BUFFER:
857                 {
858                 /* Amount of text matched not including the EOB char. */
859                 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
860
861                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
862                 *yy_cp = (yy_hold_char);
863                 YY_RESTORE_YY_MORE_OFFSET
864
865                 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
866                         {
867                         /* We're scanning a new file or input source.  It's
868                          * possible that this happened because the user
869                          * just pointed yyin at a new source and called
870                          * yylex().  If so, then we have to assure
871                          * consistency between YY_CURRENT_BUFFER and our
872                          * globals.  Here is the right place to do so, because
873                          * this is the first action (other than possibly a
874                          * back-up) that will match for the new input source.
875                          */
876                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
877                         YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
878                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
879                         }
880
881                 /* Note that here we test for yy_c_buf_p "<=" to the position
882                  * of the first EOB in the buffer, since yy_c_buf_p will
883                  * already have been incremented past the NUL character
884                  * (since all states make transitions on EOB to the
885                  * end-of-buffer state).  Contrast this with the test
886                  * in input().
887                  */
888                 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
889                         { /* This was really a NUL. */
890                         yy_state_type yy_next_state;
891
892                         (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
893
894                         yy_current_state = yy_get_previous_state(  );
895
896                         /* Okay, we're now positioned to make the NUL
897                          * transition.  We couldn't have
898                          * yy_get_previous_state() go ahead and do it
899                          * for us because it doesn't know how to deal
900                          * with the possibility of jamming (and we don't
901                          * want to build jamming into it because then it
902                          * will run more slowly).
903                          */
904
905                         yy_next_state = yy_try_NUL_trans( yy_current_state );
906
907                         yy_bp = (yytext_ptr) + YY_MORE_ADJ;
908
909                         if ( yy_next_state )
910                                 {
911                                 /* Consume the NUL. */
912                                 yy_cp = ++(yy_c_buf_p);
913                                 yy_current_state = yy_next_state;
914                                 goto yy_match;
915                                 }
916
917                         else
918                                 {
919                                 yy_cp = (yy_c_buf_p);
920                                 goto yy_find_action;
921                                 }
922                         }
923
924                 else switch ( yy_get_next_buffer(  ) )
925                         {
926                         case EOB_ACT_END_OF_FILE:
927                                 {
928                                 (yy_did_buffer_switch_on_eof) = 0;
929
930                                 if ( yywrap( ) )
931                                         {
932                                         /* Note: because we've taken care in
933                                          * yy_get_next_buffer() to have set up
934                                          * yytext, we can now set up
935                                          * yy_c_buf_p so that if some total
936                                          * hoser (like flex itself) wants to
937                                          * call the scanner after we return the
938                                          * YY_NULL, it'll still work - another
939                                          * YY_NULL will get returned.
940                                          */
941                                         (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
942
943                                         yy_act = YY_STATE_EOF(YY_START);
944                                         goto do_action;
945                                         }
946
947                                 else
948                                         {
949                                         if ( ! (yy_did_buffer_switch_on_eof) )
950                                                 YY_NEW_FILE;
951                                         }
952                                 break;
953                                 }
954
955                         case EOB_ACT_CONTINUE_SCAN:
956                                 (yy_c_buf_p) =
957                                         (yytext_ptr) + yy_amount_of_matched_text;
958
959                                 yy_current_state = yy_get_previous_state(  );
960
961                                 yy_cp = (yy_c_buf_p);
962                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
963                                 goto yy_match;
964
965                         case EOB_ACT_LAST_MATCH:
966                                 (yy_c_buf_p) =
967                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
968
969                                 yy_current_state = yy_get_previous_state(  );
970
971                                 yy_cp = (yy_c_buf_p);
972                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
973                                 goto yy_find_action;
974                         }
975                 break;
976                 }
977
978         default:
979                 YY_FATAL_ERROR(
980                         "fatal flex scanner internal error--no action found" );
981         } /* end of action switch */
982                 } /* end of scanning one token */
983 } /* end of yylex */
984
985 /* yy_get_next_buffer - try to read in a new buffer
986  *
987  * Returns a code representing an action:
988  *      EOB_ACT_LAST_MATCH -
989  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
990  *      EOB_ACT_END_OF_FILE - end of file
991  */
992 static int yy_get_next_buffer (void)
993 {
994         register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
995         register char *source = (yytext_ptr);
996         register int number_to_move, i;
997         int ret_val;
998
999         if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1000                 YY_FATAL_ERROR(
1001                 "fatal flex scanner internal error--end of buffer missed" );
1002
1003         if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1004                 { /* Don't try to fill the buffer, so this is an EOF. */
1005                 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1006                         {
1007                         /* We matched a single character, the EOB, so
1008                          * treat this as a final EOF.
1009                          */
1010                         return EOB_ACT_END_OF_FILE;
1011                         }
1012
1013                 else
1014                         {
1015                         /* We matched some text prior to the EOB, first
1016                          * process it.
1017                          */
1018                         return EOB_ACT_LAST_MATCH;
1019                         }
1020                 }
1021
1022         /* Try to read more data. */
1023
1024         /* First move last chars to start of buffer. */
1025         number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1026
1027         for ( i = 0; i < number_to_move; ++i )
1028                 *(dest++) = *(source++);
1029
1030         if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1031                 /* don't do the read, it's not guaranteed to return an EOF,
1032                  * just force an EOF
1033                  */
1034                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1035
1036         else
1037                 {
1038                         int num_to_read =
1039                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1040
1041                 while ( num_to_read <= 0 )
1042                         { /* Not enough room in the buffer - grow it. */
1043
1044                         /* just a shorter name for the current buffer */
1045                         YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1046
1047                         int yy_c_buf_p_offset =
1048                                 (int) ((yy_c_buf_p) - b->yy_ch_buf);
1049
1050                         if ( b->yy_is_our_buffer )
1051                                 {
1052                                 int new_size = b->yy_buf_size * 2;
1053
1054                                 if ( new_size <= 0 )
1055                                         b->yy_buf_size += b->yy_buf_size / 8;
1056                                 else
1057                                         b->yy_buf_size *= 2;
1058
1059                                 b->yy_ch_buf = (char *)
1060                                         /* Include room in for 2 EOB chars. */
1061                                         yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
1062                                 }
1063                         else
1064                                 /* Can't grow it, we don't own it. */
1065                                 b->yy_ch_buf = 0;
1066
1067                         if ( ! b->yy_ch_buf )
1068                                 YY_FATAL_ERROR(
1069                                 "fatal error - scanner input buffer overflow" );
1070
1071                         (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1072
1073                         num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1074                                                 number_to_move - 1;
1075
1076                         }
1077
1078                 if ( num_to_read > YY_READ_BUF_SIZE )
1079                         num_to_read = YY_READ_BUF_SIZE;
1080
1081                 /* Read in more data. */
1082                 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1083                         (yy_n_chars), num_to_read );
1084
1085                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1086                 }
1087
1088         if ( (yy_n_chars) == 0 )
1089                 {
1090                 if ( number_to_move == YY_MORE_ADJ )
1091                         {
1092                         ret_val = EOB_ACT_END_OF_FILE;
1093                         yyrestart(yyin  );
1094                         }
1095
1096                 else
1097                         {
1098                         ret_val = EOB_ACT_LAST_MATCH;
1099                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1100                                 YY_BUFFER_EOF_PENDING;
1101                         }
1102                 }
1103
1104         else
1105                 ret_val = EOB_ACT_CONTINUE_SCAN;
1106
1107         (yy_n_chars) += number_to_move;
1108         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1109         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1110
1111         (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1112
1113         return ret_val;
1114 }
1115
1116 /* yy_get_previous_state - get the state just before the EOB char was reached */
1117
1118     static yy_state_type yy_get_previous_state (void)
1119 {
1120         register yy_state_type yy_current_state;
1121         register char *yy_cp;
1122     
1123         yy_current_state = (yy_start);
1124
1125         for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1126                 {
1127                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1128                 if ( yy_accept[yy_current_state] )
1129                         {
1130                         (yy_last_accepting_state) = yy_current_state;
1131                         (yy_last_accepting_cpos) = yy_cp;
1132                         }
1133                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1134                         {
1135                         yy_current_state = (int) yy_def[yy_current_state];
1136                         if ( yy_current_state >= 46 )
1137                                 yy_c = yy_meta[(unsigned int) yy_c];
1138                         }
1139                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1140                 }
1141
1142         return yy_current_state;
1143 }
1144
1145 /* yy_try_NUL_trans - try to make a transition on the NUL character
1146  *
1147  * synopsis
1148  *      next_state = yy_try_NUL_trans( current_state );
1149  */
1150     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
1151 {
1152         register int yy_is_jam;
1153         register char *yy_cp = (yy_c_buf_p);
1154
1155         register YY_CHAR yy_c = 1;
1156         if ( yy_accept[yy_current_state] )
1157                 {
1158                 (yy_last_accepting_state) = yy_current_state;
1159                 (yy_last_accepting_cpos) = yy_cp;
1160                 }
1161         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1162                 {
1163                 yy_current_state = (int) yy_def[yy_current_state];
1164                 if ( yy_current_state >= 46 )
1165                         yy_c = yy_meta[(unsigned int) yy_c];
1166                 }
1167         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1168         yy_is_jam = (yy_current_state == 45);
1169
1170         return yy_is_jam ? 0 : yy_current_state;
1171 }
1172
1173     static void yyunput (int c, register char * yy_bp )
1174 {
1175         register char *yy_cp;
1176     
1177     yy_cp = (yy_c_buf_p);
1178
1179         /* undo effects of setting up yytext */
1180         *yy_cp = (yy_hold_char);
1181
1182         if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1183                 { /* need to shift things up to make room */
1184                 /* +2 for EOB chars. */
1185                 register int number_to_move = (yy_n_chars) + 2;
1186                 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1187                                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1188                 register char *source =
1189                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1190
1191                 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1192                         *--dest = *--source;
1193
1194                 yy_cp += (int) (dest - source);
1195                 yy_bp += (int) (dest - source);
1196                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1197                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1198
1199                 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1200                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
1201                 }
1202
1203         *--yy_cp = (char) c;
1204
1205         (yytext_ptr) = yy_bp;
1206         (yy_hold_char) = *yy_cp;
1207         (yy_c_buf_p) = yy_cp;
1208 }
1209
1210 #ifndef YY_NO_INPUT
1211 #ifdef __cplusplus
1212     static int yyinput (void)
1213 #else
1214     static int input  (void)
1215 #endif
1216
1217 {
1218         int c;
1219     
1220         *(yy_c_buf_p) = (yy_hold_char);
1221
1222         if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1223                 {
1224                 /* yy_c_buf_p now points to the character we want to return.
1225                  * If this occurs *before* the EOB characters, then it's a
1226                  * valid NUL; if not, then we've hit the end of the buffer.
1227                  */
1228                 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1229                         /* This was really a NUL. */
1230                         *(yy_c_buf_p) = '\0';
1231
1232                 else
1233                         { /* need more input */
1234                         int offset = (yy_c_buf_p) - (yytext_ptr);
1235                         ++(yy_c_buf_p);
1236
1237                         switch ( yy_get_next_buffer(  ) )
1238                                 {
1239                                 case EOB_ACT_LAST_MATCH:
1240                                         /* This happens because yy_g_n_b()
1241                                          * sees that we've accumulated a
1242                                          * token and flags that we need to
1243                                          * try matching the token before
1244                                          * proceeding.  But for input(),
1245                                          * there's no matching to consider.
1246                                          * So convert the EOB_ACT_LAST_MATCH
1247                                          * to EOB_ACT_END_OF_FILE.
1248                                          */
1249
1250                                         /* Reset buffer status. */
1251                                         yyrestart(yyin );
1252
1253                                         /*FALLTHROUGH*/
1254
1255                                 case EOB_ACT_END_OF_FILE:
1256                                         {
1257                                         if ( yywrap( ) )
1258                                                 return EOF;
1259
1260                                         if ( ! (yy_did_buffer_switch_on_eof) )
1261                                                 YY_NEW_FILE;
1262 #ifdef __cplusplus
1263                                         return yyinput();
1264 #else
1265                                         return input();
1266 #endif
1267                                         }
1268
1269                                 case EOB_ACT_CONTINUE_SCAN:
1270                                         (yy_c_buf_p) = (yytext_ptr) + offset;
1271                                         break;
1272                                 }
1273                         }
1274                 }
1275
1276         c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
1277         *(yy_c_buf_p) = '\0';   /* preserve yytext */
1278         (yy_hold_char) = *++(yy_c_buf_p);
1279
1280         return c;
1281 }
1282 #endif  /* ifndef YY_NO_INPUT */
1283
1284 /** Immediately switch to a different input stream.
1285  * @param input_file A readable stream.
1286  * 
1287  * @note This function does not reset the start condition to @c INITIAL .
1288  */
1289     void yyrestart  (FILE * input_file )
1290 {
1291     
1292         if ( ! YY_CURRENT_BUFFER ){
1293         yyensure_buffer_stack ();
1294                 YY_CURRENT_BUFFER_LVALUE =
1295             yy_create_buffer(yyin,YY_BUF_SIZE );
1296         }
1297
1298         yy_init_buffer(YY_CURRENT_BUFFER,input_file );
1299         yy_load_buffer_state( );
1300 }
1301
1302 /** Switch to a different input buffer.
1303  * @param new_buffer The new input buffer.
1304  * 
1305  */
1306     void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
1307 {
1308     
1309         /* TODO. We should be able to replace this entire function body
1310          * with
1311          *              yypop_buffer_state();
1312          *              yypush_buffer_state(new_buffer);
1313      */
1314         yyensure_buffer_stack ();
1315         if ( YY_CURRENT_BUFFER == new_buffer )
1316                 return;
1317
1318         if ( YY_CURRENT_BUFFER )
1319                 {
1320                 /* Flush out information for old buffer. */
1321                 *(yy_c_buf_p) = (yy_hold_char);
1322                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1323                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1324                 }
1325
1326         YY_CURRENT_BUFFER_LVALUE = new_buffer;
1327         yy_load_buffer_state( );
1328
1329         /* We don't actually know whether we did this switch during
1330          * EOF (yywrap()) processing, but the only time this flag
1331          * is looked at is after yywrap() is called, so it's safe
1332          * to go ahead and always set it.
1333          */
1334         (yy_did_buffer_switch_on_eof) = 1;
1335 }
1336
1337 static void yy_load_buffer_state  (void)
1338 {
1339         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1340         (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1341         yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1342         (yy_hold_char) = *(yy_c_buf_p);
1343 }
1344
1345 /** Allocate and initialize an input buffer state.
1346  * @param file A readable stream.
1347  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1348  * 
1349  * @return the allocated buffer state.
1350  */
1351     YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size )
1352 {
1353         YY_BUFFER_STATE b;
1354     
1355         b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
1356         if ( ! b )
1357                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1358
1359         b->yy_buf_size = size;
1360
1361         /* yy_ch_buf has to be 2 characters longer than the size given because
1362          * we need to put in 2 end-of-buffer characters.
1363          */
1364         b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2  );
1365         if ( ! b->yy_ch_buf )
1366                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1367
1368         b->yy_is_our_buffer = 1;
1369
1370         yy_init_buffer(b,file );
1371
1372         return b;
1373 }
1374
1375 /** Destroy the buffer.
1376  * @param b a buffer created with yy_create_buffer()
1377  * 
1378  */
1379     void yy_delete_buffer (YY_BUFFER_STATE  b )
1380 {
1381     
1382         if ( ! b )
1383                 return;
1384
1385         if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1386                 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1387
1388         if ( b->yy_is_our_buffer )
1389                 yyfree((void *) b->yy_ch_buf  );
1390
1391         yyfree((void *) b  );
1392 }
1393
1394 #ifndef __cplusplus
1395 extern int isatty (int );
1396 #endif /* __cplusplus */
1397     
1398 /* Initializes or reinitializes a buffer.
1399  * This function is sometimes called more than once on the same buffer,
1400  * such as during a yyrestart() or at EOF.
1401  */
1402     static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
1403
1404 {
1405         int oerrno = errno;
1406     
1407         yy_flush_buffer(b );
1408
1409         b->yy_input_file = file;
1410         b->yy_fill_buffer = 1;
1411
1412     /* If b is the current buffer, then yy_init_buffer was _probably_
1413      * called from yyrestart() or through yy_get_next_buffer.
1414      * In that case, we don't want to reset the lineno or column.
1415      */
1416     if (b != YY_CURRENT_BUFFER){
1417         b->yy_bs_lineno = 1;
1418         b->yy_bs_column = 0;
1419     }
1420
1421         b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1422     
1423         errno = oerrno;
1424 }
1425
1426 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1427  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1428  * 
1429  */
1430     void yy_flush_buffer (YY_BUFFER_STATE  b )
1431 {
1432         if ( ! b )
1433                 return;
1434
1435         b->yy_n_chars = 0;
1436
1437         /* We always need two end-of-buffer characters.  The first causes
1438          * a transition to the end-of-buffer state.  The second causes
1439          * a jam in that state.
1440          */
1441         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1442         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1443
1444         b->yy_buf_pos = &b->yy_ch_buf[0];
1445
1446         b->yy_at_bol = 1;
1447         b->yy_buffer_status = YY_BUFFER_NEW;
1448
1449         if ( b == YY_CURRENT_BUFFER )
1450                 yy_load_buffer_state( );
1451 }
1452
1453 /** Pushes the new state onto the stack. The new state becomes
1454  *  the current state. This function will allocate the stack
1455  *  if necessary.
1456  *  @param new_buffer The new state.
1457  *  
1458  */
1459 void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
1460 {
1461         if (new_buffer == NULL)
1462                 return;
1463
1464         yyensure_buffer_stack();
1465
1466         /* This block is copied from yy_switch_to_buffer. */
1467         if ( YY_CURRENT_BUFFER )
1468                 {
1469                 /* Flush out information for old buffer. */
1470                 *(yy_c_buf_p) = (yy_hold_char);
1471                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1472                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1473                 }
1474
1475         /* Only push if top exists. Otherwise, replace top. */
1476         if (YY_CURRENT_BUFFER)
1477                 (yy_buffer_stack_top)++;
1478         YY_CURRENT_BUFFER_LVALUE = new_buffer;
1479
1480         /* copied from yy_switch_to_buffer. */
1481         yy_load_buffer_state( );
1482         (yy_did_buffer_switch_on_eof) = 1;
1483 }
1484
1485 /** Removes and deletes the top of the stack, if present.
1486  *  The next element becomes the new top.
1487  *  
1488  */
1489 void yypop_buffer_state (void)
1490 {
1491         if (!YY_CURRENT_BUFFER)
1492                 return;
1493
1494         yy_delete_buffer(YY_CURRENT_BUFFER );
1495         YY_CURRENT_BUFFER_LVALUE = NULL;
1496         if ((yy_buffer_stack_top) > 0)
1497                 --(yy_buffer_stack_top);
1498
1499         if (YY_CURRENT_BUFFER) {
1500                 yy_load_buffer_state( );
1501                 (yy_did_buffer_switch_on_eof) = 1;
1502         }
1503 }
1504
1505 /* Allocates the stack if it does not exist.
1506  *  Guarantees space for at least one push.
1507  */
1508 static void yyensure_buffer_stack (void)
1509 {
1510         int num_to_alloc;
1511     
1512         if (!(yy_buffer_stack)) {
1513
1514                 /* First allocation is just for 2 elements, since we don't know if this
1515                  * scanner will even need a stack. We use 2 instead of 1 to avoid an
1516                  * immediate realloc on the next call.
1517          */
1518                 num_to_alloc = 1;
1519                 (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
1520                                                                 (num_to_alloc * sizeof(struct yy_buffer_state*)
1521                                                                 );
1522                 
1523                 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1524                                 
1525                 (yy_buffer_stack_max) = num_to_alloc;
1526                 (yy_buffer_stack_top) = 0;
1527                 return;
1528         }
1529
1530         if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1531
1532                 /* Increase the buffer to prepare for a possible push. */
1533                 int grow_size = 8 /* arbitrary grow size */;
1534
1535                 num_to_alloc = (yy_buffer_stack_max) + grow_size;
1536                 (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
1537                                                                 ((yy_buffer_stack),
1538                                                                 num_to_alloc * sizeof(struct yy_buffer_state*)
1539                                                                 );
1540
1541                 /* zero only the new slots.*/
1542                 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
1543                 (yy_buffer_stack_max) = num_to_alloc;
1544         }
1545 }
1546
1547 /** Setup the input buffer state to scan directly from a user-specified character buffer.
1548  * @param base the character buffer
1549  * @param size the size in bytes of the character buffer
1550  * 
1551  * @return the newly allocated buffer state object. 
1552  */
1553 YY_BUFFER_STATE yy_scan_buffer  (char * base, yy_size_t  size )
1554 {
1555         YY_BUFFER_STATE b;
1556     
1557         if ( size < 2 ||
1558              base[size-2] != YY_END_OF_BUFFER_CHAR ||
1559              base[size-1] != YY_END_OF_BUFFER_CHAR )
1560                 /* They forgot to leave room for the EOB's. */
1561                 return 0;
1562
1563         b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
1564         if ( ! b )
1565                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1566
1567         b->yy_buf_size = size - 2;      /* "- 2" to take care of EOB's */
1568         b->yy_buf_pos = b->yy_ch_buf = base;
1569         b->yy_is_our_buffer = 0;
1570         b->yy_input_file = 0;
1571         b->yy_n_chars = b->yy_buf_size;
1572         b->yy_is_interactive = 0;
1573         b->yy_at_bol = 1;
1574         b->yy_fill_buffer = 0;
1575         b->yy_buffer_status = YY_BUFFER_NEW;
1576
1577         yy_switch_to_buffer(b  );
1578
1579         return b;
1580 }
1581
1582 /** Setup the input buffer state to scan a string. The next call to yylex() will
1583  * scan from a @e copy of @a str.
1584  * @param str a NUL-terminated string to scan
1585  * 
1586  * @return the newly allocated buffer state object.
1587  * @note If you want to scan bytes that may contain NUL values, then use
1588  *       yy_scan_bytes() instead.
1589  */
1590 YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
1591 {
1592     
1593         return yy_scan_bytes(yystr,strlen(yystr) );
1594 }
1595
1596 /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
1597  * scan from a @e copy of @a bytes.
1598  * @param bytes the byte buffer to scan
1599  * @param len the number of bytes in the buffer pointed to by @a bytes.
1600  * 
1601  * @return the newly allocated buffer state object.
1602  */
1603 YY_BUFFER_STATE yy_scan_bytes  (yyconst char * yybytes, int  _yybytes_len )
1604 {
1605         YY_BUFFER_STATE b;
1606         char *buf;
1607         yy_size_t n;
1608         int i;
1609     
1610         /* Get memory for full buffer, including space for trailing EOB's. */
1611         n = _yybytes_len + 2;
1612         buf = (char *) yyalloc(n  );
1613         if ( ! buf )
1614                 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1615
1616         for ( i = 0; i < _yybytes_len; ++i )
1617                 buf[i] = yybytes[i];
1618
1619         buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1620
1621         b = yy_scan_buffer(buf,n );
1622         if ( ! b )
1623                 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1624
1625         /* It's okay to grow etc. this buffer, and we should throw it
1626          * away when we're done.
1627          */
1628         b->yy_is_our_buffer = 1;
1629
1630         return b;
1631 }
1632
1633 #ifndef YY_EXIT_FAILURE
1634 #define YY_EXIT_FAILURE 2
1635 #endif
1636
1637 static void yy_fatal_error (yyconst char* msg )
1638 {
1639         (void) fprintf( stderr, "%s\n", msg );
1640         exit( YY_EXIT_FAILURE );
1641 }
1642
1643 /* Redefine yyless() so it works in section 3 code. */
1644
1645 #undef yyless
1646 #define yyless(n) \
1647         do \
1648                 { \
1649                 /* Undo effects of setting up yytext. */ \
1650         int yyless_macro_arg = (n); \
1651         YY_LESS_LINENO(yyless_macro_arg);\
1652                 yytext[yyleng] = (yy_hold_char); \
1653                 (yy_c_buf_p) = yytext + yyless_macro_arg; \
1654                 (yy_hold_char) = *(yy_c_buf_p); \
1655                 *(yy_c_buf_p) = '\0'; \
1656                 yyleng = yyless_macro_arg; \
1657                 } \
1658         while ( 0 )
1659
1660 /* Accessor  methods (get/set functions) to struct members. */
1661
1662 /** Get the input stream.
1663  * 
1664  */
1665 FILE *yyget_in  (void)
1666 {
1667         return yyin;
1668 }
1669
1670 /** Get the output stream.
1671  * 
1672  */
1673 FILE *yyget_out  (void)
1674 {
1675         return yyout;
1676 }
1677
1678 /** Get the length of the current token.
1679  * 
1680  */
1681 int yyget_leng  (void)
1682 {
1683         return yyleng;
1684 }
1685
1686 /** Get the current token.
1687  * 
1688  */
1689
1690 char *yyget_text  (void)
1691 {
1692         return yytext;
1693 }
1694
1695 /** Set the input stream. This does not discard the current
1696  * input buffer.
1697  * @param in_str A readable stream.
1698  * 
1699  * @see yy_switch_to_buffer
1700  */
1701 void yyset_in (FILE *  in_str )
1702 {
1703         yyin = in_str ;
1704 }
1705
1706 void yyset_out (FILE *  out_str )
1707 {
1708         yyout = out_str ;
1709 }
1710
1711 int yyget_debug  (void)
1712 {
1713         return yy_flex_debug;
1714 }
1715
1716 void yyset_debug (int  bdebug )
1717 {
1718         yy_flex_debug = bdebug ;
1719 }
1720
1721 static int yy_init_globals (void)
1722 {
1723         /* Initialization is the same as for the non-reentrant scanner.
1724      * This function is called from yylex_destroy(), so don't allocate here.
1725      */
1726
1727     (yy_buffer_stack) = 0;
1728     (yy_buffer_stack_top) = 0;
1729     (yy_buffer_stack_max) = 0;
1730     (yy_c_buf_p) = (char *) 0;
1731     (yy_init) = 0;
1732     (yy_start) = 0;
1733
1734 /* Defined in main.c */
1735 #ifdef YY_STDINIT
1736     yyin = stdin;
1737     yyout = stdout;
1738 #else
1739     yyin = (FILE *) 0;
1740     yyout = (FILE *) 0;
1741 #endif
1742
1743     /* For future reference: Set errno on error, since we are called by
1744      * yylex_init()
1745      */
1746     return 0;
1747 }
1748
1749 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
1750 int yylex_destroy  (void)
1751 {
1752     
1753     /* Pop the buffer stack, destroying each element. */
1754         while(YY_CURRENT_BUFFER){
1755                 yy_delete_buffer(YY_CURRENT_BUFFER  );
1756                 YY_CURRENT_BUFFER_LVALUE = NULL;
1757                 yypop_buffer_state();
1758         }
1759
1760         /* Destroy the stack itself. */
1761         yyfree((yy_buffer_stack) );
1762         (yy_buffer_stack) = NULL;
1763
1764     /* Reset the globals. This is important in a non-reentrant scanner so the next time
1765      * yylex() is called, initialization will occur. */
1766     yy_init_globals( );
1767
1768     return 0;
1769 }
1770
1771 /*
1772  * Internal utility routines.
1773  */
1774
1775 #ifndef yytext_ptr
1776 static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
1777 {
1778         register int i;
1779         for ( i = 0; i < n; ++i )
1780                 s1[i] = s2[i];
1781 }
1782 #endif
1783
1784 #ifdef YY_NEED_STRLEN
1785 static int yy_flex_strlen (yyconst char * s )
1786 {
1787         register int n;
1788         for ( n = 0; s[n]; ++n )
1789                 ;
1790
1791         return n;
1792 }
1793 #endif
1794
1795 void *yyalloc (yy_size_t  size )
1796 {
1797         return (void *) malloc( size );
1798 }
1799
1800 void *yyrealloc  (void * ptr, yy_size_t  size )
1801 {
1802         /* The cast to (char *) in the following accommodates both
1803          * implementations that use char* generic pointers, and those
1804          * that use void* generic pointers.  It works with the latter
1805          * because both ANSI C and C++ allow castless assignment from
1806          * any pointer type to void*, and deal with argument conversions
1807          * as though doing an assignment.
1808          */
1809         return (void *) realloc( (char *) ptr, size );
1810 }
1811
1812 void yyfree (void * ptr )
1813 {
1814         free( (char *) ptr );   /* see yyrealloc() for (char *) cast */
1815 }
1816
1817 #define YYTABLES_NAME "yytables"
1818
1819 #line 75 "lex.l"
1820
1821
1822
1823 #ifndef yywrap /* XXX */
1824 int
1825 yywrap () 
1826 {
1827      return 1;
1828 }
1829 #endif
1830
1831 static int
1832 getstring(void)
1833 {
1834     char x[128];
1835     int i = 0;
1836     int c;
1837     int quote = 0;
1838     while(i < sizeof(x) - 1 && (c = input()) != EOF){
1839         if(quote) {
1840             x[i++] = c;
1841             quote = 0;
1842             continue;
1843         }
1844         if(c == '\n'){
1845             error_message("unterminated string");
1846             lineno++;
1847             break;
1848         }
1849         if(c == '\\'){
1850             quote++;
1851             continue;
1852         }
1853         if(c == '\"')
1854             break;
1855         x[i++] = c;
1856     }
1857     x[i] = '\0';
1858     yylval.string = strdup(x);
1859     if (yylval.string == NULL)
1860         err(1, "malloc");
1861     return STRING;
1862 }
1863
1864 void
1865 error_message (const char *format, ...)
1866 {
1867      va_list args;
1868
1869      va_start (args, format);
1870      fprintf (stderr, "%s:%d:", filename, lineno);
1871      vfprintf (stderr, format, args);
1872      va_end (args);
1873      numerror++;
1874 }
1875