Lab entry diagnostic message was not conditionalised, fixed.
[crawl:crawl.git] / crawl-ref / source / prebuilt / levcomp.lex.cc
1 #line 2 "levcomp.lex.cc"
2
3 #line 4 "levcomp.lex.cc"
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     /* Note: We specifically omit the test for yy_rule_can_match_eol because it requires
164      *       access to the local variable yy_act. Since yyless() is a macro, it would break
165      *       existing scanners that call yyless() from OUTSIDE yylex. 
166      *       One obvious solution it to make yy_act a global. I tried that, and saw
167      *       a 5% performance hit in a non-yylineno scanner, because yy_act is
168      *       normally declared as a register variable-- so it is not worth it.
169      */
170     #define  YY_LESS_LINENO(n) \
171             do { \
172                 int yyl;\
173                 for ( yyl = n; yyl < yyleng; ++yyl )\
174                     if ( yytext[yyl] == '\n' )\
175                         --yylineno;\
176             }while(0)
177     
178 /* Return all but the first "n" matched characters back to the input stream. */
179 #define yyless(n) \
180         do \
181                 { \
182                 /* Undo effects of setting up yytext. */ \
183         int yyless_macro_arg = (n); \
184         YY_LESS_LINENO(yyless_macro_arg);\
185                 *yy_cp = (yy_hold_char); \
186                 YY_RESTORE_YY_MORE_OFFSET \
187                 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
188                 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
189                 } \
190         while ( 0 )
191
192 #define unput(c) yyunput( c, (yytext_ptr)  )
193
194 /* The following is because we cannot portably get our hands on size_t
195  * (without autoconf's help, which isn't available because we want
196  * flex-generated scanners to compile on their own).
197  */
198
199 #ifndef YY_TYPEDEF_YY_SIZE_T
200 #define YY_TYPEDEF_YY_SIZE_T
201 typedef unsigned int yy_size_t;
202 #endif
203
204 #ifndef YY_STRUCT_YY_BUFFER_STATE
205 #define YY_STRUCT_YY_BUFFER_STATE
206 struct yy_buffer_state
207         {
208         FILE *yy_input_file;
209
210         char *yy_ch_buf;                /* input buffer */
211         char *yy_buf_pos;               /* current position in input buffer */
212
213         /* Size of input buffer in bytes, not including room for EOB
214          * characters.
215          */
216         yy_size_t yy_buf_size;
217
218         /* Number of characters read into yy_ch_buf, not including EOB
219          * characters.
220          */
221         int yy_n_chars;
222
223         /* Whether we "own" the buffer - i.e., we know we created it,
224          * and can realloc() it to grow it, and should free() it to
225          * delete it.
226          */
227         int yy_is_our_buffer;
228
229         /* Whether this is an "interactive" input source; if so, and
230          * if we're using stdio for input, then we want to use getc()
231          * instead of fread(), to make sure we stop fetching input after
232          * each newline.
233          */
234         int yy_is_interactive;
235
236         /* Whether we're considered to be at the beginning of a line.
237          * If so, '^' rules will be active on the next match, otherwise
238          * not.
239          */
240         int yy_at_bol;
241
242     int yy_bs_lineno; /**< The line count. */
243     int yy_bs_column; /**< The column count. */
244     
245         /* Whether to try to fill the input buffer when we reach the
246          * end of it.
247          */
248         int yy_fill_buffer;
249
250         int yy_buffer_status;
251
252 #define YY_BUFFER_NEW 0
253 #define YY_BUFFER_NORMAL 1
254         /* When an EOF's been seen but there's still some text to process
255          * then we mark the buffer as YY_EOF_PENDING, to indicate that we
256          * shouldn't try reading from the input source any more.  We might
257          * still have a bunch of tokens to match, though, because of
258          * possible backing-up.
259          *
260          * When we actually see the EOF, we change the status to "new"
261          * (via yyrestart()), so that the user can continue scanning by
262          * just pointing yyin at a new input file.
263          */
264 #define YY_BUFFER_EOF_PENDING 2
265
266         };
267 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
268
269 /* Stack of input buffers. */
270 static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
271 static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
272 static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
273
274 /* We provide macros for accessing buffer states in case in the
275  * future we want to put the buffer states in a more general
276  * "scanner state".
277  *
278  * Returns the top of the stack, or NULL.
279  */
280 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
281                           ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
282                           : NULL)
283
284 /* Same as previous macro, but useful when we know that the buffer stack is not
285  * NULL or when we need an lvalue. For internal use only.
286  */
287 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
288
289 /* yy_hold_char holds the character lost when yytext is formed. */
290 static char yy_hold_char;
291 static int yy_n_chars;          /* number of characters read into yy_ch_buf */
292 int yyleng;
293
294 /* Points to current character in buffer. */
295 static char *yy_c_buf_p = (char *) 0;
296 static int yy_init = 0;         /* whether we need to initialize */
297 static int yy_start = 0;        /* start state number */
298
299 /* Flag which is used to allow yywrap()'s to do buffer switches
300  * instead of setting up a fresh yyin.  A bit of a hack ...
301  */
302 static int yy_did_buffer_switch_on_eof;
303
304 void yyrestart (FILE *input_file  );
305 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer  );
306 YY_BUFFER_STATE yy_create_buffer (FILE *file,int size  );
307 void yy_delete_buffer (YY_BUFFER_STATE b  );
308 void yy_flush_buffer (YY_BUFFER_STATE b  );
309 void yypush_buffer_state (YY_BUFFER_STATE new_buffer  );
310 void yypop_buffer_state (void );
311
312 static void yyensure_buffer_stack (void );
313 static void yy_load_buffer_state (void );
314 static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file  );
315
316 #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER )
317
318 YY_BUFFER_STATE yy_scan_buffer (char *base,yy_size_t size  );
319 YY_BUFFER_STATE yy_scan_string (yyconst char *yy_str  );
320 YY_BUFFER_STATE yy_scan_bytes (yyconst char *bytes,int len  );
321
322 void *yyalloc (yy_size_t  );
323 void *yyrealloc (void *,yy_size_t  );
324 void yyfree (void *  );
325
326 #define yy_new_buffer yy_create_buffer
327
328 #define yy_set_interactive(is_interactive) \
329         { \
330         if ( ! YY_CURRENT_BUFFER ){ \
331         yyensure_buffer_stack (); \
332                 YY_CURRENT_BUFFER_LVALUE =    \
333             yy_create_buffer(yyin,YY_BUF_SIZE ); \
334         } \
335         YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
336         }
337
338 #define yy_set_bol(at_bol) \
339         { \
340         if ( ! YY_CURRENT_BUFFER ){\
341         yyensure_buffer_stack (); \
342                 YY_CURRENT_BUFFER_LVALUE =    \
343             yy_create_buffer(yyin,YY_BUF_SIZE ); \
344         } \
345         YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
346         }
347
348 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
349
350 /* Begin user sect3 */
351
352 typedef unsigned char YY_CHAR;
353
354 FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
355
356 typedef int yy_state_type;
357
358 extern int yylineno;
359
360 int yylineno = 1;
361
362 extern char *yytext;
363 #define yytext_ptr yytext
364
365 static yy_state_type yy_get_previous_state (void );
366 static yy_state_type yy_try_NUL_trans (yy_state_type current_state  );
367 static int yy_get_next_buffer (void );
368 static void yy_fatal_error (yyconst char msg[]  );
369
370 /* Done after the current pattern has been matched and before the
371  * corresponding action - sets up yytext.
372  */
373 #define YY_DO_BEFORE_ACTION \
374         (yytext_ptr) = yy_bp; \
375         yyleng = (size_t) (yy_cp - yy_bp); \
376         (yy_hold_char) = *yy_cp; \
377         *yy_cp = '\0'; \
378         (yy_c_buf_p) = yy_cp;
379
380 #define YY_NUM_RULES 62
381 #define YY_END_OF_BUFFER 63
382 /* This struct is not used in this scanner,
383    but its presence is necessary. */
384 struct yy_trans_info
385         {
386         flex_int32_t yy_verify;
387         flex_int32_t yy_nxt;
388         };
389 static yyconst flex_int16_t yy_accept[782] =
390     {   0,
391         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
392         0,    0,    0,    0,    0,    0,    0,    0,   63,   61,
393        59,   60,   61,   57,   58,   61,   61,   61,   61,   61,
394        61,   61,   61,   61,   61,   61,   61,   61,   59,   30,
395        32,   61,   61,   61,   61,   61,   61,   62,    6,   62,
396        62,    4,    2,    3,   62,    2,    2,    2,    2,    9,
397        10,   62,    9,    9,   62,   12,   62,   61,   26,   61,
398        57,   58,   61,   61,   61,   61,   61,   61,   61,   61,
399        61,   61,   61,   61,   61,   30,   32,   61,   61,   61,
400        61,   61,   61,   61,   24,   21,   24,   23,   58,   61,
401
402        61,   61,   61,   61,   61,   61,   61,   61,   61,   61,
403        61,   61,   24,   30,   32,   61,   61,   61,   61,   61,
404        61,   14,   15,   61,   13,   13,   13,   13,   13,   13,
405        13,   13,   13,   13,   13,   13,   13,   13,   13,   14,
406        13,   13,   13,   13,   13,   17,   19,   20,   62,   18,
407        62,   29,   62,   62,   59,   60,   58,    0,    0,    0,
408         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
409         0,    0,    0,    0,    0,   59,   30,   32,    0,    0,
410         0,    0,   30,    0,    0,    0,    0,    0,    0,    0,
411        35,    6,    5,    0,    0,    2,    3,    2,    0,    2,
412
413         2,    2,    2,    9,    9,   10,    9,    9,    9,    0,
414        11,   12,   25,    0,   26,   25,   25,   25,   25,   25,
415        25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
416        25,   25,   25,   25,   25,   30,   25,   25,   25,   25,
417        25,   25,   25,   25,    0,   24,   21,   24,   21,   58,
418         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
419         0,    0,    0,    0,    0,    0,    0,    0,   24,   30,
420         0,    0,    0,    0,    0,    0,    0,   35,   14,   15,
421         0,   15,   13,   13,   13,   13,   13,   13,   13,   13,
422        13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
423
424        13,   13,   14,   13,   13,   13,   13,   13,   13,   13,
425        16,    0,   19,   20,    0,    0,   28,    0,   28,    0,
426        27,    0,    0,    0,    0,    0,    0,    0,    0,    0,
427         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
428         0,    0,    0,    0,    0,    0,    2,    9,    9,    9,
429         7,   25,   25,   25,   25,   25,   25,   25,   25,   25,
430        25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
431        25,   25,   25,   25,   25,   25,   22,   22,   22,   22,
432        22,   22,   22,   22,   22,   22,   22,   22,   22,   22,
433        22,   22,   22,   22,   22,   22,   22,   22,   22,   22,
434
435        22,   22,   22,   22,   22,   22,   13,   13,   13,   13,
436        13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
437        13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
438        13,    0,    0,    0,    0,    0,    0,    0,    0,    0,
439         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
440         0,   31,    0,    0,    0,    0,    0,    2,    9,    8,
441         9,    7,   25,   25,   25,   25,   25,   25,   25,   25,
442        25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
443        25,    0,    0,   25,   25,   25,   25,   22,   22,   22,
444        22,   22,   22,   22,   22,   22,   22,   22,   22,   22,
445
446        22,   22,   22,   22,   22,   22,    0,    0,   22,   22,
447        22,   22,   13,   13,   13,   13,   13,   13,   13,   13,
448        13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
449        13,   13,   13,   13,    0,    0,    0,   51,    0,    0,
450         0,    0,   50,   38,    0,    0,    0,    0,    0,   47,
451         0,    0,    0,   34,    0,    0,    0,    0,    2,   25,
452        25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
453        25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
454        25,    0,   25,   22,   22,   22,   22,   22,   22,   22,
455        22,   22,   22,   22,   22,   22,   22,   22,   22,   22,
456
457        22,   22,   22,   22,   22,    0,   22,   13,   13,   13,
458        13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
459        13,   13,   13,   13,    0,   40,   46,   54,   55,   56,
460         0,    0,    0,   42,    0,   48,    0,    0,    0,    0,
461         0,   37,    1,   25,   25,   25,   25,   25,   25,   25,
462        25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
463        25,   22,   22,   22,   22,   22,   22,   22,   22,   22,
464        22,   22,   22,   22,   22,   22,   22,   22,   22,   13,
465        13,   13,   13,   13,   13,   13,   13,   13,   13,   44,
466        52,   49,   41,    0,   45,    0,    0,    0,    0,    1,
467
468        25,   25,   25,   25,   25,   25,   25,   25,   25,   25,
469        22,   22,   22,   22,   22,   22,   22,   22,   22,   22,
470        13,   13,   13,   13,   13,   53,   43,    0,    0,    0,
471         0,   25,   25,   25,    0,   25,   25,   22,   22,   22,
472         0,   22,   22,   13,   13,    0,   33,    0,    0,   25,
473        25,    0,   25,   22,   22,    0,   22,   13,    0,   36,
474        25,   25,   22,   22,   13,    0,   25,   22,   13,    0,
475        25,   22,   13,    0,   25,   22,   13,   39,   25,   22,
476         0
477     } ;
478
479 static yyconst flex_int32_t yy_ec[256] =
480     {   0,
481         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
482         1,    1,    4,    1,    1,    1,    1,    1,    1,    1,
483         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
484         1,    5,    1,    1,    6,    1,    1,    1,    1,    1,
485         1,    1,    1,    7,    8,    1,    1,    9,    9,    9,
486         9,    9,    9,    9,    9,    9,    9,   10,    1,    1,
487         1,    1,    1,    1,   11,   12,   13,   14,   15,   16,
488        17,   18,   19,   20,   21,   22,   23,   24,   25,   26,
489        20,   27,   28,   29,   30,   20,   31,   20,   20,   20,
490         1,   32,    1,    1,   20,    1,   33,   20,   20,   34,
491
492        35,   36,   20,   37,   38,   20,   20,   39,   20,   20,
493        40,   41,   20,   42,   43,   44,   45,   46,   20,   20,
494        20,   20,   47,    1,   48,    1,    1,    1,    1,    1,
495         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
496         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
497         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
498         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
499         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
500         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
501         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
502
503         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
504         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
505         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
506         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
507         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
508         1,    1,    1,    1,    1
509     } ;
510
511 static yyconst flex_int32_t yy_meta[49] =
512     {   0,
513         1,    2,    3,    4,    1,    1,    5,    6,    6,    1,
514         6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
515         6,    6,    6,    6,    6,    6,    6,    6,    6,    6,
516         6,    1,    6,    6,    6,    6,    6,    6,    6,    6,
517         6,    6,    6,    6,    6,    6,    1,    1
518     } ;
519
520 static yyconst flex_int16_t yy_base[806] =
521     {   0,
522         0,   34,   80,   85,   89,   91,    7,   14,  138,  172,
523       219,  253,  301,  348,   94,  100,  106,  112, 2034, 2035,
524        10, 2035, 2030, 2035, 2023, 2013, 2015, 2007, 1999,   95,
525        95,   97, 2000, 2004,    2, 2014, 2009, 1988,  394,    0,
526      2035,  101, 1977, 1979,   90,   84, 1973, 2035, 2035, 2016,
527       118, 2035,    0, 2035, 2015,  357,    0, 1993,  112, 1968,
528      2035, 2012,   81, 1966, 2010, 2035, 2009,  144, 2035, 2008,
529       166,  225,  361,  365,  370,  379,  401,  405,  410,  421,
530       427,  432,  440,  450,  454,  247,  459,  465,  469,  473,
531       477,  483,  489,    0,  493, 2035,  499, 2035, 2001, 1991,
532
533      1993, 1985, 1977,  137,  125,  340, 1978, 1982,  207, 1992,
534      1987, 1966,  503,   23,    0,  353, 1955, 1957,  333,  206,
535      1951,  507, 2035, 1994,    0, 1987, 1977, 1979, 1971, 1963,
536       374,  377,  390, 1964, 1968,  355, 1978, 1973, 1952,  519,
537       402, 1941, 1943,  334,  433,  350,  523, 2035, 1981, 2035,
538       379, 2035,  425,  481,  417, 2035, 1974, 1971, 1955, 1969,
539      1964, 1963, 1948, 1951, 1945, 1944, 1944, 1936, 1937, 1944,
540      1924, 1936, 1927,  424, 1907,    0,    0, 2035, 1897, 1894,
541       484, 1883,    0,  104, 1892, 1884, 1907,  437, 1868, 1862,
542      2035, 2035, 2035, 1902,  526,    0, 2035,    0, 1891,  529,
543
544      1819, 1808,  520, 1783, 1782, 2035,  188, 1781,  535, 1824,
545      2035, 2035,  537,  541, 2035,  545,  551,  555,  562,  567,
546       572,  584,  589,  593,  597,  601,  605,  613,  623,  634,
547       638,  642,  647,  651,  656,  663,  668,  672,  676,  680,
548       684,  694,  688,  698,  546,  710, 2035,  714, 2035,  556,
549       573,  628,  699,  614,  719,  718,  606,  621,  704,  720,
550       724,  733,  734,  735,  739,  744,  748,  753,    0,  755,
551       761,  766,  767,  771,  772,  773,  778,  779,  788, 2035,
552      1823, 2035,    0, 1814, 1806, 1785, 1795, 1790, 1776, 1750,
553      1753, 1750, 1734, 1725, 1706, 1716, 1720, 1700, 1712, 1699,
554
555       775, 1676,    0,  553, 1675, 1660, 1683,  449, 1642, 1631,
556       796,  798,  802, 2035, 1660,  609, 2035,  806, 2035,  811,
557      2035, 1631, 1613, 1623, 1609, 1617, 1609, 1596, 1595, 1582,
558      1576, 1572, 1568, 1559, 1547, 1530, 1526, 1528, 1528, 1504,
559       815,  819, 1493, 1499, 1479, 1473, 1486,  823,  827,  831,
560      2035,  835,  840,  844,  849,  853,  858,  863,  872,  876,
561       880,  884,  895,  901,  907,  911,  915,  920,  925,  929,
562       942,  946,  950,  954,  959,  963,  845,  889,  916,  955,
563       964,  930,  968,  970,  972,  981,  985,  986,  993, 1002,
564      1006, 1004, 1010, 1016, 1020, 1021, 1022, 1026, 1037, 1027,
565
566      1041, 1043, 1045, 1047, 1049, 1055, 1480, 1467, 1474, 1457,
567      1457, 1449, 1434, 1435, 1422, 1423, 1416, 1407, 1390, 1383,
568      1367, 1363, 1361, 1364, 1338, 1056, 1060, 1327, 1339, 1323,
569      1317, 1340, 1331, 1317, 1330, 1307, 1309, 1302, 1309, 1300,
570      1299, 1276, 1275, 1280, 1260, 1233, 1245, 1227, 1211, 1180,
571      1061, 2035, 1066, 1174, 1171, 1178, 1070, 1197, 1074, 2035,
572      1079, 2035, 1081, 1087, 1095, 1099, 1106, 1110, 1114, 1124,
573      1136, 1143, 1132, 1147, 1152, 1157, 1161, 1170, 1174, 1179,
574      1183, 1191, 1195, 1201, 1205, 1209, 1213, 1119, 1184, 1196,
575      1217, 1091, 1218, 1224, 1153, 1228, 1229, 1230, 1235, 1242,
576
577      1249, 1244, 1251, 1261, 1262, 1266, 1267, 1272, 1273, 1278,
578      1279, 1280, 1178, 1164, 1149, 1160, 1140, 1141, 1122, 1129,
579      1133, 1121, 1102, 1101, 1091, 1086, 1069, 1078, 1060, 1048,
580      1022, 1008, 1007, 1284, 1021, 1025, 1006, 2035, 1004, 1000,
581       990,  972, 2035, 2035,  965,  963,  972,  956,  966, 2035,
582       942,  926,  903, 2035,  907,  903, 1286,  881,  900, 1288,
583      1292, 1296, 1303, 1312, 1324, 1333, 1337, 1342, 1346, 1350,
584      1354, 1358, 1365, 1370, 1380, 1384, 1388, 1392, 1396, 1400,
585      1404, 1410, 1414, 1310, 1371, 1415, 1316, 1419, 1425, 1431,
586      1405, 1421, 1437, 1438, 1442, 1443, 1444, 1449, 1450, 1458,
587
588      1460, 1467, 1468, 1473, 1472, 1474, 1479,  893,  897,  892,
589       891,  882,  880,  856,  841,  827,  842,  819,  825,  802,
590       804,  784,  785,  777,  786, 2035, 2035, 2035, 2035, 2035,
591       776,  775,  769, 2035,  749, 2035,  746,  733,  698,  696,
592       686, 2035,  703, 1484, 1488, 1493, 1497, 1506, 1510, 1514,
593      1518, 1525, 1529, 1534, 1538, 1542, 1546, 1551, 1555, 1560,
594      1564, 1565, 1480, 1498, 1569, 1571, 1575, 1576, 1577, 1583,
595      1587, 1592, 1594, 1596, 1598, 1600, 1606, 1607, 1612,  687,
596       673,  669,  665,  656,  653,  647,  613,  610,  593, 2035,
597      2035, 2035, 2035,  612, 2035,  594,  592, 1613,  561,  587,
598
599      1617, 1621, 1625, 1629, 1633, 1643, 1648, 1657, 1652, 1662,
600      1634, 1644, 1666, 1667, 1668, 1672, 1674, 1678, 1680, 1685,
601       580,  575,  562, 1686,  533, 2035, 2035,  518, 1687,  497,
602      1691, 1696, 1700, 1705, 1709, 1713, 1717, 1701, 1721, 1723,
603      1727, 1735, 1739,  465, 1740,  418, 2035, 1741,  400, 1745,
604      1749, 1757, 1761, 1750, 1765, 1766, 1767,  404,  357, 2035,
605      1771, 1779, 1787, 1788,  345,  202, 1792, 1793,  121,  121,
606      1797, 1798,   98,   23, 1805, 1814,   12, 2035, 1816, 1820,
607      2035, 1837, 1843, 1849, 1855, 1861, 1867, 1873, 1879, 1885,
608      1891, 1897, 1903, 1909, 1915, 1921, 1927, 1933, 1939, 1945,
609
610         0, 1951, 1957, 1963, 1969
611     } ;
612
613 static yyconst flex_int16_t yy_def[806] =
614     {   0,
615       782,  781,  783,  784,  785,  785,  786,  786,  787,  781,
616       788,  781,  781,   13,  789,  789,  790,  790,  781,  781,
617       781,  781,  781,  781,  781,  781,  781,  781,  781,  781,
618       781,  781,  781,  781,  781,  781,  781,  781,  781,  791,
619       781,  781,  781,  781,  781,  781,  781,  781,  781,  781,
620       792,  781,  793,  781,  781,  794,  793,  793,  793,  795,
621       781,  781,  795,  795,  796,  781,  781,  797,  781,  781,
622       797,  797,  797,  797,  797,  797,  797,  797,  797,  797,
623       797,  797,  797,  797,  797,  798,  797,  797,  797,  797,
624       797,  797,  797,  799,  781,  781,  781,  781,  799,  799,
625
626       799,  799,  799,  799,  799,  799,  799,  799,  799,  799,
627       799,  799,   39,  800,  799,  799,  799,  799,  799,  799,
628       799,  781,  781,  781,  801,  801,  801,  801,  801,  801,
629       801,  801,  801,  801,  801,  801,  801,  801,  801,   39,
630       801,  801,  801,  801,  801,  802,  781,  781,  781,  781,
631       803,  781,  803,  803,  781,  781,  781,  781,  781,  781,
632       781,  781,  781,  781,  781,  781,  781,  781,  781,  781,
633       781,  781,  781,  781,  781,   39,  791,  781,  781,  781,
634       781,  781,  791,  781,  781,  781,  781,  781,  781,  781,
635       781,  781,  781,  781,  781,  793,  781,  793,  781,  793,
636
637       793,  793,  793,  795,  795,  781,  795,  795,  795,  796,
638       781,  781,  797,  797,  781,  797,  797,  797,  797,  797,
639       797,  797,  797,  797,  797,  797,  797,  797,  797,  797,
640       797,  797,  797,  797,  798,  798,  797,  797,  797,  797,
641       797,  797,  797,  797,  804,  781,  781,  781,  781,  804,
642       804,  804,  804,  804,  804,  804,  804,  804,  804,  804,
643       804,  804,  804,  804,  804,  804,  804,  804,  113,  805,
644       804,  804,  804,  804,  804,  804,  804,  804,  781,  781,
645       781,  781,  801,  801,  801,  801,  801,  801,  801,  801,
646       801,  801,  801,  801,  801,  801,  801,  801,  801,  801,
647
648       801,  801,  140,  801,  801,  801,  801,  801,  801,  801,
649       802,  802,  781,  781,  781,  803,  781,  803,  781,  803,
650       781,  781,  781,  781,  781,  781,  781,  781,  781,  781,
651       781,  781,  781,  781,  781,  781,  781,  781,  781,  781,
652       781,  781,  781,  781,  781,  781,  793,  795,  795,  795,
653       781,  797,  797,  797,  797,  797,  797,  797,  797,  797,
654       797,  797,  797,  797,  797,  797,  797,  797,  797,  797,
655       797,  797,  797,  797,  797,  797,  804,  804,  804,  804,
656       804,  804,  804,  804,  804,  804,  804,  804,  804,  804,
657       804,  804,  804,  804,  804,  804,  804,  805,  804,  804,
658
659       804,  804,  804,  804,  804,  804,  801,  801,  801,  801,
660       801,  801,  801,  801,  801,  801,  801,  801,  801,  801,
661       801,  801,  801,  801,  801,  801,  801,  801,  801,  801,
662       801,  781,  781,  781,  781,  781,  781,  781,  781,  781,
663       781,  781,  781,  781,  781,  781,  781,  781,  781,  781,
664       781,  781,  781,  781,  781,  781,  781,  793,  795,  781,
665       795,  781,  797,  797,  797,  797,  797,  797,  797,  797,
666       797,  797,  797,  797,  797,  797,  797,  797,  797,  797,
667       797,  797,  797,  797,  797,  797,  797,  804,  804,  804,
668       804,  804,  804,  804,  804,  804,  804,  804,  804,  804,
669
670       804,  804,  804,  804,  804,  804,  804,  804,  804,  804,
671       804,  804,  801,  801,  801,  801,  801,  801,  801,  801,
672       801,  801,  801,  801,  801,  801,  801,  801,  801,  801,
673       801,  801,  801,  801,  781,  781,  781,  781,  781,  781,
674       781,  781,  781,  781,  781,  781,  781,  781,  781,  781,
675       781,  781,  781,  781,  781,  781,  781,  781,  793,  797,
676       797,  797,  797,  797,  797,  797,  797,  797,  797,  797,
677       797,  797,  797,  797,  797,  797,  797,  797,  797,  797,
678       797,  797,  797,  804,  804,  804,  804,  804,  804,  804,
679       804,  804,  804,  804,  804,  804,  804,  804,  804,  804,
680
681       804,  804,  804,  804,  804,  804,  804,  801,  801,  801,
682       801,  801,  801,  801,  801,  801,  801,  801,  801,  801,
683       801,  801,  801,  801,  781,  781,  781,  781,  781,  781,
684       781,  781,  781,  781,  781,  781,  781,  781,  781,  781,
685       781,  781,  793,  797,  797,  797,  797,  797,  797,  797,
686       797,  797,  797,  797,  797,  797,  797,  797,  797,  797,
687       797,  804,  804,  804,  804,  804,  804,  804,  804,  804,
688       804,  804,  804,  804,  804,  804,  804,  804,  804,  801,
689       801,  801,  801,  801,  801,  801,  801,  801,  801,  781,
690       781,  781,  781,  781,  781,  781,  781,  781,  781,  793,
691
692       797,  797,  797,  797,  797,  797,  797,  797,  797,  797,
693       804,  804,  804,  804,  804,  804,  804,  804,  804,  804,
694       801,  801,  801,  801,  801,  781,  781,  781,  781,  781,
695       781,  797,  797,  797,  797,  797,  797,  804,  804,  804,
696       804,  804,  804,  801,  801,  781,  781,  781,  781,  797,
697       797,  797,  797,  804,  804,  804,  804,  801,  781,  781,
698       797,  797,  804,  804,  801,  781,  797,  804,  801,  781,
699       797,  804,  801,  781,  797,  804,  801,  781,  797,  804,
700         0,  781,  781,  781,  781,  781,  781,  781,  781,  781,
701       781,  781,  781,  781,  781,  781,  781,  781,  781,  781,
702
703       781,  781,  781,  781,  781
704     } ;
705
706 static yyconst flex_int16_t yy_nxt[2084] =
707     {   0,
708       781,   21,   22,   23,   21,  283,   24,  781,   25,   66,
709        67,  155,   26,   27,  155,   28,   66,   67,   29,  171,
710        30,  778,   31,   32,   33,   34,  183,   35,   36,  183,
711        37,  172,  778,   38,   20,   39,   22,   23,   39,   40,
712        24,   20,   25,   41,   20,   20,   26,   27,   20,   28,
713        20,   20,   29,   20,   30,   20,   42,   32,   33,   34,
714        20,   35,   36,   20,   37,   20,   20,   38,   20,   20,
715        20,   20,   43,   20,   44,   20,   45,   20,   20,   46,
716        47,   20,   49,   50,   51,   52,   48,   54,   55,   56,
717        57,   61,   62,   61,   62,  147,  148,  149,  147,   58,
718
719       150,  147,  148,  149,  147,  165,  150,  167,  152,  153,
720       162,  184,  187,  163,  152,  153,  189,  164,  190,  166,
721       192,  194,  195,  207,  168,  166,  202,   59,  208,  341,
722       329,   63,  188,   63,  777,  258,   64,  154,   64,   21,
723        69,   70,   21,  154,   71,  214,   72,  214,  214,  259,
724        73,   74,  255,   75,  203,  256,   76,  774,   77,  257,
725        78,   79,   80,   81,  773,   82,   83,  214,   84,  214,
726       214,   85,   68,   39,   69,   70,   39,   86,   71,   68,
727        72,   87,   68,   68,   73,   74,   68,   75,   68,   68,
728        76,   68,   77,   68,   88,   79,   80,   81,   68,   82,
729
730        83,   68,   84,   68,   68,   85,   68,   68,   68,   68,
731        89,   68,   90,   68,   91,   68,   68,   92,   93,   68,
732        95,   96,   97,   95,  264,   98,  214,   99,  214,  214,
733       207,  100,  101,  216,  102,  208,  265,  103,  276,  104,
734       277,  105,  106,  107,  108,  770,  109,  110,  236,  111,
735       236,  236,  112,   94,  113,   96,   97,  113,  114,   98,
736        94,   99,  115,   94,   94,  100,  101,   94,  102,   94,
737        94,  103,   94,  104,   94,  116,  106,  107,  108,   94,
738       109,  110,   94,  111,   94,   94,  112,   94,   94,   94,
739        94,  117,   94,  118,   94,  119,   94,   94,  120,  121,
740
741        94,   20,  122,  123,  124,  122,   20,   24,  125,  126,
742        20,  125,  125,  127,  128,  125,  129,  125,  125,  130,
743       125,  131,  125,  132,  133,  134,  135,  125,  136,  137,
744       125,  138,   20,  125,  139,  125,  125,  125,  125,  125,
745       125,  125,  125,  125,  125,  125,  125,   20,   20,  140,
746       260,  312,  140,   40,  312,  274,  307,   41,  193,  197,
747       199,  200,  214,  271,  214,  214,  214,  261,  214,  214,
748       141,  214,  298,  214,  214,  275,  308,  259,  217,  218,
749       214,  317,  214,  214,  299,  769,  142,  292,  143,  289,
750       144,  219,  290,  145,   47,  176,  291,  766,  176,  177,
751
752       294,  293,  214,  178,  214,  214,  214,  220,  214,  214,
753       318,  214,  304,  214,  214,  224,  221,  295,  155,  222,
754       226,  155,  214,  223,  214,  214,  293,  319,  214,  225,
755       214,  214,  179,  214,  180,  214,  214,  227,  765,  181,
756       182,  214,  338,  214,  214,  339,  760,  228,  229,  230,
757       232,  214,  759,  214,  214,  214,  318,  214,  214,  187,
758       214,  231,  214,  214,  233,  309,  214,  310,  214,  214,
759       214,  307,  214,  214,  214,  237,  214,  214,  214,  188,
760       214,  214,  320,  321,  214,  320,  214,  214,  234,  225,
761       214,  308,  214,  214,  246,  247,  248,  246,  758,  240,
762
763       248,  249,  248,  248,  269,  247,  248,  269,  279,  280,
764       281,  279,  318,  238,  239,  242,  189,  243,  190,  241,
765       303,  280,  281,  303,  313,  314,  315,  313,  192,  194,
766       195,  197,  199,  200,  202,  244,  350,  351,  214,  350,
767       214,  214,  214,  747,  214,  214,  214,  245,  214,  214,
768       245,  746,  214,  216,  214,  214,  214,  245,  214,  214,
769       245,  352,  203,  214,  378,  214,  214,  745,  214,  744,
770       214,  214,  354,  214,  245,  214,  214,  245,  426,  414,
771       353,  355,  348,  379,  727,  214,  356,  214,  214,  726,
772       214,  700,  214,  214,  214,  731,  214,  214,  214,  728,
773
774       214,  214,  214,  727,  214,  214,  214,  245,  214,  214,
775       245,  317,  357,  358,  214,  245,  214,  214,  245,  359,
776       360,  726,  245,  361,  214,  245,  214,  214,  382,  245,
777       385,  363,  245,  364,  362,  214,  725,  214,  214,  214,
778       318,  214,  214,  214,  724,  214,  214,  386,  214,  366,
779       214,  214,  214,  380,  214,  214,  723,  236,  367,  236,
780       236,  722,  695,  365,  236,  368,  236,  236,  369,  214,
781       721,  214,  214,  214,  693,  214,  214,  214,  692,  214,
782       214,  214,  691,  214,  214,  214,  370,  214,  214,  214,
783       374,  214,  214,  371,  359,  214,  690,  214,  214,  214,
784
785       245,  214,  214,  245,  372,  245,  240,  700,  245,  381,
786       373,  246,  247,  248,  246,  248,  247,  248,  248,  245,
787       245,  245,  245,  245,  245,  245,  241,  387,  245,  699,
788       698,  376,  375,  383,  245,  245,  245,  245,  245,  245,
789       245,  697,  388,  245,  391,  245,  384,  696,  245,  245,
790       393,  390,  245,  389,  245,  695,  270,  245,  183,  270,
791       394,  183,  245,  694,  392,  245,  395,  245,  245,  396,
792       245,  245,  245,  245,  245,  245,  245,  245,  693,  245,
793       245,  402,  245,  245,  692,  691,  399,  386,  397,  279,
794       280,  281,  279,  423,  403,  690,  424,  312,  400,  312,
795
796       312,  401,  312,  313,  314,  315,  313,  320,  321,  689,
797       320,  405,  320,  321,  404,  320,  451,  452,  688,  451,
798       453,  406,  687,  453,  459,  460,  686,  459,  461,  462,
799       685,  461,  350,  351,  636,  350,  214,  318,  214,  214,
800       684,  214,  318,  214,  214,  214,  245,  214,  214,  245,
801       214,  634,  214,  214,  214,  683,  214,  214,  463,  214,
802       465,  214,  214,  467,  214,  454,  214,  214,  464,  682,
803       348,  466,  468,  214,  348,  214,  214,  214,  205,  214,
804       214,  214,  681,  214,  214,  214,  469,  214,  214,  630,
805       245,  629,  470,  245,  472,  473,  214,  378,  214,  214,
806
807       628,  627,  214,  471,  214,  214,  626,  680,  214,  474,
808       214,  214,  214,  475,  214,  214,  214,  245,  214,  214,
809       245,  214,  476,  214,  214,  643,  214,  642,  214,  214,
810       214,  245,  214,  214,  245,  641,  479,  480,  477,  488,
811       640,  639,  478,  482,  452,  214,  482,  483,  638,  214,
812       483,  214,  491,  214,  214,  214,  245,  214,  214,  245,
813       214,  481,  214,  214,  214,  245,  214,  214,  245,  245,
814       637,  245,  245,  245,  245,  636,  245,  635,  492,  371,
815       490,  634,  245,  489,  493,  245,  245,  245,  485,  245,
816       245,  633,  484,  632,  245,  494,  486,  245,  631,  630,
817
818       497,  495,  487,  245,  498,  245,  245,  245,  245,  629,
819       245,  245,  496,  628,  245,  627,  499,  245,  500,  501,
820       245,  245,  245,  245,  245,  245,  245,  270,  508,  183,
821       270,  508,  183,  505,  626,  625,  504,  502,  507,  452,
822       624,  507,  245,  503,  245,  245,  245,  245,  245,  245,
823       245,  245,  623,  245,  506,  402,  245,  451,  452,  245,
824       451,  453,  451,  452,  453,  451,  622,  453,  399,  403,
825       453,  557,  621,  509,  557,  459,  460,  620,  459,  510,
826       461,  462,  214,  461,  214,  214,  511,  550,  214,  404,
827       214,  214,  245,  560,  512,  245,  214,  619,  214,  214,
828
829       214,  618,  214,  214,  561,  617,  454,  214,  563,  214,
830       214,  214,  454,  214,  214,  214,  558,  214,  214,  588,
831       245,  205,  562,  245,  616,  214,  205,  214,  214,  615,
832       544,  584,  565,  214,  564,  214,  214,  214,  567,  214,
833       214,  566,  543,  614,  214,  568,  214,  214,  214,  613,
834       214,  214,  569,  214,  245,  214,  214,  245,  214,  570,
835       214,  214,  214,  612,  214,  214,  572,  591,  611,  538,
836       571,  214,  573,  214,  214,  214,  610,  214,  214,  575,
837       214,  609,  214,  214,  214,  245,  214,  214,  245,  574,
838       608,  576,  482,  452,  214,  482,  483,  245,  214,  483,
839
840       245,  585,  214,  577,  214,  214,  214,  559,  214,  214,
841       214,  556,  214,  214,  582,  555,  214,  582,  245,  245,
842       554,  245,  245,  586,  553,  245,  587,  578,  245,  245,
843       245,  245,  245,  245,  245,  552,  245,  592,  593,  245,
844       589,  484,  581,  245,  551,  245,  245,  579,  245,  580,
845       245,  590,  245,  245,  550,  245,  596,  594,  595,  583,
846       599,  549,  245,  245,  597,  245,  245,  245,  507,  452,
847       245,  507,  598,  508,  245,  548,  508,  245,  600,  245,
848       245,  606,  245,  245,  606,  557,  601,  557,  557,  214,
849       557,  214,  214,  214,  547,  214,  214,  214,  546,  214,
850
851       214,  645,  644,  545,  214,  646,  214,  214,  544,  543,
852       602,  245,  605,  214,  245,  214,  214,  245,  509,  603,
853       245,  647,  604,  542,  662,  214,  607,  214,  214,  541,
854       558,  540,  558,  648,  214,  539,  214,  214,  214,  538,
855       214,  214,  649,  214,  537,  214,  214,  214,  536,  214,
856       214,  214,  535,  214,  214,  214,  534,  214,  214,  214,
857       533,  214,  214,  650,  426,  532,  214,  653,  214,  214,
858       531,  214,  245,  214,  214,  245,  530,  529,  651,  655,
859       663,  214,  652,  214,  214,  214,  654,  214,  214,  214,
860       528,  214,  214,  214,  527,  214,  214,  214,  526,  214,
861
862       214,  214,  525,  214,  214,  214,  245,  214,  214,  245,
863       657,  582,  656,  214,  582,  214,  245,  214,  214,  245,
864       245,  524,  245,  245,  664,  245,  245,  523,  665,  245,
865       658,  668,  245,  659,  666,  245,  660,  522,  245,  245,
866       667,  245,  245,  245,  245,  245,  245,  245,  245,  521,
867       245,  245,  671,  245,  245,  520,  583,  519,  673,  245,
868       661,  245,  245,  518,  245,  672,  669,  517,  245,  245,
869       670,  245,  245,  245,  245,  606,  245,  245,  606,  516,
870       245,  245,  675,  245,  245,  214,  674,  214,  214,  214,
871       515,  214,  214,  701,  214,  514,  214,  214,  214,  245,
872
873       214,  214,  245,  513,  678,  676,  677,  214,  458,  214,
874       214,  214,  457,  214,  214,  214,  456,  214,  214,  214,
875       607,  214,  214,  702,  341,  679,  214,  703,  214,  214,
876       214,  455,  214,  214,  704,  214,  450,  214,  214,  214,
877       449,  214,  214,  214,  448,  214,  214,  214,  705,  214,
878       214,  706,  214,  447,  214,  214,  214,  446,  214,  214,
879       707,  214,  445,  214,  214,  214,  245,  214,  214,  245,
880       245,  444,  245,  245,  711,  245,  245,  245,  245,  245,
881       245,  245,  443,  442,  245,  712,  713,  245,  245,  709,
882       441,  245,  714,  245,  708,  245,  245,  245,  245,  245,
883
884       245,  245,  245,  710,  245,  716,  715,  245,  245,  440,
885       245,  245,  717,  245,  729,  439,  245,  729,  214,  438,
886       214,  214,  214,  437,  214,  214,  214,  436,  214,  214,
887       214,  435,  214,  214,  214,  245,  214,  214,  245,  434,
888       719,  433,  732,  718,  214,  245,  214,  214,  245,  214,
889       720,  214,  214,  735,  432,  214,  735,  733,  214,  730,
890       214,  214,  314,  214,  734,  214,  214,  245,  245,  245,
891       245,  245,  245,  245,  431,  245,  245,  738,  245,  245,
892       430,  741,  245,  739,  741,  740,  245,  729,  729,  245,
893       729,  729,  748,  429,  428,  748,  737,  214,  736,  214,
894
895       214,  214,  245,  214,  214,  245,  214,  427,  214,  214,
896       735,  425,  214,  735,  214,  422,  214,  214,  752,  743,
897       214,  752,  245,  421,  245,  245,  742,  245,  741,  420,
898       419,  741,  730,  730,  418,  417,  245,  749,  750,  245,
899       756,  748,  748,  756,  748,  748,  214,  416,  214,  214,
900       214,  245,  214,  214,  245,  736,  754,  415,  752,  751,
901       214,  752,  214,  753,  214,  214,  245,  756,  245,  245,
902       756,  245,  214,  742,  214,  214,  414,  413,  412,  761,
903       214,  755,  214,  214,  763,  757,  749,  749,  245,  245,
904       411,  245,  245,  214,  245,  214,  214,  245,  214,  245,
905
906       214,  214,  245,  753,  410,  409,  214,  762,  214,  214,
907       408,  767,  757,  764,  779,  245,  407,  214,  245,  214,
908       214,  245,  284,  780,  245,  280,  211,  768,  349,  348,
909       205,  201,  347,  775,  776,  771,  772,   20,   20,   20,
910        20,   20,   20,   48,   48,   48,   48,   48,   48,   53,
911        53,   53,   53,   53,   53,   60,   60,   60,   60,   60,
912        60,   65,   65,   65,   65,   65,   65,   68,   68,   68,
913        68,   68,   68,   94,   94,   94,   94,   94,   94,  146,
914       146,  146,  146,  146,  146,  151,  151,  151,  151,  151,
915       151,  183,  183,  197,  183,  183,  183,  193,  193,  193,
916
917       193,  193,  193,  196,  192,  346,  345,  196,  196,  198,
918       198,  198,  198,  198,  198,  204,  204,  344,  343,  204,
919       204,  210,  210,  210,  342,  210,  210,  213,  213,  191,
920       213,  213,  213,  235,  235,  186,  235,  235,  235,  245,
921       245,  185,  340,  337,  245,  270,  270,  336,  270,  270,
922       270,  311,  311,  335,  334,  333,  311,  316,  316,  316,
923       316,  316,  316,  377,  377,  332,  331,  330,  377,  398,
924       398,  329,  398,  398,  398,  328,  327,  326,  325,  324,
925       323,  322,  157,  314,  306,  305,  302,  301,  300,  297,
926       296,  288,  287,  286,  285,  284,  282,  278,  273,  272,
927
928       268,  267,  266,  263,  262,  254,  253,  252,  251,  250,
929       215,  212,  211,  209,  206,  205,  201,  197,  192,  191,
930       186,  185,  175,  174,  173,  170,  169,  161,  160,  159,
931       158,  157,  156,  781,   19,  781,  781,  781,  781,  781,
932       781,  781,  781,  781,  781,  781,  781,  781,  781,  781,
933       781,  781,  781,  781,  781,  781,  781,  781,  781,  781,
934       781,  781,  781,  781,  781,  781,  781,  781,  781,  781,
935       781,  781,  781,  781,  781,  781,  781,  781,  781,  781,
936       781,  781,  781
937     } ;
938
939 static yyconst flex_int16_t yy_chk[2084] =
940     {   0,
941         0,    1,    1,    1,    1,  801,    1,    0,    1,    7,
942         7,   21,    1,    1,   21,    1,    8,    8,    1,   35,
943         1,  777,    1,    1,    1,    1,  114,    1,    1,  114,
944         1,   35,  774,    1,    2,    2,    2,    2,    2,    2,
945         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
946         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
947         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
948         2,    2,    2,    2,    2,    2,    2,    2,    2,    2,
949         2,    2,    3,    3,    3,    3,    4,    4,    4,    4,
950         4,    5,    5,    6,    6,   15,   15,   15,   15,    4,
951
952        15,   16,   16,   16,   16,   31,   16,   32,   17,   17,
953        30,   42,   45,   30,   18,   18,   46,   30,   46,   31,
954        51,   51,   51,   63,   32,   42,   59,    4,   63,  184,
955       184,    5,   45,    6,  773,  105,    5,   17,    6,    9,
956         9,    9,    9,   18,    9,   68,    9,   68,   68,  105,
957         9,    9,  104,    9,   59,  104,    9,  770,    9,  104,
958         9,    9,    9,    9,  769,    9,    9,   71,    9,   71,
959        71,    9,   10,   10,   10,   10,   10,   10,   10,   10,
960        10,   10,   10,   10,   10,   10,   10,   10,   10,   10,
961        10,   10,   10,   10,   10,   10,   10,   10,   10,   10,
962
963        10,   10,   10,   10,   10,   10,   10,   10,   10,   10,
964        10,   10,   10,   10,   10,   10,   10,   10,   10,   10,
965        11,   11,   11,   11,  109,   11,   72,   11,   72,   72,
966       207,   11,   11,   72,   11,  207,  109,   11,  120,   11,
967       120,   11,   11,   11,   11,  766,   11,   11,   86,   11,
968        86,   86,   11,   12,   12,   12,   12,   12,   12,   12,
969        12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
970        12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
971        12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
972        12,   12,   12,   12,   12,   12,   12,   12,   12,   12,
973
974        12,   13,   13,   13,   13,   13,   13,   13,   13,   13,
975        13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
976        13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
977        13,   13,   13,   13,   13,   13,   13,   13,   13,   13,
978        13,   13,   13,   13,   13,   13,   13,   13,   13,   14,
979       106,  146,   14,   14,  146,  119,  144,   14,   56,   56,
980        56,   56,   73,  116,   73,   73,   74,  106,   74,   74,
981        14,   75,  136,   75,   75,  119,  144,  116,   73,   74,
982        76,  151,   76,   76,  136,  765,   14,  132,   14,  131,
983        14,   75,  131,   14,   14,   39,  131,  759,   39,   39,
984
985       133,  132,   77,   39,   77,   77,   78,   76,   78,   78,
986       151,   79,  141,   79,   79,   78,   77,  133,  155,   77,
987        79,  155,   80,   77,   80,   80,  141,  153,   81,   78,
988        81,   81,   39,   82,   39,   82,   82,   79,  758,   39,
989        39,   83,  174,   83,   83,  174,  749,   80,   81,   82,
990        83,   84,  746,   84,   84,   85,  153,   85,   85,  188,
991        87,   82,   87,   87,   84,  145,   88,  145,   88,   88,
992        89,  308,   89,   89,   90,   88,   90,   90,   91,  188,
993        91,   91,  154,  154,   92,  154,   92,   92,   85,   88,
994        93,  308,   93,   93,   95,   95,   95,   95,  744,   91,
995
996        97,   97,   97,   97,  113,  113,  113,  113,  122,  122,
997       122,  122,  154,   89,   90,   92,  181,   92,  181,   91,
998       140,  140,  140,  140,  147,  147,  147,  147,  195,  195,
999       195,  200,  200,  200,  203,   93,  209,  209,  213,  209,
1000       213,  213,  214,  730,  214,  214,  216,  245,  216,  216,
1001       245,  728,  217,  216,  217,  217,  218,  250,  218,  218,
1002       250,  217,  203,  219,  250,  219,  219,  725,  220,  723,
1003       220,  220,  219,  221,  251,  221,  221,  251,  304,  304,
1004       218,  220,  209,  251,  722,  222,  221,  222,  222,  721,
1005       223,  700,  223,  223,  224,  699,  224,  224,  225,  697,
1006
1007       225,  225,  226,  696,  226,  226,  227,  257,  227,  227,
1008       257,  316,  222,  223,  228,  254,  228,  228,  254,  224,
1009       225,  694,  258,  226,  229,  258,  229,  229,  254,  252,
1010       257,  228,  252,  229,  227,  230,  689,  230,  230,  231,
1011       316,  231,  231,  232,  688,  232,  232,  258,  233,  231,
1012       233,  233,  234,  252,  234,  234,  687,  235,  232,  235,
1013       235,  686,  685,  230,  236,  233,  236,  236,  233,  237,
1014       684,  237,  237,  238,  683,  238,  238,  239,  682,  239,
1015       239,  240,  681,  240,  240,  241,  234,  241,  241,  243,
1016       240,  243,  243,  237,  237,  242,  680,  242,  242,  244,
1017
1018       253,  244,  244,  253,  238,  259,  241,  643,  259,  253,
1019       239,  246,  246,  246,  246,  248,  248,  248,  248,  256,
1020       255,  260,  256,  255,  260,  261,  241,  259,  261,  641,
1021       640,  243,  242,  255,  262,  263,  264,  262,  263,  264,
1022       265,  639,  260,  265,  263,  266,  256,  638,  266,  267,
1023       265,  262,  267,  261,  268,  637,  270,  268,  270,  270,
1024       266,  270,  271,  635,  264,  271,  267,  272,  273,  267,
1025       272,  273,  274,  275,  276,  274,  275,  276,  633,  277,
1026       278,  274,  277,  278,  632,  631,  271,  271,  268,  279,
1027       279,  279,  279,  301,  275,  625,  301,  311,  272,  312,
1028
1029       311,  273,  312,  313,  313,  313,  313,  318,  318,  624,
1030       318,  276,  320,  320,  275,  320,  341,  341,  623,  341,
1031       342,  277,  622,  342,  348,  348,  621,  348,  349,  349,
1032       620,  349,  350,  350,  619,  350,  352,  318,  352,  352,
1033       618,  353,  320,  353,  353,  354,  377,  354,  354,  377,
1034       355,  617,  355,  355,  356,  616,  356,  356,  352,  357,
1035       354,  357,  357,  356,  358,  342,  358,  358,  353,  615,
1036       348,  355,  357,  359,  349,  359,  359,  360,  350,  360,
1037       360,  361,  614,  361,  361,  362,  358,  362,  362,  613,
1038       378,  612,  359,  378,  361,  362,  363,  378,  363,  363,
1039
1040       611,  610,  364,  360,  364,  364,  609,  608,  365,  363,
1041       365,  365,  366,  364,  366,  366,  367,  379,  367,  367,
1042       379,  368,  365,  368,  368,  559,  369,  558,  369,  369,
1043       370,  382,  370,  370,  382,  556,  368,  369,  366,  379,
1044       555,  553,  367,  371,  371,  371,  371,  372,  552,  372,
1045       372,  373,  382,  373,  373,  374,  380,  374,  374,  380,
1046       375,  370,  375,  375,  376,  381,  376,  376,  381,  383,
1047       551,  384,  383,  385,  384,  549,  385,  548,  383,  374,
1048       381,  547,  386,  380,  384,  386,  387,  388,  373,  387,
1049       388,  546,  372,  545,  389,  385,  375,  389,  542,  541,
1050
1051       388,  386,  376,  390,  389,  392,  390,  391,  392,  540,
1052       391,  393,  387,  539,  393,  537,  390,  394,  391,  392,
1053       394,  395,  396,  397,  395,  396,  397,  398,  400,  398,
1054       398,  400,  398,  396,  536,  535,  395,  393,  399,  399,
1055       533,  399,  401,  394,  402,  401,  403,  402,  404,  403,
1056       405,  404,  532,  405,  397,  403,  406,  426,  426,  406,
1057       426,  427,  451,  451,  427,  451,  531,  453,  402,  404,
1058       453,  457,  530,  400,  457,  459,  459,  529,  459,  401,
1059       461,  461,  463,  461,  463,  463,  405,  528,  464,  404,
1060       464,  464,  492,  463,  406,  492,  465,  527,  465,  465,
1061
1062       466,  526,  466,  466,  464,  525,  427,  467,  466,  467,
1063       467,  468,  453,  468,  468,  469,  457,  469,  469,  492,
1064       488,  459,  465,  488,  524,  470,  461,  470,  470,  523,
1065       522,  488,  468,  473,  467,  473,  473,  471,  470,  471,
1066       471,  469,  521,  520,  472,  471,  472,  472,  474,  519,
1067       474,  474,  472,  475,  495,  475,  475,  495,  476,  473,
1068       476,  476,  477,  518,  477,  477,  475,  495,  517,  516,
1069       474,  478,  476,  478,  478,  479,  515,  479,  479,  478,
1070       480,  514,  480,  480,  481,  489,  481,  481,  489,  477,
1071       513,  479,  482,  482,  482,  482,  483,  490,  483,  483,
1072
1073       490,  489,  484,  480,  484,  484,  485,  458,  485,  485,
1074       486,  456,  486,  486,  487,  455,  487,  487,  491,  493,
1075       454,  491,  493,  490,  450,  494,  491,  481,  494,  496,
1076       497,  498,  496,  497,  498,  449,  499,  496,  497,  499,
1077       493,  483,  486,  500,  448,  502,  500,  484,  502,  485,
1078       501,  494,  503,  501,  447,  503,  500,  498,  499,  487,
1079       503,  446,  504,  505,  501,  504,  505,  506,  507,  507,
1080       506,  507,  502,  508,  509,  445,  508,  509,  504,  510,
1081       511,  512,  510,  511,  512,  534,  505,  557,  534,  560,
1082       557,  560,  560,  561,  444,  561,  561,  562,  443,  562,
1083
1084       562,  561,  560,  442,  563,  562,  563,  563,  441,  440,
1085       506,  584,  511,  564,  584,  564,  564,  587,  508,  509,
1086       587,  564,  510,  439,  584,  565,  512,  565,  565,  438,
1087       534,  437,  557,  565,  566,  436,  566,  566,  567,  435,
1088       567,  567,  566,  568,  434,  568,  568,  569,  433,  569,
1089       569,  570,  432,  570,  570,  571,  431,  571,  571,  572,
1090       430,  572,  572,  567,  429,  428,  573,  572,  573,  573,
1091       425,  574,  585,  574,  574,  585,  424,  423,  570,  574,
1092       585,  575,  571,  575,  575,  576,  573,  576,  576,  577,
1093       422,  577,  577,  578,  421,  578,  578,  579,  420,  579,
1094
1095       579,  580,  419,  580,  580,  581,  591,  581,  581,  591,
1096       577,  582,  576,  582,  582,  583,  586,  583,  583,  586,
1097       588,  418,  592,  588,  586,  592,  589,  417,  588,  589,
1098       578,  591,  590,  580,  589,  590,  581,  416,  593,  594,
1099       590,  593,  594,  595,  596,  597,  595,  596,  597,  415,
1100       598,  599,  596,  598,  599,  414,  582,  413,  598,  600,
1101       583,  601,  600,  412,  601,  597,  594,  411,  602,  603,
1102       595,  602,  603,  605,  604,  606,  605,  604,  606,  410,
1103       607,  663,  601,  607,  663,  644,  600,  644,  644,  645,
1104       409,  645,  645,  644,  646,  408,  646,  646,  647,  664,
1105
1106       647,  647,  664,  407,  605,  602,  604,  648,  347,  648,
1107       648,  649,  346,  649,  649,  650,  345,  650,  650,  651,
1108       606,  651,  651,  650,  344,  607,  652,  651,  652,  652,
1109       653,  343,  653,  653,  652,  654,  340,  654,  654,  655,
1110       339,  655,  655,  656,  338,  656,  656,  657,  654,  657,
1111       657,  656,  658,  337,  658,  658,  659,  336,  659,  659,
1112       657,  660,  335,  660,  660,  661,  662,  661,  661,  662,
1113       665,  334,  666,  665,  662,  666,  667,  668,  669,  667,
1114       668,  669,  333,  332,  670,  668,  669,  670,  671,  659,
1115       331,  671,  670,  672,  658,  673,  672,  674,  673,  675,
1116
1117       674,  676,  675,  660,  676,  674,  672,  677,  678,  330,
1118       677,  678,  675,  679,  698,  329,  679,  698,  701,  328,
1119       701,  701,  702,  327,  702,  702,  703,  326,  703,  703,
1120       704,  325,  704,  704,  705,  711,  705,  705,  711,  324,
1121       677,  323,  705,  676,  706,  712,  706,  706,  712,  707,
1122       678,  707,  707,  709,  322,  709,  709,  707,  708,  698,
1123       708,  708,  315,  710,  708,  710,  710,  713,  714,  715,
1124       713,  714,  715,  716,  310,  717,  716,  715,  717,  718,
1125       309,  719,  718,  717,  719,  718,  720,  724,  729,  720,
1126       724,  729,  731,  307,  306,  731,  710,  732,  709,  732,
1127
1128       732,  733,  738,  733,  733,  738,  734,  305,  734,  734,
1129       735,  302,  735,  735,  736,  300,  736,  736,  737,  720,
1130       737,  737,  739,  299,  740,  739,  719,  740,  741,  298,
1131       297,  741,  724,  729,  296,  295,  742,  731,  734,  742,
1132       743,  745,  748,  743,  745,  748,  750,  294,  750,  750,
1133       751,  754,  751,  751,  754,  735,  740,  293,  752,  736,
1134       752,  752,  753,  737,  753,  753,  755,  756,  757,  755,
1135       756,  757,  761,  741,  761,  761,  292,  291,  290,  750,
1136       762,  742,  762,  762,  754,  743,  745,  748,  763,  764,
1137       289,  763,  764,  767,  768,  767,  767,  768,  771,  772,
1138
1139       771,  771,  772,  752,  288,  287,  775,  753,  775,  775,
1140       286,  761,  756,  757,  775,  776,  285,  779,  776,  779,
1141       779,  780,  284,  776,  780,  281,  210,  763,  208,  205,
1142       204,  202,  201,  771,  772,  767,  768,  782,  782,  782,
1143       782,  782,  782,  783,  783,  783,  783,  783,  783,  784,
1144       784,  784,  784,  784,  784,  785,  785,  785,  785,  785,
1145       785,  786,  786,  786,  786,  786,  786,  787,  787,  787,
1146       787,  787,  787,  788,  788,  788,  788,  788,  788,  789,
1147       789,  789,  789,  789,  789,  790,  790,  790,  790,  790,
1148       790,  791,  791,  199,  791,  791,  791,  792,  792,  792,
1149
1150       792,  792,  792,  793,  194,  190,  189,  793,  793,  794,
1151       794,  794,  794,  794,  794,  795,  795,  187,  186,  795,
1152       795,  796,  796,  796,  185,  796,  796,  797,  797,  182,
1153       797,  797,  797,  798,  798,  180,  798,  798,  798,  799,
1154       799,  179,  175,  173,  799,  800,  800,  172,  800,  800,
1155       800,  802,  802,  171,  170,  169,  802,  803,  803,  803,
1156       803,  803,  803,  804,  804,  168,  167,  166,  804,  805,
1157       805,  165,  805,  805,  805,  164,  163,  162,  161,  160,
1158       159,  158,  157,  149,  143,  142,  139,  138,  137,  135,
1159       134,  130,  129,  128,  127,  126,  124,  121,  118,  117,
1160
1161       112,  111,  110,  108,  107,  103,  102,  101,  100,   99,
1162        70,   67,   65,   64,   62,   60,   58,   55,   50,   47,
1163        44,   43,   38,   37,   36,   34,   33,   29,   28,   27,
1164        26,   25,   23,   19,  781,  781,  781,  781,  781,  781,
1165       781,  781,  781,  781,  781,  781,  781,  781,  781,  781,
1166       781,  781,  781,  781,  781,  781,  781,  781,  781,  781,
1167       781,  781,  781,  781,  781,  781,  781,  781,  781,  781,
1168       781,  781,  781,  781,  781,  781,  781,  781,  781,  781,
1169       781,  781,  781
1170     } ;
1171
1172 /* Table of booleans, true if rule could match eol. */
1173 static yyconst flex_int32_t yy_rule_can_match_eol[63] =
1174     {   0,
1175 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 
1176     1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
1177     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 
1178     1, 0, 0,     };
1179
1180 static yy_state_type yy_last_accepting_state;
1181 static char *yy_last_accepting_cpos;
1182
1183 extern int yy_flex_debug;
1184 int yy_flex_debug = 0;
1185
1186 /* The intent behind this definition is that it'll catch
1187  * any uses of REJECT which flex missed.
1188  */
1189 #define REJECT reject_used_but_not_detected
1190 #define yymore() yymore_used_but_not_detected
1191 #define YY_MORE_ADJ 0
1192 #define YY_RESTORE_YY_MORE_OFFSET
1193 char *yytext;
1194 #line 1 "levcomp.lpp"
1195 #line 2 "levcomp.lpp"
1196
1197 // levcomp.lpp:
1198 //      Level compiler lexer for Dungeon Crawl Stone Soup.
1199 // 
1200 // Based loosely on NetHack's lev_comp.l
1201
1202 #include "AppHdr.h"
1203 #include "mapdef.h"
1204 #include "levcomp.tab.h"
1205 #include <cstring>
1206 #include <queue>
1207
1208 static bool alloced = false;
1209
1210 std::queue<const char *> free_queue;
1211
1212 static void flush_free_queue(unsigned int max_allowed)
1213 {
1214     while (free_queue.size() > max_allowed)
1215     {
1216         const char *s = free_queue.front();
1217         free((void *) s);
1218         free_queue.pop();
1219     }
1220 }
1221
1222 static void add_to_queue(const char *s)
1223 {
1224     free_queue.push(s);
1225     flush_free_queue(100);
1226 }
1227
1228 static void clean()
1229 {
1230     if (yylval.text && alloced)
1231         add_to_queue(yylval.text);
1232     yylval.text = NULL;
1233     alloced = false;
1234 }
1235
1236 static char *copy_text(bool trim_right, int strip_trailing)
1237 {
1238     char *newstring = NULL;
1239     if ((yylval.text = newstring = strdup(yytext)))
1240     {
1241         alloced = true;
1242         char *s = NULL;
1243         if (trim_right)
1244         {
1245             s = newstring + strlen(newstring) - 1;
1246             while (isspace(*s) && s >= newstring)
1247                 *s-- = 0;
1248         }
1249         if (strip_trailing)
1250         {
1251             if (!s)
1252                 s = newstring + strlen(newstring) - 1;
1253             while (s >= newstring && --strip_trailing >= 0)
1254                 *s-- = 0;
1255         }
1256     }
1257     return (newstring);
1258 }
1259
1260 static void settext(bool trim_right = false, int strip_trailing = 0)
1261 {
1262     clean();
1263     char *newstring = copy_text(trim_right, strip_trailing);
1264     yylval.text = newstring;
1265 }
1266
1267
1268
1269
1270
1271
1272
1273
1274
1275 #line 1276 "levcomp.lex.cc"
1276
1277 #define INITIAL 0
1278 #define MAPDEF 1
1279 #define LUA 2
1280 #define LUA_ONELINER 3
1281 #define ARGUMENT 4
1282 #define MNAME 5
1283 #define KEYWORDS 6
1284 #define ITEM_LIST 7
1285 #define TOEOL 8
1286
1287 #ifndef YY_NO_UNISTD_H
1288 /* Special case for "unistd.h", since it is non-ANSI. We include it way
1289  * down here because we want the user's section 1 to have been scanned first.
1290  * The user has a chance to override it with an option.
1291  */
1292 #include <unistd.h>
1293 #endif
1294
1295 #ifndef YY_EXTRA_TYPE
1296 #define YY_EXTRA_TYPE void *
1297 #endif
1298
1299 static int yy_init_globals (void );
1300
1301 /* Macros after this point can all be overridden by user definitions in
1302  * section 1.
1303  */
1304
1305 #ifndef YY_SKIP_YYWRAP
1306 #ifdef __cplusplus
1307 extern "C" int yywrap (void );
1308 #else
1309 extern int yywrap (void );
1310 #endif
1311 #endif
1312
1313     static void yyunput (int c,char *buf_ptr  );
1314     
1315 #ifndef yytext_ptr
1316 static void yy_flex_strncpy (char *,yyconst char *,int );
1317 #endif
1318
1319 #ifdef YY_NEED_STRLEN
1320 static int yy_flex_strlen (yyconst char * );
1321 #endif
1322
1323 #ifndef YY_NO_INPUT
1324
1325 #ifdef __cplusplus
1326 static int yyinput (void );
1327 #else
1328 static int input (void );
1329 #endif
1330
1331 #endif
1332
1333 /* Amount of stuff to slurp up with each read. */
1334 #ifndef YY_READ_BUF_SIZE
1335 #define YY_READ_BUF_SIZE 8192
1336 #endif
1337
1338 /* Copy whatever the last rule matched to the standard output. */
1339 #ifndef ECHO
1340 /* This used to be an fputs(), but since the string might contain NUL's,
1341  * we now use fwrite().
1342  */
1343 #define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
1344 #endif
1345
1346 /* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
1347  * is returned in "result".
1348  */
1349 #ifndef YY_INPUT
1350 #define YY_INPUT(buf,result,max_size) \
1351         if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
1352                 { \
1353                 int c = '*'; \
1354                 size_t n; \
1355                 for ( n = 0; n < max_size && \
1356                              (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
1357                         buf[n] = (char) c; \
1358                 if ( c == '\n' ) \
1359                         buf[n++] = (char) c; \
1360                 if ( c == EOF && ferror( yyin ) ) \
1361                         YY_FATAL_ERROR( "input in flex scanner failed" ); \
1362                 result = n; \
1363                 } \
1364         else \
1365                 { \
1366                 errno=0; \
1367                 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
1368                         { \
1369                         if( errno != EINTR) \
1370                                 { \
1371                                 YY_FATAL_ERROR( "input in flex scanner failed" ); \
1372                                 break; \
1373                                 } \
1374                         errno=0; \
1375                         clearerr(yyin); \
1376                         } \
1377                 }\
1378 \
1379
1380 #endif
1381
1382 /* No semi-colon after return; correct usage is to write "yyterminate();" -
1383  * we don't want an extra ';' after the "return" because that will cause
1384  * some compilers to complain about unreachable statements.
1385  */
1386 #ifndef yyterminate
1387 #define yyterminate() return YY_NULL
1388 #endif
1389
1390 /* Number of entries by which start-condition stack grows. */
1391 #ifndef YY_START_STACK_INCR
1392 #define YY_START_STACK_INCR 25
1393 #endif
1394
1395 /* Report a fatal error. */
1396 #ifndef YY_FATAL_ERROR
1397 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
1398 #endif
1399
1400 /* end tables serialization structures and prototypes */
1401
1402 /* Default declaration of generated scanner - a define so the user can
1403  * easily add parameters.
1404  */
1405 #ifndef YY_DECL
1406 #define YY_DECL_IS_OURS 1
1407
1408 extern int yylex (void);
1409
1410 #define YY_DECL int yylex (void)
1411 #endif /* !YY_DECL */
1412
1413 /* Code executed at the beginning of each rule, after yytext and yyleng
1414  * have been set up.
1415  */
1416 #ifndef YY_USER_ACTION
1417 #define YY_USER_ACTION
1418 #endif
1419
1420 /* Code executed at the end of each rule. */
1421 #ifndef YY_BREAK
1422 #define YY_BREAK break;
1423 #endif
1424
1425 #define YY_RULE_SETUP \
1426         if ( yyleng > 0 ) \
1427                 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
1428                                 (yytext[yyleng - 1] == '\n'); \
1429         YY_USER_ACTION
1430
1431 /** The main scanner function which does all the work.
1432  */
1433 YY_DECL
1434 {
1435         register yy_state_type yy_current_state;
1436         register char *yy_cp, *yy_bp;
1437         register int yy_act;
1438     
1439 #line 89 "levcomp.lpp"
1440
1441
1442 #line 1443 "levcomp.lex.cc"
1443
1444         if ( !(yy_init) )
1445                 {
1446                 (yy_init) = 1;
1447
1448 #ifdef YY_USER_INIT
1449                 YY_USER_INIT;
1450 #endif
1451
1452                 if ( ! (yy_start) )
1453                         (yy_start) = 1; /* first start state */
1454
1455                 if ( ! yyin )
1456                         yyin = stdin;
1457
1458                 if ( ! yyout )
1459                         yyout = stdout;
1460
1461                 if ( ! YY_CURRENT_BUFFER ) {
1462                         yyensure_buffer_stack ();
1463                         YY_CURRENT_BUFFER_LVALUE =
1464                                 yy_create_buffer(yyin,YY_BUF_SIZE );
1465                 }
1466
1467                 yy_load_buffer_state( );
1468                 }
1469
1470         while ( 1 )             /* loops until end-of-file is reached */
1471                 {
1472                 yy_cp = (yy_c_buf_p);
1473
1474                 /* Support of yytext. */
1475                 *yy_cp = (yy_hold_char);
1476
1477                 /* yy_bp points to the position in yy_ch_buf of the start of
1478                  * the current run.
1479                  */
1480                 yy_bp = yy_cp;
1481
1482                 yy_current_state = (yy_start);
1483                 yy_current_state += YY_AT_BOL();
1484 yy_match:
1485                 do
1486                         {
1487                         register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
1488                         if ( yy_accept[yy_current_state] )
1489                                 {
1490                                 (yy_last_accepting_state) = yy_current_state;
1491                                 (yy_last_accepting_cpos) = yy_cp;
1492                                 }
1493                         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1494                                 {
1495                                 yy_current_state = (int) yy_def[yy_current_state];
1496                                 if ( yy_current_state >= 782 )
1497                                         yy_c = yy_meta[(unsigned int) yy_c];
1498                                 }
1499                         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1500                         ++yy_cp;
1501                         }
1502                 while ( yy_current_state != 781 );
1503                 yy_cp = (yy_last_accepting_cpos);
1504                 yy_current_state = (yy_last_accepting_state);
1505
1506 yy_find_action:
1507                 yy_act = yy_accept[yy_current_state];
1508
1509                 YY_DO_BEFORE_ACTION;
1510
1511                 if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
1512                         {
1513                         int yyl;
1514                         for ( yyl = 0; yyl < yyleng; ++yyl )
1515                                 if ( yytext[yyl] == '\n' )
1516                                            
1517     yylineno++;
1518 ;
1519                         }
1520
1521 do_action:      /* This label is used only to access EOF actions. */
1522
1523                 switch ( yy_act )
1524         { /* beginning of action switch */
1525                         case 0: /* must back up */
1526                         /* undo the effects of YY_DO_BEFORE_ACTION */
1527                         *yy_cp = (yy_hold_char);
1528                         yy_cp = (yy_last_accepting_cpos);
1529                         yy_current_state = (yy_last_accepting_state);
1530                         goto yy_find_action;
1531
1532 case 1:
1533 YY_RULE_SETUP
1534 #line 91 "levcomp.lpp"
1535 { BEGIN(INITIAL); }
1536         YY_BREAK
1537 case 2:
1538 YY_RULE_SETUP
1539 #line 93 "levcomp.lpp"
1540 {
1541                         settext(true);
1542                         return MAP_LINE;
1543                     }
1544         YY_BREAK
1545 case 3:
1546 /* rule 3 can match eol */
1547 YY_RULE_SETUP
1548 #line 98 "levcomp.lpp"
1549 return CHARACTER;
1550         YY_BREAK
1551 case 4:
1552 YY_RULE_SETUP
1553 #line 99 "levcomp.lpp"
1554 return CHARACTER;
1555         YY_BREAK
1556 case 5:
1557 YY_RULE_SETUP
1558 #line 100 "levcomp.lpp"
1559 return CHARACTER;
1560         YY_BREAK
1561 case 6:
1562 /* rule 6 can match eol */
1563 YY_RULE_SETUP
1564 #line 102 "levcomp.lpp"
1565 ;
1566         YY_BREAK
1567 case 7:
1568 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1569 (yy_c_buf_p) = yy_cp -= 1;
1570 YY_DO_BEFORE_ACTION; /* set up yytext again */
1571 YY_RULE_SETUP
1572 #line 104 "levcomp.lpp"
1573 { BEGIN(INITIAL); }
1574         YY_BREAK
1575 case 8:
1576 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1577 (yy_c_buf_p) = yy_cp -= 1;
1578 YY_DO_BEFORE_ACTION; /* set up yytext again */
1579 YY_RULE_SETUP
1580 #line 105 "levcomp.lpp"
1581 {
1582                             settext(true, 2);
1583                             BEGIN(INITIAL);
1584                             return LUA_LINE;
1585                         }
1586         YY_BREAK
1587 case 9:
1588 YY_RULE_SETUP
1589 #line 110 "levcomp.lpp"
1590 {
1591                             settext();
1592                             return LUA_LINE;
1593                         }
1594         YY_BREAK
1595 case 10:
1596 /* rule 10 can match eol */
1597 YY_RULE_SETUP
1598 #line 114 "levcomp.lpp"
1599 ;
1600         YY_BREAK
1601 case 11:
1602 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1603 (yy_c_buf_p) = yy_cp -= 1;
1604 YY_DO_BEFORE_ACTION; /* set up yytext again */
1605 YY_RULE_SETUP
1606 #line 116 "levcomp.lpp"
1607 {
1608                             settext();
1609                             return LUA_LINE;
1610                         }
1611         YY_BREAK
1612 case 12:
1613 /* rule 12 can match eol */
1614 YY_RULE_SETUP
1615 #line 120 "levcomp.lpp"
1616 { BEGIN(INITIAL); }
1617         YY_BREAK
1618 case 13:
1619 YY_RULE_SETUP
1620 #line 122 "levcomp.lpp"
1621 {
1622                         settext();
1623                         return STRING;
1624                     }
1625         YY_BREAK
1626 case 14:
1627 YY_RULE_SETUP
1628 #line 127 "levcomp.lpp"
1629 ;
1630         YY_BREAK
1631 case 15:
1632 /* rule 15 can match eol */
1633 YY_RULE_SETUP
1634 #line 128 "levcomp.lpp"
1635 { BEGIN(INITIAL); }
1636         YY_BREAK
1637 case 16:
1638 YY_RULE_SETUP
1639 #line 130 "levcomp.lpp"
1640
1641                         settext();
1642                         return ITEM_INFO;
1643                     }
1644         YY_BREAK
1645 case 17:
1646 YY_RULE_SETUP
1647 #line 135 "levcomp.lpp"
1648 {
1649                         settext();
1650                         return ITEM_INFO;
1651                     }
1652         YY_BREAK
1653 case 18:
1654 YY_RULE_SETUP
1655 #line 140 "levcomp.lpp"
1656 return COMMA;
1657         YY_BREAK
1658 case 19:
1659 YY_RULE_SETUP
1660 #line 141 "levcomp.lpp"
1661 ;
1662         YY_BREAK
1663 case 20:
1664 /* rule 20 can match eol */
1665 YY_RULE_SETUP
1666 #line 142 "levcomp.lpp"
1667 { BEGIN(INITIAL); }
1668         YY_BREAK
1669 case 21:
1670 /* rule 21 can match eol */
1671 YY_RULE_SETUP
1672 #line 144 "levcomp.lpp"
1673 { BEGIN(INITIAL); }
1674         YY_BREAK
1675 case 22:
1676 YY_RULE_SETUP
1677 #line 146 "levcomp.lpp"
1678
1679                         settext();
1680                         return MONSTER_NAME; 
1681                     }
1682         YY_BREAK
1683 case 23:
1684 YY_RULE_SETUP
1685 #line 151 "levcomp.lpp"
1686 return COMMA;
1687         YY_BREAK
1688 case 24:
1689 YY_RULE_SETUP
1690 #line 152 "levcomp.lpp"
1691 ;
1692         YY_BREAK
1693 case 25:
1694 YY_RULE_SETUP
1695 #line 154 "levcomp.lpp"
1696
1697                         BEGIN(INITIAL);
1698                         settext();
1699                         return STRING; 
1700                     }
1701         YY_BREAK
1702 case 26:
1703 /* rule 26 can match eol */
1704 YY_RULE_SETUP
1705 #line 160 "levcomp.lpp"
1706 { BEGIN(INITIAL); }
1707         YY_BREAK
1708 case 27:
1709 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1710 (yy_c_buf_p) = yy_cp -= 1;
1711 YY_DO_BEFORE_ACTION; /* set up yytext again */
1712 YY_RULE_SETUP
1713 #line 162 "levcomp.lpp"
1714 {
1715                         settext(true, 1);
1716                         return STRING;
1717                     }
1718         YY_BREAK
1719 case 28:
1720 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1721 (yy_c_buf_p) = yy_cp -= 1;
1722 YY_DO_BEFORE_ACTION; /* set up yytext again */
1723 YY_RULE_SETUP
1724 #line 167 "levcomp.lpp"
1725 {
1726                         BEGIN(INITIAL);
1727                         settext();
1728                         return STRING;
1729                     }
1730         YY_BREAK
1731 case 29:
1732 /* rule 29 can match eol */
1733 YY_RULE_SETUP
1734 #line 172 "levcomp.lpp"
1735 ;
1736         YY_BREAK
1737 case 30:
1738 YY_RULE_SETUP
1739 #line 174 "levcomp.lpp"
1740 ;
1741         YY_BREAK
1742 case 31:
1743 *yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
1744 (yy_c_buf_p) = yy_cp -= 1;
1745 YY_DO_BEFORE_ACTION; /* set up yytext again */
1746 YY_RULE_SETUP
1747 #line 176 "levcomp.lpp"
1748 { BEGIN(MAPDEF); }
1749         YY_BREAK
1750 case 32:
1751 YY_RULE_SETUP
1752 #line 178 "levcomp.lpp"
1753 { BEGIN(LUA_ONELINER); return MAIN; }
1754         YY_BREAK
1755 case 33:
1756 YY_RULE_SETUP
1757 #line 180 "levcomp.lpp"
1758 { BEGIN(LUA); return PRELUDE; }      
1759         YY_BREAK
1760 case 34:
1761 YY_RULE_SETUP
1762 #line 181 "levcomp.lpp"
1763 { BEGIN(LUA); return MAIN; }
1764         YY_BREAK
1765 case 35:
1766 YY_RULE_SETUP
1767 #line 182 "levcomp.lpp"
1768 { BEGIN(LUA); return MAIN; }
1769         YY_BREAK
1770 case 36:
1771 YY_RULE_SETUP
1772 #line 183 "levcomp.lpp"
1773 { BEGIN(LUA); return VALIDATE; }
1774         YY_BREAK
1775 case 37:
1776 YY_RULE_SETUP
1777 #line 184 "levcomp.lpp"
1778 { BEGIN(LUA); return VETO; }
1779         YY_BREAK
1780 case 38:
1781 YY_RULE_SETUP
1782 #line 187 "levcomp.lpp"
1783 { BEGIN(ARGUMENT); return NAME; }
1784         YY_BREAK
1785 case 39:
1786 YY_RULE_SETUP
1787 #line 188 "levcomp.lpp"
1788 { BEGIN(ARGUMENT); return DEFAULT_DEPTH; }
1789         YY_BREAK
1790 case 40:
1791 YY_RULE_SETUP
1792 #line 189 "levcomp.lpp"
1793 { BEGIN(ARGUMENT); return DEPTH; }
1794         YY_BREAK
1795 case 41:
1796 YY_RULE_SETUP
1797 #line 190 "levcomp.lpp"
1798 { BEGIN(ARGUMENT); return ORIENT; }
1799         YY_BREAK
1800 case 42:
1801 YY_RULE_SETUP
1802 #line 191 "levcomp.lpp"
1803 { BEGIN(ARGUMENT); return PLACE; }
1804         YY_BREAK
1805 case 43:
1806 YY_RULE_SETUP
1807 #line 192 "levcomp.lpp"
1808 { BEGIN(ARGUMENT); return WELCOME; }
1809         YY_BREAK
1810 case 44:
1811 YY_RULE_SETUP
1812 #line 193 "levcomp.lpp"
1813 return CHANCE;
1814         YY_BREAK
1815 case 45:
1816 YY_RULE_SETUP
1817 #line 194 "levcomp.lpp"
1818 return CHANCE;
1819         YY_BREAK
1820 case 46:
1821 YY_RULE_SETUP
1822 #line 195 "levcomp.lpp"
1823 { BEGIN(KEYWORDS); return TAGS; }
1824         YY_BREAK
1825 case 47:
1826 YY_RULE_SETUP
1827 #line 196 "levcomp.lpp"
1828 { BEGIN(KEYWORDS); return TAGS; }
1829         YY_BREAK
1830 case 48:
1831 YY_RULE_SETUP
1832 #line 197 "levcomp.lpp"
1833 { BEGIN(ITEM_LIST); return SUBST; }
1834         YY_BREAK
1835 case 49:
1836 YY_RULE_SETUP
1837 #line 198 "levcomp.lpp"
1838 { BEGIN(ITEM_LIST); return NSUBST; }
1839         YY_BREAK
1840 case 50:
1841 YY_RULE_SETUP
1842 #line 199 "levcomp.lpp"
1843 { BEGIN(MNAME); return MONS; }
1844         YY_BREAK
1845 case 51:
1846 YY_RULE_SETUP
1847 #line 200 "levcomp.lpp"
1848 { BEGIN(ITEM_LIST); return ITEM; }
1849         YY_BREAK
1850 case 52:
1851 YY_RULE_SETUP
1852 #line 201 "levcomp.lpp"
1853 { BEGIN(TOEOL); return MARKER; }
1854         YY_BREAK
1855 case 53:
1856 YY_RULE_SETUP
1857 #line 202 "levcomp.lpp"
1858 { BEGIN(ITEM_LIST); return SHUFFLE; }
1859         YY_BREAK
1860 case 54:
1861 YY_RULE_SETUP
1862 #line 204 "levcomp.lpp"
1863 { BEGIN(ARGUMENT); return KFEAT; }
1864         YY_BREAK
1865 case 55:
1866 YY_RULE_SETUP
1867 #line 205 "levcomp.lpp"
1868 { BEGIN(ARGUMENT); return KITEM; }
1869         YY_BREAK
1870 case 56:
1871 YY_RULE_SETUP
1872 #line 206 "levcomp.lpp"
1873 { BEGIN(ARGUMENT); return KMONS; }
1874         YY_BREAK
1875 case 57:
1876 YY_RULE_SETUP
1877 #line 208 "levcomp.lpp"
1878 return COMMA;
1879         YY_BREAK
1880 case 58:
1881 YY_RULE_SETUP
1882 #line 210 "levcomp.lpp"
1883 {
1884                         clean();
1885                         yylval.i = atoi(yytext);
1886                         return INTEGER;
1887                     }
1888         YY_BREAK
1889 case 59:
1890 YY_RULE_SETUP
1891 #line 216 "levcomp.lpp"
1892 ;
1893         YY_BREAK
1894 case 60:
1895 /* rule 60 can match eol */
1896 YY_RULE_SETUP
1897 #line 217 "levcomp.lpp"
1898 ;
1899         YY_BREAK
1900 case 61:
1901 YY_RULE_SETUP
1902 #line 218 "levcomp.lpp"
1903 return CHARACTER;
1904         YY_BREAK
1905 case 62:
1906 YY_RULE_SETUP
1907 #line 220 "levcomp.lpp"
1908 ECHO;
1909         YY_BREAK
1910 #line 1911 "levcomp.lex.cc"
1911 case YY_STATE_EOF(INITIAL):
1912 case YY_STATE_EOF(MAPDEF):
1913 case YY_STATE_EOF(LUA):
1914 case YY_STATE_EOF(LUA_ONELINER):
1915 case YY_STATE_EOF(ARGUMENT):
1916 case YY_STATE_EOF(MNAME):
1917 case YY_STATE_EOF(KEYWORDS):
1918 case YY_STATE_EOF(ITEM_LIST):
1919 case YY_STATE_EOF(TOEOL):
1920         yyterminate();
1921
1922         case YY_END_OF_BUFFER:
1923                 {
1924                 /* Amount of text matched not including the EOB char. */
1925                 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1926
1927                 /* Undo the effects of YY_DO_BEFORE_ACTION. */
1928                 *yy_cp = (yy_hold_char);
1929                 YY_RESTORE_YY_MORE_OFFSET
1930
1931                 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1932                         {
1933                         /* We're scanning a new file or input source.  It's
1934                          * possible that this happened because the user
1935                          * just pointed yyin at a new source and called
1936                          * yylex().  If so, then we have to assure
1937                          * consistency between YY_CURRENT_BUFFER and our
1938                          * globals.  Here is the right place to do so, because
1939                          * this is the first action (other than possibly a
1940                          * back-up) that will match for the new input source.
1941                          */
1942                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1943                         YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1944                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1945                         }
1946
1947                 /* Note that here we test for yy_c_buf_p "<=" to the position
1948                  * of the first EOB in the buffer, since yy_c_buf_p will
1949                  * already have been incremented past the NUL character
1950                  * (since all states make transitions on EOB to the
1951                  * end-of-buffer state).  Contrast this with the test
1952                  * in input().
1953                  */
1954                 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1955                         { /* This was really a NUL. */
1956                         yy_state_type yy_next_state;
1957
1958                         (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1959
1960                         yy_current_state = yy_get_previous_state(  );
1961
1962                         /* Okay, we're now positioned to make the NUL
1963                          * transition.  We couldn't have
1964                          * yy_get_previous_state() go ahead and do it
1965                          * for us because it doesn't know how to deal
1966                          * with the possibility of jamming (and we don't
1967                          * want to build jamming into it because then it
1968                          * will run more slowly).
1969                          */
1970
1971                         yy_next_state = yy_try_NUL_trans( yy_current_state );
1972
1973                         yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1974
1975                         if ( yy_next_state )
1976                                 {
1977                                 /* Consume the NUL. */
1978                                 yy_cp = ++(yy_c_buf_p);
1979                                 yy_current_state = yy_next_state;
1980                                 goto yy_match;
1981                                 }
1982
1983                         else
1984                                 {
1985                                 yy_cp = (yy_last_accepting_cpos);
1986                                 yy_current_state = (yy_last_accepting_state);
1987                                 goto yy_find_action;
1988                                 }
1989                         }
1990
1991                 else switch ( yy_get_next_buffer(  ) )
1992                         {
1993                         case EOB_ACT_END_OF_FILE:
1994                                 {
1995                                 (yy_did_buffer_switch_on_eof) = 0;
1996
1997                                 if ( yywrap( ) )
1998                                         {
1999                                         /* Note: because we've taken care in
2000                                          * yy_get_next_buffer() to have set up
2001                                          * yytext, we can now set up
2002                                          * yy_c_buf_p so that if some total
2003                                          * hoser (like flex itself) wants to
2004                                          * call the scanner after we return the
2005                                          * YY_NULL, it'll still work - another
2006                                          * YY_NULL will get returned.
2007                                          */
2008                                         (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
2009
2010                                         yy_act = YY_STATE_EOF(YY_START);
2011                                         goto do_action;
2012                                         }
2013
2014                                 else
2015                                         {
2016                                         if ( ! (yy_did_buffer_switch_on_eof) )
2017                                                 YY_NEW_FILE;
2018                                         }
2019                                 break;
2020                                 }
2021
2022                         case EOB_ACT_CONTINUE_SCAN:
2023                                 (yy_c_buf_p) =
2024                                         (yytext_ptr) + yy_amount_of_matched_text;
2025
2026                                 yy_current_state = yy_get_previous_state(  );
2027
2028                                 yy_cp = (yy_c_buf_p);
2029                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
2030                                 goto yy_match;
2031
2032                         case EOB_ACT_LAST_MATCH:
2033                                 (yy_c_buf_p) =
2034                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
2035
2036                                 yy_current_state = yy_get_previous_state(  );
2037
2038                                 yy_cp = (yy_c_buf_p);
2039                                 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
2040                                 goto yy_find_action;
2041                         }
2042                 break;
2043                 }
2044
2045         default:
2046                 YY_FATAL_ERROR(
2047                         "fatal flex scanner internal error--no action found" );
2048         } /* end of action switch */
2049                 } /* end of scanning one token */
2050 } /* end of yylex */
2051
2052 /* yy_get_next_buffer - try to read in a new buffer
2053  *
2054  * Returns a code representing an action:
2055  *      EOB_ACT_LAST_MATCH -
2056  *      EOB_ACT_CONTINUE_SCAN - continue scanning from current position
2057  *      EOB_ACT_END_OF_FILE - end of file
2058  */
2059 static int yy_get_next_buffer (void)
2060 {
2061         register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
2062         register char *source = (yytext_ptr);
2063         register int number_to_move, i;
2064         int ret_val;
2065
2066         if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
2067                 YY_FATAL_ERROR(
2068                 "fatal flex scanner internal error--end of buffer missed" );
2069
2070         if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
2071                 { /* Don't try to fill the buffer, so this is an EOF. */
2072                 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
2073                         {
2074                         /* We matched a single character, the EOB, so
2075                          * treat this as a final EOF.
2076                          */
2077                         return EOB_ACT_END_OF_FILE;
2078                         }
2079
2080                 else
2081                         {
2082                         /* We matched some text prior to the EOB, first
2083                          * process it.
2084                          */
2085                         return EOB_ACT_LAST_MATCH;
2086                         }
2087                 }
2088
2089         /* Try to read more data. */
2090
2091         /* First move last chars to start of buffer. */
2092         number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
2093
2094         for ( i = 0; i < number_to_move; ++i )
2095                 *(dest++) = *(source++);
2096
2097         if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
2098                 /* don't do the read, it's not guaranteed to return an EOF,
2099                  * just force an EOF
2100                  */
2101                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
2102
2103         else
2104                 {
2105                         int num_to_read =
2106                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
2107
2108                 while ( num_to_read <= 0 )
2109                         { /* Not enough room in the buffer - grow it. */
2110
2111                         /* just a shorter name for the current buffer */
2112                         YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
2113
2114                         int yy_c_buf_p_offset =
2115                                 (int) ((yy_c_buf_p) - b->yy_ch_buf);
2116
2117                         if ( b->yy_is_our_buffer )
2118                                 {
2119                                 int new_size = b->yy_buf_size * 2;
2120
2121                                 if ( new_size <= 0 )
2122                                         b->yy_buf_size += b->yy_buf_size / 8;
2123                                 else
2124                                         b->yy_buf_size *= 2;
2125
2126                                 b->yy_ch_buf = (char *)
2127                                         /* Include room in for 2 EOB chars. */
2128                                         yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2  );
2129                                 }
2130                         else
2131                                 /* Can't grow it, we don't own it. */
2132                                 b->yy_ch_buf = 0;
2133
2134                         if ( ! b->yy_ch_buf )
2135                                 YY_FATAL_ERROR(
2136                                 "fatal error - scanner input buffer overflow" );
2137
2138                         (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
2139
2140                         num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
2141                                                 number_to_move - 1;
2142
2143                         }
2144
2145                 if ( num_to_read > YY_READ_BUF_SIZE )
2146                         num_to_read = YY_READ_BUF_SIZE;
2147
2148                 /* Read in more data. */
2149                 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
2150                         (yy_n_chars), num_to_read );
2151
2152                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2153                 }
2154
2155         if ( (yy_n_chars) == 0 )
2156                 {
2157                 if ( number_to_move == YY_MORE_ADJ )
2158                         {
2159                         ret_val = EOB_ACT_END_OF_FILE;
2160                         yyrestart(yyin  );
2161                         }
2162
2163                 else
2164                         {
2165                         ret_val = EOB_ACT_LAST_MATCH;
2166                         YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
2167                                 YY_BUFFER_EOF_PENDING;
2168                         }
2169                 }
2170
2171         else
2172                 ret_val = EOB_ACT_CONTINUE_SCAN;
2173
2174         (yy_n_chars) += number_to_move;
2175         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
2176         YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
2177
2178         (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
2179
2180         return ret_val;
2181 }
2182
2183 /* yy_get_previous_state - get the state just before the EOB char was reached */
2184
2185     static yy_state_type yy_get_previous_state (void)
2186 {
2187         register yy_state_type yy_current_state;
2188         register char *yy_cp;
2189     
2190         yy_current_state = (yy_start);
2191         yy_current_state += YY_AT_BOL();
2192
2193         for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
2194                 {
2195                 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
2196                 if ( yy_accept[yy_current_state] )
2197                         {
2198                         (yy_last_accepting_state) = yy_current_state;
2199                         (yy_last_accepting_cpos) = yy_cp;
2200                         }
2201                 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2202                         {
2203                         yy_current_state = (int) yy_def[yy_current_state];
2204                         if ( yy_current_state >= 782 )
2205                                 yy_c = yy_meta[(unsigned int) yy_c];
2206                         }
2207                 yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2208                 }
2209
2210         return yy_current_state;
2211 }
2212
2213 /* yy_try_NUL_trans - try to make a transition on the NUL character
2214  *
2215  * synopsis
2216  *      next_state = yy_try_NUL_trans( current_state );
2217  */
2218     static yy_state_type yy_try_NUL_trans  (yy_state_type yy_current_state )
2219 {
2220         register int yy_is_jam;
2221         register char *yy_cp = (yy_c_buf_p);
2222
2223         register YY_CHAR yy_c = 1;
2224         if ( yy_accept[yy_current_state] )
2225                 {
2226                 (yy_last_accepting_state) = yy_current_state;
2227                 (yy_last_accepting_cpos) = yy_cp;
2228                 }
2229         while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
2230                 {
2231                 yy_current_state = (int) yy_def[yy_current_state];
2232                 if ( yy_current_state >= 782 )
2233                         yy_c = yy_meta[(unsigned int) yy_c];
2234                 }
2235         yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
2236         yy_is_jam = (yy_current_state == 781);
2237
2238         return yy_is_jam ? 0 : yy_current_state;
2239 }
2240
2241     static void yyunput (int c, register char * yy_bp )
2242 {
2243         register char *yy_cp;
2244     
2245     yy_cp = (yy_c_buf_p);
2246
2247         /* undo effects of setting up yytext */
2248         *yy_cp = (yy_hold_char);
2249
2250         if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
2251                 { /* need to shift things up to make room */
2252                 /* +2 for EOB chars. */
2253                 register int number_to_move = (yy_n_chars) + 2;
2254                 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
2255                                         YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
2256                 register char *source =
2257                                 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
2258
2259                 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
2260                         *--dest = *--source;
2261
2262                 yy_cp += (int) (dest - source);
2263                 yy_bp += (int) (dest - source);
2264                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
2265                         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
2266
2267                 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
2268                         YY_FATAL_ERROR( "flex scanner push-back overflow" );
2269                 }
2270
2271         *--yy_cp = (char) c;
2272
2273     if ( c == '\n' ){
2274         --yylineno;
2275     }
2276
2277         (yytext_ptr) = yy_bp;
2278         (yy_hold_char) = *yy_cp;
2279         (yy_c_buf_p) = yy_cp;
2280 }
2281
2282 #ifndef YY_NO_INPUT
2283 #ifdef __cplusplus
2284     static int yyinput (void)
2285 #else
2286     static int input  (void)
2287 #endif
2288
2289 {
2290         int c;
2291     
2292         *(yy_c_buf_p) = (yy_hold_char);
2293
2294         if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
2295                 {
2296                 /* yy_c_buf_p now points to the character we want to return.
2297                  * If this occurs *before* the EOB characters, then it's a
2298                  * valid NUL; if not, then we've hit the end of the buffer.
2299                  */
2300                 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
2301                         /* This was really a NUL. */
2302                         *(yy_c_buf_p) = '\0';
2303
2304                 else
2305                         { /* need more input */
2306                         int offset = (yy_c_buf_p) - (yytext_ptr);
2307                         ++(yy_c_buf_p);
2308
2309                         switch ( yy_get_next_buffer(  ) )
2310                                 {
2311                                 case EOB_ACT_LAST_MATCH:
2312                                         /* This happens because yy_g_n_b()
2313                                          * sees that we've accumulated a
2314                                          * token and flags that we need to
2315                                          * try matching the token before
2316                                          * proceeding.  But for input(),
2317                                          * there's no matching to consider.
2318                                          * So convert the EOB_ACT_LAST_MATCH
2319                                          * to EOB_ACT_END_OF_FILE.
2320                                          */
2321
2322                                         /* Reset buffer status. */
2323                                         yyrestart(yyin );
2324
2325                                         /*FALLTHROUGH*/
2326
2327                                 case EOB_ACT_END_OF_FILE:
2328                                         {
2329                                         if ( yywrap( ) )
2330                                                 return EOF;
2331
2332                                         if ( ! (yy_did_buffer_switch_on_eof) )
2333                                                 YY_NEW_FILE;
2334 #ifdef __cplusplus
2335                                         return yyinput();
2336 #else
2337                                         return input();
2338 #endif
2339                                         }
2340
2341                                 case EOB_ACT_CONTINUE_SCAN:
2342                                         (yy_c_buf_p) = (yytext_ptr) + offset;
2343                                         break;
2344                                 }
2345                         }
2346                 }
2347
2348         c = *(unsigned char *) (yy_c_buf_p);    /* cast for 8-bit char's */
2349         *(yy_c_buf_p) = '\0';   /* preserve yytext */
2350         (yy_hold_char) = *++(yy_c_buf_p);
2351
2352         YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\n');
2353         if ( YY_CURRENT_BUFFER_LVALUE->yy_at_bol )
2354                    
2355     yylineno++;
2356 ;
2357
2358         return c;
2359 }
2360 #endif  /* ifndef YY_NO_INPUT */
2361
2362 /** Immediately switch to a different input stream.
2363  * @param input_file A readable stream.
2364  * 
2365  * @note This function does not reset the start condition to @c INITIAL .
2366  */
2367     void yyrestart  (FILE * input_file )
2368 {
2369     
2370         if ( ! YY_CURRENT_BUFFER ){
2371         yyensure_buffer_stack ();
2372                 YY_CURRENT_BUFFER_LVALUE =
2373             yy_create_buffer(yyin,YY_BUF_SIZE );
2374         }
2375
2376         yy_init_buffer(YY_CURRENT_BUFFER,input_file );
2377         yy_load_buffer_state( );
2378 }
2379
2380 /** Switch to a different input buffer.
2381  * @param new_buffer The new input buffer.
2382  * 
2383  */
2384     void yy_switch_to_buffer  (YY_BUFFER_STATE  new_buffer )
2385 {
2386     
2387         /* TODO. We should be able to replace this entire function body
2388          * with
2389          *              yypop_buffer_state();
2390          *              yypush_buffer_state(new_buffer);
2391      */
2392         yyensure_buffer_stack ();
2393         if ( YY_CURRENT_BUFFER == new_buffer )
2394                 return;
2395
2396         if ( YY_CURRENT_BUFFER )
2397                 {
2398                 /* Flush out information for old buffer. */
2399                 *(yy_c_buf_p) = (yy_hold_char);
2400                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
2401                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2402                 }
2403
2404         YY_CURRENT_BUFFER_LVALUE = new_buffer;
2405         yy_load_buffer_state( );
2406
2407         /* We don't actually know whether we did this switch during
2408          * EOF (yywrap()) processing, but the only time this flag
2409          * is looked at is after yywrap() is called, so it's safe
2410          * to go ahead and always set it.
2411          */
2412         (yy_did_buffer_switch_on_eof) = 1;
2413 }
2414
2415 static void yy_load_buffer_state  (void)
2416 {
2417         (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
2418         (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
2419         yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
2420         (yy_hold_char) = *(yy_c_buf_p);
2421 }
2422
2423 /** Allocate and initialize an input buffer state.
2424  * @param file A readable stream.
2425  * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
2426  * 
2427  * @return the allocated buffer state.
2428  */
2429     YY_BUFFER_STATE yy_create_buffer  (FILE * file, int  size )
2430 {
2431         YY_BUFFER_STATE b;
2432     
2433         b = (YY_BUFFER_STATE) yyalloc(sizeof( struct yy_buffer_state )  );
2434         if ( ! b )
2435                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2436
2437         b->yy_buf_size = size;
2438
2439         /* yy_ch_buf has to be 2 characters longer than the size given because
2440          * we need to put in 2 end-of-buffer characters.
2441          */
2442         b->yy_ch_buf = (char *) yyalloc(b->yy_buf_size + 2  );
2443         if ( ! b->yy_ch_buf )
2444                 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
2445
2446         b->yy_is_our_buffer = 1;
2447
2448         yy_init_buffer(b,file );
2449
2450         return b;
2451 }
2452
2453 /** Destroy the buffer.
2454  * @param b a buffer created with yy_create_buffer()
2455  * 
2456  */
2457     void yy_delete_buffer (YY_BUFFER_STATE  b )
2458 {
2459     
2460         if ( ! b )
2461                 return;
2462
2463         if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
2464                 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
2465
2466         if ( b->yy_is_our_buffer )
2467                 yyfree((void *) b->yy_ch_buf  );
2468
2469         yyfree((void *) b  );
2470 }
2471
2472 /* Initializes or reinitializes a buffer.
2473  * This function is sometimes called more than once on the same buffer,
2474  * such as during a yyrestart() or at EOF.
2475  */
2476     static void yy_init_buffer  (YY_BUFFER_STATE  b, FILE * file )
2477
2478 {
2479         int oerrno = errno;
2480     
2481         yy_flush_buffer(b );
2482
2483         b->yy_input_file = file;
2484         b->yy_fill_buffer = 1;
2485
2486     /* If b is the current buffer, then yy_init_buffer was _probably_
2487      * called from yyrestart() or through yy_get_next_buffer.
2488      * In that case, we don't want to reset the lineno or column.
2489      */
2490     if (b != YY_CURRENT_BUFFER){
2491         b->yy_bs_lineno = 1;
2492         b->yy_bs_column = 0;
2493     }
2494
2495         b->yy_is_interactive = 0;
2496     
2497         errno = oerrno;
2498 }
2499
2500 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
2501  * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
2502  * 
2503  */
2504     void yy_flush_buffer (YY_BUFFER_STATE  b )
2505 {
2506         if ( ! b )
2507                 return;
2508
2509         b->yy_n_chars = 0;
2510
2511         /* We always need two end-of-buffer characters.  The first causes
2512          * a transition to the end-of-buffer state.  The second causes
2513          * a jam in that state.
2514          */
2515         b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2516         b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2517
2518         b->yy_buf_pos = &b->yy_ch_buf[0];
2519
2520         b->yy_at_bol = 1;
2521         b->yy_buffer_status = YY_BUFFER_NEW;
2522
2523         if ( b == YY_CURRENT_BUFFER )
2524                 yy_load_buffer_state( );
2525 }
2526
2527 /** Pushes the new state onto the stack. The new state becomes
2528  *  the current state. This function will allocate the stack
2529  *  if necessary.
2530  *  @param new_buffer The new state.
2531  *  
2532  */
2533 void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
2534 {
2535         if (new_buffer == NULL)
2536                 return;
2537
2538         yyensure_buffer_stack();
2539
2540         /* This block is copied from yy_switch_to_buffer. */
2541         if ( YY_CURRENT_BUFFER )
2542                 {
2543                 /* Flush out information for old buffer. */
2544                 *(yy_c_buf_p) = (yy_hold_char);
2545                 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
2546                 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2547                 }
2548
2549         /* Only push if top exists. Otherwise, replace top. */
2550         if (YY_CURRENT_BUFFER)
2551                 (yy_buffer_stack_top)++;
2552         YY_CURRENT_BUFFER_LVALUE = new_buffer;
2553
2554         /* copied from yy_switch_to_buffer. */
2555         yy_load_buffer_state( );
2556         (yy_did_buffer_switch_on_eof) = 1;
2557 }
2558
2559 /** Removes and deletes the top of the stack, if present.
2560  *  The next element becomes the new top.
2561  *  
2562  */
2563 void yypop_buffer_state (void)
2564 {
2565         if (!YY_CURRENT_BUFFER)
2566                 return;
2567
2568         yy_delete_buffer(YY_CURRENT_BUFFER );
2569         YY_CURRENT_BUFFER_LVALUE = NULL;
2570         if ((yy_buffer_stack_top) > 0)
2571                 --(yy_buffer_stack_top);
2572
2573         if (YY_CURRENT_BUFFER) {
2574                 yy_load_buffer_state( );
2575                 (yy_did_buffer_switch_on_eof) = 1;
2576         }
2577 }
2578
2579 /* Allocates the stack if it does not exist.
2580  *  Guarantees space for at least one push.
2581  */
2582 static void yyensure_buffer_stack (void)
2583 {
2584         int num_to_alloc;
2585     
2586         if (!(yy_buffer_stack)) {
2587
2588                 /* First allocation is just for 2 elements, since we don't know if this
2589                  * scanner will even need a stack. We use 2 instead of 1 to avoid an
2590                  * immediate realloc on the next call.
2591          */
2592                 num_to_alloc = 1;
2593                 (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
2594                                                                 (num_to_alloc * sizeof(struct yy_buffer_state*)
2595                                                                 );
2596                 
2597                 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
2598                                 
2599                 (yy_buffer_stack_max) = num_to_alloc;
2600                 (yy_buffer_stack_top) = 0;
2601                 return;
2602         }
2603
2604         if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
2605
2606                 /* Increase the buffer to prepare for a possible push. */
2607                 int grow_size = 8 /* arbitrary grow size */;
2608
2609                 num_to_alloc = (yy_buffer_stack_max) + grow_size;
2610                 (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
2611                                                                 ((yy_buffer_stack),
2612                                                                 num_to_alloc * sizeof(struct yy_buffer_state*)