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