Crossfire Server, Trunk
reader.cpp
Go to the documentation of this file.
1 #line 2 "reader.cpp"
2 
3 #line 4 "reader.cpp"
4 
5 #define YY_INT_ALIGNED short int
6 
7 /* A lexical scanner generated by flex */
8 
9 #define yy_create_buffer rm_create_buffer
10 #define yy_delete_buffer rm_delete_buffer
11 #define yy_scan_buffer rm_scan_buffer
12 #define yy_scan_string rm_scan_string
13 #define yy_scan_bytes rm_scan_bytes
14 #define yy_init_buffer rm_init_buffer
15 #define yy_flush_buffer rm_flush_buffer
16 #define yy_load_buffer_state rm_load_buffer_state
17 #define yy_switch_to_buffer rm_switch_to_buffer
18 #define yypush_buffer_state rmpush_buffer_state
19 #define yypop_buffer_state rmpop_buffer_state
20 #define yyensure_buffer_stack rmensure_buffer_stack
21 #define yy_flex_debug rm_flex_debug
22 #define yyin rmin
23 #define yyleng rmleng
24 #define yylex rmlex
25 #define yylineno rmlineno
26 #define yyout rmout
27 #define yyrestart rmrestart
28 #define yytext rmtext
29 #define yywrap rmwrap
30 #define yyalloc rmalloc
31 #define yyrealloc rmrealloc
32 #define yyfree rmfree
33 
34 #define FLEX_SCANNER
35 #define YY_FLEX_MAJOR_VERSION 2
36 #define YY_FLEX_MINOR_VERSION 6
37 #define YY_FLEX_SUBMINOR_VERSION 4
38 #if YY_FLEX_SUBMINOR_VERSION > 0
39 #define FLEX_BETA
40 #endif
41 
42 #ifdef yy_create_buffer
43 #define rm_create_buffer_ALREADY_DEFINED
44 #else
45 #define yy_create_buffer rm_create_buffer
46 #endif
47 
48 #ifdef yy_delete_buffer
49 #define rm_delete_buffer_ALREADY_DEFINED
50 #else
51 #define yy_delete_buffer rm_delete_buffer
52 #endif
53 
54 #ifdef yy_scan_buffer
55 #define rm_scan_buffer_ALREADY_DEFINED
56 #else
57 #define yy_scan_buffer rm_scan_buffer
58 #endif
59 
60 #ifdef yy_scan_string
61 #define rm_scan_string_ALREADY_DEFINED
62 #else
63 #define yy_scan_string rm_scan_string
64 #endif
65 
66 #ifdef yy_scan_bytes
67 #define rm_scan_bytes_ALREADY_DEFINED
68 #else
69 #define yy_scan_bytes rm_scan_bytes
70 #endif
71 
72 #ifdef yy_init_buffer
73 #define rm_init_buffer_ALREADY_DEFINED
74 #else
75 #define yy_init_buffer rm_init_buffer
76 #endif
77 
78 #ifdef yy_flush_buffer
79 #define rm_flush_buffer_ALREADY_DEFINED
80 #else
81 #define yy_flush_buffer rm_flush_buffer
82 #endif
83 
84 #ifdef yy_load_buffer_state
85 #define rm_load_buffer_state_ALREADY_DEFINED
86 #else
87 #define yy_load_buffer_state rm_load_buffer_state
88 #endif
89 
90 #ifdef yy_switch_to_buffer
91 #define rm_switch_to_buffer_ALREADY_DEFINED
92 #else
93 #define yy_switch_to_buffer rm_switch_to_buffer
94 #endif
95 
96 #ifdef yypush_buffer_state
97 #define rmpush_buffer_state_ALREADY_DEFINED
98 #else
99 #define yypush_buffer_state rmpush_buffer_state
100 #endif
101 
102 #ifdef yypop_buffer_state
103 #define rmpop_buffer_state_ALREADY_DEFINED
104 #else
105 #define yypop_buffer_state rmpop_buffer_state
106 #endif
107 
108 #ifdef yyensure_buffer_stack
109 #define rmensure_buffer_stack_ALREADY_DEFINED
110 #else
111 #define yyensure_buffer_stack rmensure_buffer_stack
112 #endif
113 
114 #ifdef yylex
115 #define rmlex_ALREADY_DEFINED
116 #else
117 #define yylex rmlex
118 #endif
119 
120 #ifdef yyrestart
121 #define rmrestart_ALREADY_DEFINED
122 #else
123 #define yyrestart rmrestart
124 #endif
125 
126 #ifdef yylex_init
127 #define rmlex_init_ALREADY_DEFINED
128 #else
129 #define yylex_init rmlex_init
130 #endif
131 
132 #ifdef yylex_init_extra
133 #define rmlex_init_extra_ALREADY_DEFINED
134 #else
135 #define yylex_init_extra rmlex_init_extra
136 #endif
137 
138 #ifdef yylex_destroy
139 #define rmlex_destroy_ALREADY_DEFINED
140 #else
141 #define yylex_destroy rmlex_destroy
142 #endif
143 
144 #ifdef yyget_debug
145 #define rmget_debug_ALREADY_DEFINED
146 #else
147 #define yyget_debug rmget_debug
148 #endif
149 
150 #ifdef yyset_debug
151 #define rmset_debug_ALREADY_DEFINED
152 #else
153 #define yyset_debug rmset_debug
154 #endif
155 
156 #ifdef yyget_extra
157 #define rmget_extra_ALREADY_DEFINED
158 #else
159 #define yyget_extra rmget_extra
160 #endif
161 
162 #ifdef yyset_extra
163 #define rmset_extra_ALREADY_DEFINED
164 #else
165 #define yyset_extra rmset_extra
166 #endif
167 
168 #ifdef yyget_in
169 #define rmget_in_ALREADY_DEFINED
170 #else
171 #define yyget_in rmget_in
172 #endif
173 
174 #ifdef yyset_in
175 #define rmset_in_ALREADY_DEFINED
176 #else
177 #define yyset_in rmset_in
178 #endif
179 
180 #ifdef yyget_out
181 #define rmget_out_ALREADY_DEFINED
182 #else
183 #define yyget_out rmget_out
184 #endif
185 
186 #ifdef yyset_out
187 #define rmset_out_ALREADY_DEFINED
188 #else
189 #define yyset_out rmset_out
190 #endif
191 
192 #ifdef yyget_leng
193 #define rmget_leng_ALREADY_DEFINED
194 #else
195 #define yyget_leng rmget_leng
196 #endif
197 
198 #ifdef yyget_text
199 #define rmget_text_ALREADY_DEFINED
200 #else
201 #define yyget_text rmget_text
202 #endif
203 
204 #ifdef yyget_lineno
205 #define rmget_lineno_ALREADY_DEFINED
206 #else
207 #define yyget_lineno rmget_lineno
208 #endif
209 
210 #ifdef yyset_lineno
211 #define rmset_lineno_ALREADY_DEFINED
212 #else
213 #define yyset_lineno rmset_lineno
214 #endif
215 
216 #ifdef yywrap
217 #define rmwrap_ALREADY_DEFINED
218 #else
219 #define yywrap rmwrap
220 #endif
221 
222 #ifdef yyalloc
223 #define rmalloc_ALREADY_DEFINED
224 #else
225 #define yyalloc rmalloc
226 #endif
227 
228 #ifdef yyrealloc
229 #define rmrealloc_ALREADY_DEFINED
230 #else
231 #define yyrealloc rmrealloc
232 #endif
233 
234 #ifdef yyfree
235 #define rmfree_ALREADY_DEFINED
236 #else
237 #define yyfree rmfree
238 #endif
239 
240 #ifdef yytext
241 #define rmtext_ALREADY_DEFINED
242 #else
243 #define yytext rmtext
244 #endif
245 
246 #ifdef yyleng
247 #define rmleng_ALREADY_DEFINED
248 #else
249 #define yyleng rmleng
250 #endif
251 
252 #ifdef yyin
253 #define rmin_ALREADY_DEFINED
254 #else
255 #define yyin rmin
256 #endif
257 
258 #ifdef yyout
259 #define rmout_ALREADY_DEFINED
260 #else
261 #define yyout rmout
262 #endif
263 
264 #ifdef yy_flex_debug
265 #define rm_flex_debug_ALREADY_DEFINED
266 #else
267 #define yy_flex_debug rm_flex_debug
268 #endif
269 
270 #ifdef yylineno
271 #define rmlineno_ALREADY_DEFINED
272 #else
273 #define yylineno rmlineno
274 #endif
275 
276 /* First, we deal with platform-specific or compiler-specific issues. */
277 
278 /* begin standard C headers. */
279 #include <stdio.h>
280 #include <string.h>
281 #include <errno.h>
282 #include <stdlib.h>
283 
284 /* end standard C headers. */
285 
286 /* flex integer type definitions */
287 
288 #ifndef FLEXINT_H
289 #define FLEXINT_H
290 
291 /* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
292 
293 #if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
294 
295 /* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
296  * if you want the limit (max/min) macros for int types.
297  */
298 #ifndef __STDC_LIMIT_MACROS
299 #define __STDC_LIMIT_MACROS 1
300 #endif
301 
302 #include <inttypes.h>
303 typedef int8_t flex_int8_t;
304 typedef uint8_t flex_uint8_t;
305 typedef int16_t flex_int16_t;
306 typedef uint16_t flex_uint16_t;
307 typedef int32_t flex_int32_t;
308 typedef uint32_t flex_uint32_t;
309 #else
310 typedef signed char flex_int8_t;
311 typedef short int flex_int16_t;
312 typedef int flex_int32_t;
313 typedef unsigned char flex_uint8_t;
314 typedef unsigned short int flex_uint16_t;
315 typedef unsigned int flex_uint32_t;
316 
317 /* Limits of integral types. */
318 #ifndef INT8_MIN
319 #define INT8_MIN (-128)
320 #endif
321 #ifndef INT16_MIN
322 #define INT16_MIN (-32767-1)
323 #endif
324 #ifndef INT32_MIN
325 #define INT32_MIN (-2147483647-1)
326 #endif
327 #ifndef INT8_MAX
328 #define INT8_MAX (127)
329 #endif
330 #ifndef INT16_MAX
331 #define INT16_MAX (32767)
332 #endif
333 #ifndef INT32_MAX
334 #define INT32_MAX (2147483647)
335 #endif
336 #ifndef UINT8_MAX
337 #define UINT8_MAX (255U)
338 #endif
339 #ifndef UINT16_MAX
340 #define UINT16_MAX (65535U)
341 #endif
342 #ifndef UINT32_MAX
343 #define UINT32_MAX (4294967295U)
344 #endif
345 
346 #ifndef SIZE_MAX
347 #define SIZE_MAX (~(size_t)0)
348 #endif
349 
350 #endif /* ! C99 */
351 
352 #endif /* ! FLEXINT_H */
353 
354 /* begin standard C++ headers. */
355 
356 /* TODO: this is always defined, so inline it */
357 #define yyconst const
358 
359 #if defined(__GNUC__) && __GNUC__ >= 3
360 #define yynoreturn __attribute__((__noreturn__))
361 #else
362 #define yynoreturn
363 #endif
364 
365 /* Returned upon end-of-file. */
366 #define YY_NULL 0
367 
368 /* Promotes a possibly negative, possibly signed char to an
369  * integer in range [0..255] for use as an array index.
370  */
371 #define YY_SC_TO_UI(c) ((YY_CHAR) (c))
372 
373 /* Enter a start condition. This macro really ought to take a parameter,
374  * but we do it the disgusting crufty way forced on us by the ()-less
375  * definition of BEGIN.
376  */
377 #define BEGIN (yy_start) = 1 + 2 *
378 /* Translate the current start state into a value that can be later handed
379  * to BEGIN to return to the state. The YYSTATE alias is for lex
380  * compatibility.
381  */
382 #define YY_START (((yy_start) - 1) / 2)
383 #define YYSTATE YY_START
384 /* Action number for EOF rule of a given start state. */
385 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
386 /* Special action meaning "start processing a new file". */
387 #define YY_NEW_FILE yyrestart( yyin )
388 #define YY_END_OF_BUFFER_CHAR 0
389 
390 /* Size of default input buffer. */
391 #ifndef YY_BUF_SIZE
392 #ifdef __ia64__
393 /* On IA-64, the buffer size is 16k, not 8k.
394  * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
395  * Ditto for the __ia64__ case accordingly.
396  */
397 #define YY_BUF_SIZE 32768
398 #else
399 #define YY_BUF_SIZE 16384
400 #endif /* __ia64__ */
401 #endif
402 
403 /* The state buf must be large enough to hold one state per character in the main buffer.
404  */
405 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
406 
407 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
408 #define YY_TYPEDEF_YY_BUFFER_STATE
410 #endif
411 
412 #ifndef YY_TYPEDEF_YY_SIZE_T
413 #define YY_TYPEDEF_YY_SIZE_T
414 typedef size_t yy_size_t;
415 #endif
416 
417 extern int yyleng;
418 
419 extern FILE *yyin, *yyout;
420 
421 #define EOB_ACT_CONTINUE_SCAN 0
422 #define EOB_ACT_END_OF_FILE 1
423 #define EOB_ACT_LAST_MATCH 2
424 
425  #define YY_LESS_LINENO(n)
426  #define YY_LINENO_REWIND_TO(ptr)
427 
428 /* Return all but the first "n" matched characters back to the input stream. */
429 #define yyless(n) \
430  do \
431  { \
432  /* Undo effects of setting up yytext. */ \
433  int yyless_macro_arg = (n); \
434  YY_LESS_LINENO(yyless_macro_arg);\
435  *yy_cp = (yy_hold_char); \
436  YY_RESTORE_YY_MORE_OFFSET \
437  (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
438  YY_DO_BEFORE_ACTION; /* set up yytext again */ \
439  } \
440  while ( 0 )
441 #define unput(c) yyunput( c, (yytext_ptr) )
442 
443 #ifndef YY_STRUCT_YY_BUFFER_STATE
444 #define YY_STRUCT_YY_BUFFER_STATE
445 struct yy_buffer_state
446  {
447  FILE *yy_input_file;
448 
449  char *yy_ch_buf; /* input buffer */
450  char *yy_buf_pos; /* current position in input buffer */
451 
452  /* Size of input buffer in bytes, not including room for EOB
453  * characters.
454  */
455  int yy_buf_size;
456 
457  /* Number of characters read into yy_ch_buf, not including EOB
458  * characters.
459  */
460  int yy_n_chars;
461 
462  /* Whether we "own" the buffer - i.e., we know we created it,
463  * and can realloc() it to grow it, and should free() it to
464  * delete it.
465  */
466  int yy_is_our_buffer;
467 
468  /* Whether this is an "interactive" input source; if so, and
469  * if we're using stdio for input, then we want to use getc()
470  * instead of fread(), to make sure we stop fetching input after
471  * each newline.
472  */
473  int yy_is_interactive;
474 
475  /* Whether we're considered to be at the beginning of a line.
476  * If so, '^' rules will be active on the next match, otherwise
477  * not.
478  */
479  int yy_at_bol;
480 
481  int yy_bs_lineno;
482  int yy_bs_column;
484  /* Whether to try to fill the input buffer when we reach the
485  * end of it.
486  */
487  int yy_fill_buffer;
488 
489  int yy_buffer_status;
490 
491 #define YY_BUFFER_NEW 0
492 #define YY_BUFFER_NORMAL 1
493  /* When an EOF's been seen but there's still some text to process
494  * then we mark the buffer as YY_EOF_PENDING, to indicate that we
495  * shouldn't try reading from the input source any more. We might
496  * still have a bunch of tokens to match, though, because of
497  * possible backing-up.
498  *
499  * When we actually see the EOF, we change the status to "new"
500  * (via yyrestart()), so that the user can continue scanning by
501  * just pointing yyin at a new input file.
502  */
503 #define YY_BUFFER_EOF_PENDING 2
504 
505  };
506 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
507 
508 /* Stack of input buffers. */
509 static size_t yy_buffer_stack_top = 0;
510 static size_t yy_buffer_stack_max = 0;
513 /* We provide macros for accessing buffer states in case in the
514  * future we want to put the buffer states in a more general
515  * "scanner state".
516  *
517  * Returns the top of the stack, or NULL.
518  */
519 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
520  ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
521  : NULL)
522 /* Same as previous macro, but useful when we know that the buffer stack is not
523  * NULL or when we need an lvalue. For internal use only.
524  */
525 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
526 
527 /* yy_hold_char holds the character lost when yytext is formed. */
528 static char yy_hold_char;
529 static int yy_n_chars; /* number of characters read into yy_ch_buf */
530 int yyleng;
531 
532 /* Points to current character in buffer. */
533 static char *yy_c_buf_p = NULL;
534 static int yy_init = 0; /* whether we need to initialize */
535 static int yy_start = 0; /* start state number */
536 
537 /* Flag which is used to allow yywrap()'s to do buffer switches
538  * instead of setting up a fresh yyin. A bit of a hack ...
539  */
541 
542 void yyrestart ( FILE *input_file );
543 void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer );
544 YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size );
547 void yypush_buffer_state ( YY_BUFFER_STATE new_buffer );
548 void yypop_buffer_state ( void );
549 
550 static void yyensure_buffer_stack ( void );
551 static void yy_load_buffer_state ( void );
552 static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file );
553 #define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER )
554 
555 YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size );
556 YY_BUFFER_STATE yy_scan_string ( const char *yy_str );
557 YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len );
558 
559 void *yyalloc ( yy_size_t );
560 void *yyrealloc ( void *, yy_size_t );
561 void yyfree ( void * );
562 
563 #define yy_new_buffer yy_create_buffer
564 #define yy_set_interactive(is_interactive) \
565  { \
566  if ( ! YY_CURRENT_BUFFER ){ \
567  yyensure_buffer_stack (); \
568  YY_CURRENT_BUFFER_LVALUE = \
569  yy_create_buffer( yyin, YY_BUF_SIZE ); \
570  } \
571  YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
572  }
573 #define yy_set_bol(at_bol) \
574  { \
575  if ( ! YY_CURRENT_BUFFER ){\
576  yyensure_buffer_stack (); \
577  YY_CURRENT_BUFFER_LVALUE = \
578  yy_create_buffer( yyin, YY_BUF_SIZE ); \
579  } \
580  YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
581  }
582 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
583 
584 /* Begin user sect3 */
585 
586 #define rmwrap() (/*CONSTCOND*/1)
587 #define YY_SKIP_YYWRAP
589 
590 FILE *yyin = NULL, *yyout = NULL;
591 
592 typedef int yy_state_type;
593 
594 extern int yylineno;
595 int yylineno = 1;
596 
597 extern char *yytext;
598 #ifdef yytext_ptr
599 #undef yytext_ptr
600 #endif
601 #define yytext_ptr yytext
602 
603 static yy_state_type yy_get_previous_state ( void );
604 static yy_state_type yy_try_NUL_trans ( yy_state_type current_state );
605 static int yy_get_next_buffer ( void );
606 static void yynoreturn yy_fatal_error ( const char* msg );
607 
608 /* Done after the current pattern has been matched and before the
609  * corresponding action - sets up yytext.
610  */
611 #define YY_DO_BEFORE_ACTION \
612  (yytext_ptr) = yy_bp; \
613  yyleng = (int) (yy_cp - yy_bp); \
614  (yy_hold_char) = *yy_cp; \
615  *yy_cp = '\0'; \
616  (yy_c_buf_p) = yy_cp;
617 #define YY_NUM_RULES 37
618 #define YY_END_OF_BUFFER 38
619 /* This struct is not used in this scanner,
620  but its presence is necessary. */
621 struct yy_trans_info
622  {
625  };
626 static const flex_int16_t yy_accept[390] =
627  { 0,
628  36, 36, 0, 0, 38, 36, 34, 36, 36, 36,
629  36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
630  36, 36, 37, 37, 36, 36, 35, 36, 34, 36,
631  36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
632  36, 36, 36, 36, 36, 36, 36, 36, 36, 0,
633  34, 36, 36, 36, 36, 36, 36, 36, 36, 36,
634  36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
635  36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
636  36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
637  36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
638 
639  36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
640  36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
641  36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
642  36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
643  36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
644  36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
645  36, 36, 36, 36, 36, 9, 9, 10, 10, 36,
646  36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
647  36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
648  36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
649 
650  36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
651  36, 36, 36, 36, 36, 36, 36, 36, 33, 33,
652  36, 36, 36, 36, 36, 36, 32, 32, 36, 36,
653  36, 36, 36, 36, 36, 36, 36, 11, 11, 36,
654  36, 36, 36, 36, 36, 36, 36, 36, 25, 25,
655  26, 26, 36, 14, 14, 36, 36, 36, 36, 36,
656  36, 36, 36, 6, 6, 36, 36, 36, 36, 18,
657  18, 36, 22, 22, 36, 36, 36, 36, 36, 36,
658  36, 36, 36, 36, 1, 1, 8, 8, 36, 7,
659  7, 15, 15, 36, 36, 36, 36, 36, 36, 2,
660 
661  2, 36, 36, 36, 36, 36, 27, 27, 36, 36,
662  36, 36, 36, 36, 36, 36, 36, 36, 36, 5,
663  5, 36, 36, 24, 24, 28, 28, 36, 36, 17,
664  17, 36, 36, 36, 20, 20, 36, 36, 36, 36,
665  3, 3, 36, 36, 36, 36, 21, 21, 19, 19,
666  36, 36, 36, 36, 36, 36, 4, 4, 36, 36,
667  36, 12, 12, 13, 13, 36, 36, 36, 36, 36,
668  31, 31, 29, 29, 36, 36, 36, 36, 30, 30,
669  36, 36, 36, 16, 16, 36, 23, 23, 0
670  } ;
671 
672 static const YY_CHAR yy_ec[256] =
673  { 0,
674  1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
675  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
676  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
677  1, 2, 1, 1, 4, 5, 1, 1, 1, 1,
678  1, 1, 1, 1, 1, 1, 1, 1, 6, 7,
679  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
680  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
681  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
682  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
683  1, 1, 1, 8, 9, 1, 10, 1, 11, 12,
684 
685  13, 14, 15, 16, 17, 1, 18, 19, 20, 21,
686  22, 23, 1, 24, 25, 26, 27, 28, 29, 30,
687  31, 32, 1, 1, 1, 1, 1, 1, 1, 1,
688  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
689  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
690  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
691  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
692  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
693  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
694  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
695 
696  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
697  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
698  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
699  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
700  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
701  1, 1, 1, 1, 1
702  } ;
703 
704 static const YY_CHAR yy_meta[33] =
705  { 0,
706  1, 1, 2, 1, 1, 1, 1, 1, 1, 1,
707  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
708  1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
709  1, 1
710  } ;
711 
712 static const flex_int16_t yy_base[427] =
713  { 0,
714  0, 6, 3, 4, 431, 0, 432, 427, 0, 413,
715  28, 398, 4, 417, 0, 15, 416, 394, 400, 413,
716  397, 396, 432, 11, 0, 417, 432, 38, 0, 406,
717  394, 406, 402, 393, 393, 29, 392, 390, 380, 389,
718  390, 391, 381, 385, 385, 391, 384, 385, 384, 42,
719  432, 375, 381, 376, 383, 372, 380, 368, 383, 382,
720  369, 368, 364, 362, 36, 375, 374, 365, 374, 364,
721  350, 349, 354, 358, 354, 360, 351, 362, 39, 353,
722  354, 348, 344, 344, 352, 347, 350, 344, 343, 351,
723  338, 337, 348, 347, 334, 345, 31, 346, 330, 333,
724 
725  332, 327, 340, 342, 325, 323, 335, 324, 320, 324,
726  322, 323, 316, 314, 314, 337, 336, 311, 311, 312,
727  308, 306, 301, 310, 309, 298, 321, 41, 301, 35,
728  302, 306, 314, 314, 298, 312, 296, 295, 287, 315,
729  314, 284, 289, 287, 281, 292, 291, 300, 299, 288,
730  276, 275, 294, 272, 279, 275, 275, 286, 272, 38,
731  295, 271, 264, 281, 274, 0, 290, 0, 289, 271,
732  287, 271, 268, 260, 272, 51, 270, 270, 280, 264,
733  257, 260, 252, 246, 250, 266, 257, 263, 270, 269,
734  268, 256, 266, 37, 254, 253, 263, 242, 250, 231,
735 
736  259, 247, 246, 248, 240, 254, 253, 228, 251, 239,
737  234, 231, 218, 234, 225, 223, 243, 242, 0, 241,
738  229, 239, 217, 213, 236, 235, 0, 234, 214, 232,
739  64, 231, 209, 203, 210, 208, 226, 0, 225, 217,
740  223, 222, 201, 209, 202, 201, 198, 216, 0, 215,
741  0, 214, 203, 0, 212, 187, 181, 209, 208, 184,
742  206, 205, 189, 0, 203, 178, 190, 189, 191, 0,
743  198, 189, 0, 196, 195, 175, 193, 181, 171, 190,
744  189, 188, 172, 169, 0, 185, 0, 184, 183, 0,
745  182, 0, 181, 161, 165, 161, 177, 159, 153, 0,
746 
747  174, 150, 172, 171, 150, 169, 0, 168, 167, 146,
748  154, 164, 154, 162, 161, 160, 152, 149, 27, 0,
749  157, 156, 133, 0, 154, 0, 153, 133, 151, 0,
750  150, 127, 148, 147, 0, 146, 127, 130, 143, 142,
751  0, 141, 117, 116, 138, 126, 0, 136, 0, 135,
752  126, 122, 132, 131, 130, 129, 0, 128, 119, 105,
753  101, 0, 124, 0, 123, 122, 121, 97, 119, 89,
754  0, 117, 0, 116, 104, 114, 92, 112, 0, 111,
755  99, 109, 108, 0, 107, 106, 0, 105, 432, 73,
756  75, 105, 77, 104, 103, 102, 101, 100, 99, 98,
757 
758  97, 96, 95, 94, 93, 92, 91, 90, 89, 88,
759  87, 86, 85, 84, 83, 82, 81, 80, 79, 70,
760  66, 64, 28, 23, 14, 0
761  } ;
762 
763 static const flex_int16_t yy_def[427] =
764  { 0,
765  390, 390, 391, 391, 389, 392, 389, 393, 392, 392,
766  392, 392, 392, 392, 392, 392, 392, 392, 392, 392,
767  392, 392, 389, 389, 392, 393, 389, 392, 392, 392,
768  392, 392, 392, 392, 392, 392, 392, 392, 392, 392,
769  392, 392, 392, 392, 392, 392, 392, 392, 392, 389,
770  389, 392, 392, 392, 392, 392, 392, 392, 392, 392,
771  392, 392, 392, 392, 392, 392, 392, 392, 392, 392,
772  392, 392, 392, 392, 392, 392, 392, 392, 392, 392,
773  392, 392, 392, 392, 392, 392, 392, 392, 392, 392,
774  392, 392, 392, 392, 392, 392, 392, 392, 392, 392,
775 
776  392, 392, 392, 392, 392, 392, 392, 392, 392, 392,
777  392, 392, 392, 392, 392, 392, 392, 392, 392, 392,
778  392, 392, 392, 392, 392, 392, 392, 392, 392, 392,
779  392, 392, 392, 392, 392, 392, 392, 392, 392, 394,
780  395, 392, 392, 392, 392, 392, 392, 392, 392, 392,
781  392, 392, 392, 392, 392, 392, 392, 392, 392, 392,
782  392, 392, 392, 392, 392, 394, 394, 395, 395, 392,
783  392, 392, 392, 392, 392, 392, 392, 392, 392, 392,
784  392, 392, 392, 392, 392, 392, 392, 392, 392, 392,
785  396, 392, 392, 392, 392, 392, 397, 392, 392, 392,
786 
787  392, 392, 392, 392, 392, 392, 398, 392, 392, 392,
788  392, 392, 392, 392, 392, 392, 399, 400, 396, 396,
789  392, 401, 392, 392, 392, 392, 397, 397, 392, 392,
790  392, 402, 392, 392, 392, 392, 403, 398, 398, 392,
791  404, 392, 392, 392, 392, 392, 392, 392, 399, 399,
792  400, 400, 392, 401, 401, 392, 392, 405, 406, 392,
793  407, 408, 392, 402, 402, 392, 392, 392, 392, 403,
794  403, 392, 404, 404, 409, 392, 392, 392, 392, 392,
795  410, 392, 392, 392, 405, 405, 406, 406, 392, 407,
796  407, 408, 408, 392, 392, 392, 392, 392, 392, 409,
797 
798  409, 392, 411, 392, 392, 412, 410, 410, 413, 392,
799  392, 414, 392, 392, 392, 415, 392, 392, 392, 411,
800  411, 416, 392, 412, 412, 413, 413, 392, 392, 414,
801  414, 392, 417, 418, 415, 415, 392, 392, 392, 392,
802  416, 416, 392, 392, 419, 392, 417, 417, 418, 418,
803  392, 392, 420, 421, 392, 392, 419, 419, 392, 392,
804  392, 420, 420, 421, 421, 422, 423, 392, 392, 392,
805  422, 422, 423, 423, 392, 424, 392, 392, 424, 424,
806  392, 425, 392, 425, 425, 426, 426, 426, 0, 389,
807  389, 389, 389, 389, 389, 389, 389, 389, 389, 389,
808 
809  389, 389, 389, 389, 389, 389, 389, 389, 389, 389,
810  389, 389, 389, 389, 389, 389, 389, 389, 389, 389,
811  389, 389, 389, 389, 389, 389
812  } ;
813 
814 static const flex_int16_t yy_nxt[465] =
815  { 0,
816  387, 28, 7, 8, 29, 7, 7, 9, 7, 8,
817  24, 24, 50, 9, 384, 51, 10, 11, 12, 13,
818  37, 40, 38, 379, 14, 15, 41, 16, 373, 17,
819  18, 19, 339, 340, 20, 21, 22, 31, 42, 28,
820  32, 43, 29, 50, 33, 58, 51, 101, 86, 34,
821  87, 59, 120, 152, 35, 121, 155, 188, 223, 156,
822  153, 224, 202, 102, 371, 262, 364, 189, 190, 203,
823  362, 204, 263, 6, 6, 23, 23, 26, 26, 357,
824  349, 347, 341, 335, 330, 326, 324, 320, 307, 300,
825  292, 290, 287, 285, 273, 270, 264, 254, 251, 249,
826 
827  238, 227, 219, 168, 166, 25, 388, 388, 385, 386,
828  385, 383, 380, 382, 381, 380, 378, 374, 372, 377,
829  376, 375, 374, 372, 365, 363, 370, 369, 368, 358,
830  367, 366, 365, 363, 361, 360, 350, 348, 359, 358,
831  356, 355, 342, 354, 353, 352, 351, 336, 350, 348,
832  346, 331, 345, 344, 327, 325, 343, 342, 321, 338,
833  337, 336, 334, 333, 332, 331, 329, 328, 327, 308,
834  325, 323, 322, 321, 319, 301, 318, 317, 316, 315,
835  314, 313, 293, 291, 312, 288, 286, 311, 310, 309,
836  308, 306, 305, 304, 303, 302, 301, 274, 299, 271,
837 
838  298, 297, 296, 295, 265, 294, 293, 291, 289, 288,
839  286, 284, 283, 255, 282, 252, 250, 281, 280, 279,
840  278, 277, 276, 275, 274, 272, 239, 271, 269, 268,
841  267, 266, 265, 261, 260, 228, 259, 258, 257, 256,
842  255, 253, 220, 252, 250, 248, 247, 246, 245, 244,
843  243, 242, 241, 240, 239, 237, 236, 235, 234, 233,
844  232, 231, 230, 229, 228, 226, 225, 222, 221, 220,
845  218, 217, 216, 215, 214, 213, 212, 211, 210, 209,
846  208, 207, 206, 205, 201, 200, 199, 198, 197, 196,
847  169, 167, 195, 194, 193, 192, 191, 187, 186, 185,
848 
849  184, 183, 182, 181, 180, 179, 178, 177, 176, 175,
850  174, 173, 172, 171, 170, 169, 167, 165, 164, 163,
851  162, 161, 160, 159, 158, 157, 154, 151, 150, 149,
852  148, 147, 146, 145, 144, 143, 142, 141, 140, 139,
853  138, 137, 136, 135, 134, 133, 132, 131, 130, 129,
854  128, 127, 126, 125, 124, 123, 122, 119, 118, 117,
855  116, 115, 114, 113, 112, 111, 110, 109, 108, 107,
856  106, 105, 104, 103, 100, 99, 98, 97, 96, 95,
857  94, 93, 92, 91, 90, 89, 88, 85, 84, 83,
858  82, 81, 80, 79, 78, 77, 76, 75, 74, 73,
859 
860  72, 71, 70, 69, 68, 67, 66, 65, 64, 63,
861  62, 61, 60, 57, 56, 55, 54, 53, 52, 27,
862  49, 48, 47, 46, 45, 44, 39, 36, 30, 27,
863  389, 5, 389, 389, 389, 389, 389, 389, 389, 389,
864  389, 389, 389, 389, 389, 389, 389, 389, 389, 389,
865  389, 389, 389, 389, 389, 389, 389, 389, 389, 389,
866  389, 389, 389, 389
867  } ;
868 
869 static const flex_int16_t yy_chk[465] =
870  { 0,
871  426, 9, 1, 1, 9, 3, 4, 1, 2, 2,
872  3, 4, 24, 2, 425, 24, 2, 2, 2, 2,
873  13, 15, 13, 424, 2, 2, 15, 2, 423, 2,
874  2, 2, 319, 319, 2, 2, 2, 11, 16, 28,
875  11, 16, 28, 50, 11, 36, 50, 79, 65, 11,
876  65, 36, 97, 128, 11, 97, 130, 160, 194, 130,
877  128, 194, 176, 79, 422, 231, 421, 160, 160, 176,
878  420, 176, 231, 390, 390, 391, 391, 393, 393, 419,
879  418, 417, 416, 415, 414, 413, 412, 411, 410, 409,
880  408, 407, 406, 405, 404, 403, 402, 401, 400, 399,
881 
882  398, 397, 396, 395, 394, 392, 388, 386, 385, 383,
883  382, 381, 380, 378, 377, 376, 375, 374, 372, 370,
884  369, 368, 367, 366, 365, 363, 361, 360, 359, 358,
885  356, 355, 354, 353, 352, 351, 350, 348, 346, 345,
886  344, 343, 342, 340, 339, 338, 337, 336, 334, 333,
887  332, 331, 329, 328, 327, 325, 323, 322, 321, 318,
888  317, 316, 315, 314, 313, 312, 311, 310, 309, 308,
889  306, 305, 304, 303, 302, 301, 299, 298, 297, 296,
890  295, 294, 293, 291, 289, 288, 286, 284, 283, 282,
891  281, 280, 279, 278, 277, 276, 275, 274, 272, 271,
892 
893  269, 268, 267, 266, 265, 263, 262, 261, 260, 259,
894  258, 257, 256, 255, 253, 252, 250, 248, 247, 246,
895  245, 244, 243, 242, 241, 240, 239, 237, 236, 235,
896  234, 233, 232, 230, 229, 228, 226, 225, 224, 223,
897  222, 221, 220, 218, 217, 216, 215, 214, 213, 212,
898  211, 210, 209, 208, 207, 206, 205, 204, 203, 202,
899  201, 200, 199, 198, 197, 196, 195, 193, 192, 191,
900  190, 189, 188, 187, 186, 185, 184, 183, 182, 181,
901  180, 179, 178, 177, 175, 174, 173, 172, 171, 170,
902  169, 167, 165, 164, 163, 162, 161, 159, 158, 157,
903 
904  156, 155, 154, 153, 152, 151, 150, 149, 148, 147,
905  146, 145, 144, 143, 142, 141, 140, 139, 138, 137,
906  136, 135, 134, 133, 132, 131, 129, 127, 126, 125,
907  124, 123, 122, 121, 120, 119, 118, 117, 116, 115,
908  114, 113, 112, 111, 110, 109, 108, 107, 106, 105,
909  104, 103, 102, 101, 100, 99, 98, 96, 95, 94,
910  93, 92, 91, 90, 89, 88, 87, 86, 85, 84,
911  83, 82, 81, 80, 78, 77, 76, 75, 74, 73,
912  72, 71, 70, 69, 68, 67, 66, 64, 63, 62,
913  61, 60, 59, 58, 57, 56, 55, 54, 53, 52,
914 
915  49, 48, 47, 46, 45, 44, 43, 42, 41, 40,
916  39, 38, 37, 35, 34, 33, 32, 31, 30, 26,
917  22, 21, 20, 19, 18, 17, 14, 12, 10, 8,
918  5, 389, 389, 389, 389, 389, 389, 389, 389, 389,
919  389, 389, 389, 389, 389, 389, 389, 389, 389, 389,
920  389, 389, 389, 389, 389, 389, 389, 389, 389, 389,
921  389, 389, 389, 389
922  } ;
923 
926 
927 extern int yy_flex_debug;
929 
930 /* The intent behind this definition is that it'll catch
931  * any uses of REJECT which flex missed.
932  */
933 #define REJECT reject_used_but_not_detected
934 #define yymore() yymore_used_but_not_detected
935 #define YY_MORE_ADJ 0
936 #define YY_RESTORE_YY_MORE_OFFSET
937 char *yytext;
938 #line 1 "../random_maps/reader.l"
939 #line 2 "../random_maps/reader.l"
940 /*
941  * static char *reader_l =
942  * "$Id$";
943  */
944 
945 /*
946  CrossFire, A Multiplayer game for X-windows
947 
948  Copyright (C) 1994 Mark Wedel
949  Copyright (C) 1992 Frank Tore Johansen
950 
951  This program is free software; you can redistribute it and/or modify
952  it under the terms of the GNU General Public License as published by
953  the Free Software Foundation; either version 2 of the License, or
954  (at your option) any later version.
955 
956  This program is distributed in the hope that it will be useful,
957  but WITHOUT ANY WARRANTY; without even the implied warranty of
958  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
959  GNU General Public License for more details.
960 
961  You should have received a copy of the GNU General Public License
962  along with this program; if not, write to the Free Software
963  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
964 
965  The author can be reached via e-mail to mark@pyramid.com
966 */
967 
968 #include <global.h>
969 #include <loader.h>
970 #include <newserver.h>
971 #include <random_map.h>
972 
973 #define YY_DECL int rmap_lex_read(RMParms *RP)
974 
975 static char *rmap_yval(void);
976 static int rmap_lex_read(RMParms *RP);
977 
978 static int rmap_lex_error;
979 
980 #define IVAL atoi(rmap_yval())
981 #define FVAL atof(rmap_yval())
982 
989 static int yyerror(const char *s)
990 {
991  LOG(llevError, "%s: %s\n", s, yytext);
992  return -1;
993 }
994 
995 #line 996 "reader.cpp"
996 
997 /* Don't have to link with -lfl with this */
998 /* those functions are unused, not sure of compatibility with Flex versions. */
999 #define YY_NO_INPUT 1
1000 #line 1001 "reader.cpp"
1001 
1002 #define INITIAL 0
1003 #define MESSAGE 1
1004 
1005 #ifndef YY_NO_UNISTD_H
1006 /* Special case for "unistd.h", since it is non-ANSI. We include it way
1007  * down here because we want the user's section 1 to have been scanned first.
1008  * The user has a chance to override it with an option.
1009  */
1010 #include <unistd.h>
1011 #endif
1012 
1013 #ifndef YY_EXTRA_TYPE
1014 #define YY_EXTRA_TYPE void *
1015 #endif
1016 
1017 static int yy_init_globals ( void );
1018 
1019 /* Accessor methods to globals.
1020  These are made visible to non-reentrant scanners for convenience. */
1021 
1022 int yylex_destroy ( void );
1023 
1024 int yyget_debug ( void );
1025 
1026 void yyset_debug ( int debug_flag );
1027 
1028 YY_EXTRA_TYPE yyget_extra ( void );
1029 
1030 void yyset_extra ( YY_EXTRA_TYPE user_defined );
1031 
1032 FILE *yyget_in ( void );
1033 
1034 void yyset_in ( FILE * _in_str );
1035 
1036 FILE *yyget_out ( void );
1037 
1038 void yyset_out ( FILE * _out_str );
1039 
1040  int yyget_leng ( void );
1041 
1042 char *yyget_text ( void );
1043 
1044 int yyget_lineno ( void );
1045 
1046 void yyset_lineno ( int _line_number );
1047 
1048 /* Macros after this point can all be overridden by user definitions in
1049  * section 1.
1050  */
1051 
1052 #ifndef YY_SKIP_YYWRAP
1053 #ifdef __cplusplus
1054 extern "C" int yywrap ( void );
1055 #else
1056 extern int yywrap ( void );
1057 #endif
1058 #endif
1059 
1060 #ifndef YY_NO_UNPUT
1061 
1062 #endif
1063 
1064 #ifndef yytext_ptr
1065 static void yy_flex_strncpy ( char *, const char *, int );
1066 #endif
1067 
1068 #ifdef YY_NEED_STRLEN
1069 static int yy_flex_strlen ( const char * );
1070 #endif
1071 
1072 #ifndef YY_NO_INPUT
1073 #ifdef __cplusplus
1074 static int yyinput ( void );
1075 #else
1076 static int input ( void );
1077 #endif
1078 
1079 #endif
1080 
1081 /* Amount of stuff to slurp up with each read. */
1082 #ifndef YY_READ_BUF_SIZE
1083 #ifdef __ia64__
1084 /* On IA-64, the buffer size is 16k, not 8k */
1085 #define YY_READ_BUF_SIZE 16384
1086 #else
1087 #define YY_READ_BUF_SIZE 8192
1088 #endif /* __ia64__ */
1089 #endif
1090 
1091 /* Copy whatever the last rule matched to the standard output. */
1092 #ifndef ECHO
1093 /* This used to be an fputs(), but since the string might contain NUL's,
1094  * we now use fwrite().
1095  */
1096 #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
1097 #endif
1098 
1099 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
1100  * is returned in "result".
1101  */
1102 #ifndef YY_INPUT
1103 #define YY_INPUT(buf,result,max_size) \
1104  if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
1105  { \
1106  int c = '*'; \
1107  int n; \
1108  for ( n = 0; n < max_size && \
1109  (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
1110  buf[n] = (char) c; \
1111  if ( c == '\n' ) \
1112  buf[n++] = (char) c; \
1113  if ( c == EOF && ferror( yyin ) ) \
1114  YY_FATAL_ERROR( "input in flex scanner failed" ); \
1115  result = n; \
1116  } \
1117  else \
1118  { \
1119  errno=0; \
1120  while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
1121  { \
1122  if( errno != EINTR) \
1123  { \
1124  YY_FATAL_ERROR( "input in flex scanner failed" ); \
1125  break; \
1126  } \
1127  errno=0; \
1128  clearerr(yyin); \
1129  } \
1130  }\
1131 \
1132 
1133 #endif
1134 
1135 /* No semi-colon after return; correct usage is to write "yyterminate();" -
1136  * we don't want an extra ';' after the "return" because that will cause
1137  * some compilers to complain about unreachable statements.
1138  */
1139 #ifndef yyterminate
1140 #define yyterminate() return YY_NULL
1141 #endif
1142 
1143 /* Number of entries by which start-condition stack grows. */
1144 #ifndef YY_START_STACK_INCR
1145 #define YY_START_STACK_INCR 25
1146 #endif
1147 
1148 /* Report a fatal error. */
1149 #ifndef YY_FATAL_ERROR
1150 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
1151 #endif
1152 
1153 /* end tables serialization structures and prototypes */
1154 
1155 /* Default declaration of generated scanner - a define so the user can
1156  * easily add parameters.
1157  */
1158 #ifndef YY_DECL
1159 #define YY_DECL_IS_OURS 1
1160 
1161 extern int yylex (void);
1162 
1163 #define YY_DECL int yylex (void)
1164 #endif /* !YY_DECL */
1165 
1166 /* Code executed at the beginning of each rule, after yytext and yyleng
1167  * have been set up.
1168  */
1169 #ifndef YY_USER_ACTION
1170 #define YY_USER_ACTION
1171 #endif
1172 
1173 /* Code executed at the end of each rule. */
1174 #ifndef YY_BREAK
1175 #define YY_BREAK /*LINTED*/break;
1176 #endif
1177 
1178 #define YY_RULE_SETUP \
1179  if ( yyleng > 0 ) \
1180  YY_CURRENT_BUFFER_LVALUE->yy_at_bol = \
1181  (yytext[yyleng - 1] == '\n'); \
1182  YY_USER_ACTION
1183 
1186 YY_DECL
1188  yy_state_type yy_current_state;
1189  char *yy_cp, *yy_bp;
1190  int yy_act;
1191 
1192  if ( !(yy_init) )
1193  {
1194  (yy_init) = 1;
1195 
1196 #ifdef YY_USER_INIT
1197  YY_USER_INIT;
1198 #endif
1199 
1200  if ( ! (yy_start) )
1201  (yy_start) = 1; /* first start state */
1202 
1203  if ( ! yyin )
1204  yyin = stdin;
1205 
1206  if ( ! yyout )
1207  yyout = stdout;
1208 
1209  if ( ! YY_CURRENT_BUFFER ) {
1213  }
1214 
1216  }
1217 
1218  {
1219 #line 72 "../random_maps/reader.l"
1220 
1221 
1222 
1223 #line 76 "../random_maps/reader.l"
1224 /* Declare some local variables */
1225 
1226  rmap_lex_error = 0;
1227 
1228 
1229 
1230 #line 1231 "reader.cpp"
1231 
1232  while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
1233  {
1234  yy_cp = (yy_c_buf_p);
1235 
1236  /* Support of yytext. */
1237  *yy_cp = (yy_hold_char);
1238 
1239  /* yy_bp points to the position in yy_ch_buf of the start of
1240  * the current run.
1241  */
1242  yy_bp = yy_cp;
1243 
1244  yy_current_state = (yy_start);
1245  yy_current_state += YY_AT_BOL();
1246 yy_match:
1247  do
1248  {
1249  YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
1250  if ( yy_accept[yy_current_state] )
1251  {
1252  (yy_last_accepting_state) = yy_current_state;
1254  }
1255  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1256  {
1257  yy_current_state = (int) yy_def[yy_current_state];
1258  if ( yy_current_state >= 390 )
1259  yy_c = yy_meta[yy_c];
1260  }
1261  yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1262  ++yy_cp;
1263  }
1264  while ( yy_base[yy_current_state] != 432 );
1265 
1266 yy_find_action:
1267  yy_act = yy_accept[yy_current_state];
1268  if ( yy_act == 0 )
1269  { /* have to back up */
1271  yy_current_state = (yy_last_accepting_state);
1272  yy_act = yy_accept[yy_current_state];
1273  }
1274 
1276 
1277 do_action: /* This label is used only to access EOF actions. */
1278 
1279  switch ( yy_act )
1280  { /* beginning of action switch */
1281  case 0: /* must back up */
1282  /* undo the effects of YY_DO_BEFORE_ACTION */
1283  *yy_cp = (yy_hold_char);
1285  yy_current_state = (yy_last_accepting_state);
1286  goto yy_find_action;
1287 
1288 case 1:
1290 #line 82 "../random_maps/reader.l"
1291 strncpy(RP->wallstyle, rmap_yval(), RM_SIZE);
1292  YY_BREAK
1293 case 2:
1295 #line 83 "../random_maps/reader.l"
1296 strncpy(RP->floorstyle, rmap_yval(), RM_SIZE);
1297  YY_BREAK
1298 case 3:
1300 #line 84 "../random_maps/reader.l"
1301 strncpy(RP->monsterstyle, rmap_yval(), RM_SIZE);
1302  YY_BREAK
1303 case 4:
1305 #line 85 "../random_maps/reader.l"
1306 strncpy(RP->treasurestyle, rmap_yval(), RM_SIZE);
1307  YY_BREAK
1308 case 5:
1310 #line 86 "../random_maps/reader.l"
1311 strncpy(RP->layoutstyle, rmap_yval(), RM_SIZE);
1312  YY_BREAK
1313 case 6:
1315 #line 87 "../random_maps/reader.l"
1316 strncpy(RP->doorstyle, rmap_yval(), RM_SIZE);
1317  YY_BREAK
1318 case 7:
1320 #line 88 "../random_maps/reader.l"
1321 strncpy(RP->decorstyle, rmap_yval(), RM_SIZE);
1322  YY_BREAK
1323 case 8:
1325 #line 89 "../random_maps/reader.l"
1326 strncpy(RP->cheststyle, rmap_yval(), RM_SIZE);
1327  YY_BREAK
1328 case 9:
1330 #line 90 "../random_maps/reader.l"
1331 RP->Xsize = IVAL;
1332  YY_BREAK
1333 case 10:
1335 #line 91 "../random_maps/reader.l"
1336 RP->Ysize = IVAL;
1337  YY_BREAK
1338 case 11:
1340 #line 92 "../random_maps/reader.l"
1341 RP->expand2x = IVAL;
1342  YY_BREAK
1343 case 12:
1345 #line 93 "../random_maps/reader.l"
1346 RP->layoutoptions1 = IVAL;
1347  YY_BREAK
1348 case 13:
1350 #line 94 "../random_maps/reader.l"
1351 RP->layoutoptions2 = IVAL;
1352  YY_BREAK
1353 case 14:
1355 #line 95 "../random_maps/reader.l"
1356 RP->symmetry = IVAL;
1357  YY_BREAK
1358 case 15:
1360 #line 96 "../random_maps/reader.l"
1361 RP->difficulty = IVAL;
1362  YY_BREAK
1363 case 16:
1365 #line 97 "../random_maps/reader.l"
1366 RP->difficulty_increase = FVAL;
1367  YY_BREAK
1368 case 17:
1370 #line 98 "../random_maps/reader.l"
1371 RP->decoroptions = IVAL;
1372  YY_BREAK
1373 case 18:
1375 #line 99 "../random_maps/reader.l"
1376 strncpy(RP->exitstyle, rmap_yval(), RM_SIZE);
1377  YY_BREAK
1378 case 19:
1380 #line 100 "../random_maps/reader.l"
1381 RP->dungeon_level = IVAL;
1382  YY_BREAK
1383 case 20:
1385 #line 101 "../random_maps/reader.l"
1386 strncpy(RP->dungeon_name, rmap_yval(), RM_SIZE);
1387  YY_BREAK
1388 case 21:
1390 #line 102 "../random_maps/reader.l"
1391 RP->dungeon_depth = IVAL;
1392  YY_BREAK
1393 case 22:
1395 #line 103 "../random_maps/reader.l"
1396 strncpy(RP->final_map, rmap_yval(), RM_SIZE);
1397  YY_BREAK
1398 case 23:
1400 #line 104 "../random_maps/reader.l"
1401 strncpy(RP->final_exit_archetype, rmap_yval(), RM_SIZE);
1402  YY_BREAK
1403 case 24:
1405 #line 105 "../random_maps/reader.l"
1406 RP-> orientation = IVAL;
1407  YY_BREAK
1408 case 25:
1410 #line 106 "../random_maps/reader.l"
1411 RP->origin_x = IVAL;
1412  YY_BREAK
1413 case 26:
1415 #line 107 "../random_maps/reader.l"
1416 RP-> origin_y = IVAL;
1417  YY_BREAK
1418 case 27:
1420 #line 108 "../random_maps/reader.l"
1421 strncpy(RP->origin_map, rmap_yval(), RM_SIZE);
1422  YY_BREAK
1423 case 28:
1425 #line 109 "../random_maps/reader.l"
1426 RP->random_seed = IVAL;
1427  YY_BREAK
1428 case 29:
1430 #line 110 "../random_maps/reader.l"
1431 RP->treasureoptions = IVAL;
1432  YY_BREAK
1433 case 30:
1435 #line 111 "../random_maps/reader.l"
1436 strncpy(RP->exit_on_final_map, rmap_yval(), RM_SIZE);
1437  YY_BREAK
1438 case 31:
1440 #line 112 "../random_maps/reader.l"
1441 RP->multiple_floors = IVAL;
1442  YY_BREAK
1443 case 32:
1445 #line 113 "../random_maps/reader.l"
1446 RP->darkness = IVAL;
1447  YY_BREAK
1448 case 33:
1450 #line 114 "../random_maps/reader.l"
1451 RP->outdoor = IVAL;
1452  YY_BREAK
1453 case 34:
1454 /* rule 34 can match eol */
1456 #line 116 "../random_maps/reader.l"
1457 {/* ignore empty lines, newlines we don't do above */}
1458  YY_BREAK
1459 case 35:
1460 /* rule 35 can match eol */
1462 #line 117 "../random_maps/reader.l"
1463 { }
1464  YY_BREAK
1465 case YY_STATE_EOF(INITIAL):
1466 case YY_STATE_EOF(MESSAGE):
1467 #line 119 "../random_maps/reader.l"
1468 {/* If we got an error, return the error. Otherwise, return that we got EOF */
1469  if (rmap_lex_error != 0)
1470  return rmap_lex_error;
1471  else
1472  return LL_EOF;
1473  }
1474  YY_BREAK
1475 case 36:
1477 #line 125 "../random_maps/reader.l"
1478 {
1479  yyerror("Unrecognized string");
1480  rmap_lex_error= -1;
1481  }
1482  YY_BREAK
1483 case 37:
1485 #line 129 "../random_maps/reader.l"
1486 ECHO;
1487  YY_BREAK
1488 #line 1489 "reader.cpp"
1489 
1490  case YY_END_OF_BUFFER:
1491  {
1492  /* Amount of text matched not including the EOB char. */
1493  int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
1494 
1495  /* Undo the effects of YY_DO_BEFORE_ACTION. */
1496  *yy_cp = (yy_hold_char);
1498 
1499  if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1500  {
1501  /* We're scanning a new file or input source. It's
1502  * possible that this happened because the user
1503  * just pointed yyin at a new source and called
1504  * yylex(). If so, then we have to assure
1505  * consistency between YY_CURRENT_BUFFER and our
1506  * globals. Here is the right place to do so, because
1507  * this is the first action (other than possibly a
1508  * back-up) that will match for the new input source.
1509  */
1510  (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1511  YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1512  YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1513  }
1514 
1515  /* Note that here we test for yy_c_buf_p "<=" to the position
1516  * of the first EOB in the buffer, since yy_c_buf_p will
1517  * already have been incremented past the NUL character
1518  * (since all states make transitions on EOB to the
1519  * end-of-buffer state). Contrast this with the test
1520  * in input().
1521  */
1522  if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1523  { /* This was really a NUL. */
1524  yy_state_type yy_next_state;
1525 
1526  (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1527 
1528  yy_current_state = yy_get_previous_state( );
1529 
1530  /* Okay, we're now positioned to make the NUL
1531  * transition. We couldn't have
1532  * yy_get_previous_state() go ahead and do it
1533  * for us because it doesn't know how to deal
1534  * with the possibility of jamming (and we don't
1535  * want to build jamming into it because then it
1536  * will run more slowly).
1537  */
1538 
1539  yy_next_state = yy_try_NUL_trans( yy_current_state );
1540 
1542 
1543  if ( yy_next_state )
1544  {
1545  /* Consume the NUL. */
1546  yy_cp = ++(yy_c_buf_p);
1547  yy_current_state = yy_next_state;
1548  goto yy_match;
1549  }
1550 
1551  else
1552  {
1553  yy_cp = (yy_c_buf_p);
1554  goto yy_find_action;
1555  }
1556  }
1557 
1558  else switch ( yy_get_next_buffer( ) )
1559  {
1560  case EOB_ACT_END_OF_FILE:
1561  {
1563 
1564  if ( yywrap( ) )
1565  {
1566  /* Note: because we've taken care in
1567  * yy_get_next_buffer() to have set up
1568  * yytext, we can now set up
1569  * yy_c_buf_p so that if some total
1570  * hoser (like flex itself) wants to
1571  * call the scanner after we return the
1572  * YY_NULL, it'll still work - another
1573  * YY_NULL will get returned.
1574  */
1576 
1578  goto do_action;
1579  }
1580 
1581  else
1582  {
1583  if ( ! (yy_did_buffer_switch_on_eof) )
1584  YY_NEW_FILE;
1585  }
1586  break;
1587  }
1588 
1589  case EOB_ACT_CONTINUE_SCAN:
1590  (yy_c_buf_p) =
1591  (yytext_ptr) + yy_amount_of_matched_text;
1592 
1593  yy_current_state = yy_get_previous_state( );
1594 
1595  yy_cp = (yy_c_buf_p);
1597  goto yy_match;
1598 
1599  case EOB_ACT_LAST_MATCH:
1600  (yy_c_buf_p) =
1601  &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1602 
1603  yy_current_state = yy_get_previous_state( );
1604 
1605  yy_cp = (yy_c_buf_p);
1607  goto yy_find_action;
1608  }
1609  break;
1610  }
1611 
1612  default:
1614  "fatal flex scanner internal error--no action found" );
1615  } /* end of action switch */
1616  } /* end of scanning one token */
1617  } /* end of user's declarations */
1618 } /* end of yylex */
1619 
1620 /* yy_get_next_buffer - try to read in a new buffer
1621  *
1622  * Returns a code representing an action:
1623  * EOB_ACT_LAST_MATCH -
1624  * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1625  * EOB_ACT_END_OF_FILE - end of file
1626  */
1627 static int yy_get_next_buffer (void)
1628 {
1629  char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1630  char *source = (yytext_ptr);
1631  int number_to_move, i;
1632  int ret_val;
1633 
1634  if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1636  "fatal flex scanner internal error--end of buffer missed" );
1637 
1638  if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1639  { /* Don't try to fill the buffer, so this is an EOF. */
1640  if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1641  {
1642  /* We matched a single character, the EOB, so
1643  * treat this as a final EOF.
1644  */
1645  return EOB_ACT_END_OF_FILE;
1646  }
1647 
1648  else
1649  {
1650  /* We matched some text prior to the EOB, first
1651  * process it.
1652  */
1653  return EOB_ACT_LAST_MATCH;
1654  }
1655  }
1656 
1657  /* Try to read more data. */
1658 
1659  /* First move last chars to start of buffer. */
1660  number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1);
1661 
1662  for ( i = 0; i < number_to_move; ++i )
1663  *(dest++) = *(source++);
1664 
1665  if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1666  /* don't do the read, it's not guaranteed to return an EOF,
1667  * just force an EOF
1668  */
1669  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1670 
1671  else
1672  {
1673  int num_to_read =
1674  YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1675 
1676  while ( num_to_read <= 0 )
1677  { /* Not enough room in the buffer - grow it. */
1678 
1679  /* just a shorter name for the current buffer */
1681 
1682  int yy_c_buf_p_offset =
1683  (int) ((yy_c_buf_p) - b->yy_ch_buf);
1684 
1685  if ( b->yy_is_our_buffer )
1686  {
1687  int new_size = b->yy_buf_size * 2;
1688 
1689  if ( new_size <= 0 )
1690  b->yy_buf_size += b->yy_buf_size / 8;
1691  else
1692  b->yy_buf_size *= 2;
1693 
1694  b->yy_ch_buf = (char *)
1695  /* Include room in for 2 EOB chars. */
1696  yyrealloc( (void *) b->yy_ch_buf,
1697  (yy_size_t) (b->yy_buf_size + 2) );
1698  }
1699  else
1700  /* Can't grow it, we don't own it. */
1701  b->yy_ch_buf = NULL;
1702 
1703  if ( ! b->yy_ch_buf )
1705  "fatal error - scanner input buffer overflow" );
1706 
1707  (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1708 
1709  num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1710  number_to_move - 1;
1711 
1712  }
1713 
1714  if ( num_to_read > YY_READ_BUF_SIZE )
1715  num_to_read = YY_READ_BUF_SIZE;
1716 
1717  /* Read in more data. */
1718  YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1719  (yy_n_chars), num_to_read );
1720 
1721  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1722  }
1723 
1724  if ( (yy_n_chars) == 0 )
1725  {
1726  if ( number_to_move == YY_MORE_ADJ )
1727  {
1728  ret_val = EOB_ACT_END_OF_FILE;
1729  yyrestart( yyin );
1730  }
1731 
1732  else
1733  {
1734  ret_val = EOB_ACT_LAST_MATCH;
1735  YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1737  }
1738  }
1739 
1740  else
1741  ret_val = EOB_ACT_CONTINUE_SCAN;
1742 
1743  if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1744  /* Extend the array by 50%, plus the number we really need. */
1745  int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1746  YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
1747  (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size );
1748  if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1749  YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1750  /* "- 2" to take care of EOB's */
1751  YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
1752  }
1753 
1754  (yy_n_chars) += number_to_move;
1757 
1758  (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1759 
1760  return ret_val;
1761 }
1762 
1763 /* yy_get_previous_state - get the state just before the EOB char was reached */
1764 
1766 {
1767  yy_state_type yy_current_state;
1768  char *yy_cp;
1769 
1770  yy_current_state = (yy_start);
1771  yy_current_state += YY_AT_BOL();
1772 
1773  for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1774  {
1775  YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1776  if ( yy_accept[yy_current_state] )
1777  {
1778  (yy_last_accepting_state) = yy_current_state;
1780  }
1781  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1782  {
1783  yy_current_state = (int) yy_def[yy_current_state];
1784  if ( yy_current_state >= 390 )
1785  yy_c = yy_meta[yy_c];
1786  }
1787  yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1788  }
1789 
1790  return yy_current_state;
1791 }
1792 
1793 /* yy_try_NUL_trans - try to make a transition on the NUL character
1794  *
1795  * synopsis
1796  * next_state = yy_try_NUL_trans( current_state );
1797  */
1798  static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
1799 {
1800  int yy_is_jam;
1801  char *yy_cp = (yy_c_buf_p);
1802 
1803  YY_CHAR yy_c = 1;
1804  if ( yy_accept[yy_current_state] )
1805  {
1806  (yy_last_accepting_state) = yy_current_state;
1808  }
1809  while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1810  {
1811  yy_current_state = (int) yy_def[yy_current_state];
1812  if ( yy_current_state >= 390 )
1813  yy_c = yy_meta[yy_c];
1814  }
1815  yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1816  yy_is_jam = (yy_current_state == 389);
1817 
1818  return yy_is_jam ? 0 : yy_current_state;
1819 }
1820 
1821 #ifndef YY_NO_UNPUT
1822 
1823 #endif
1824 
1825 #ifndef YY_NO_INPUT
1826 #ifdef __cplusplus
1827  static int yyinput (void)
1828 #else
1829  static int input (void)
1830 #endif
1831 
1832 {
1833  int c;
1834 
1835  *(yy_c_buf_p) = (yy_hold_char);
1836 
1837  if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1838  {
1839  /* yy_c_buf_p now points to the character we want to return.
1840  * If this occurs *before* the EOB characters, then it's a
1841  * valid NUL; if not, then we've hit the end of the buffer.
1842  */
1843  if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1844  /* This was really a NUL. */
1845  *(yy_c_buf_p) = '\0';
1846 
1847  else
1848  { /* need more input */
1849  int offset = (int) ((yy_c_buf_p) - (yytext_ptr));
1850  ++(yy_c_buf_p);
1851 
1852  switch ( yy_get_next_buffer( ) )
1853  {
1854  case EOB_ACT_LAST_MATCH:
1855  /* This happens because yy_g_n_b()
1856  * sees that we've accumulated a
1857  * token and flags that we need to
1858  * try matching the token before
1859  * proceeding. But for input(),
1860  * there's no matching to consider.
1861  * So convert the EOB_ACT_LAST_MATCH
1862  * to EOB_ACT_END_OF_FILE.
1863  */
1864 
1865  /* Reset buffer status. */
1866  yyrestart( yyin );
1867 
1868  /*FALLTHROUGH*/
1869 
1870  case EOB_ACT_END_OF_FILE:
1871  {
1872  if ( yywrap( ) )
1873  return 0;
1874 
1875  if ( ! (yy_did_buffer_switch_on_eof) )
1876  YY_NEW_FILE;
1877 #ifdef __cplusplus
1878  return yyinput();
1879 #else
1880  return input();
1881 #endif
1882  }
1883 
1884  case EOB_ACT_CONTINUE_SCAN:
1885  (yy_c_buf_p) = (yytext_ptr) + offset;
1886  break;
1887  }
1888  }
1889  }
1890 
1891  c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
1892  *(yy_c_buf_p) = '\0'; /* preserve yytext */
1893  (yy_hold_char) = *++(yy_c_buf_p);
1894 
1895  YY_CURRENT_BUFFER_LVALUE->yy_at_bol = (c == '\n');
1896 
1897  return c;
1898 }
1899 #endif /* ifndef YY_NO_INPUT */
1900 
1906  void yyrestart (FILE * input_file )
1907 {
1908 
1909  if ( ! YY_CURRENT_BUFFER ){
1913  }
1914 
1915  yy_init_buffer( YY_CURRENT_BUFFER, input_file );
1917 }
1918 
1924 {
1925 
1926  /* TODO. We should be able to replace this entire function body
1927  * with
1928  * yypop_buffer_state();
1929  * yypush_buffer_state(new_buffer);
1930  */
1932  if ( YY_CURRENT_BUFFER == new_buffer )
1933  return;
1934 
1935  if ( YY_CURRENT_BUFFER )
1936  {
1937  /* Flush out information for old buffer. */
1938  *(yy_c_buf_p) = (yy_hold_char);
1939  YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1940  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1941  }
1942 
1943  YY_CURRENT_BUFFER_LVALUE = new_buffer;
1945 
1946  /* We don't actually know whether we did this switch during
1947  * EOF (yywrap()) processing, but the only time this flag
1948  * is looked at is after yywrap() is called, so it's safe
1949  * to go ahead and always set it.
1950  */
1952 }
1953 
1954 static void yy_load_buffer_state (void)
1955 {
1956  (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1957  (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1958  yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1959  (yy_hold_char) = *(yy_c_buf_p);
1960 }
1961 
1969 {
1971 
1972  b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
1973  if ( ! b )
1974  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1975 
1976  b->yy_buf_size = size;
1977 
1978  /* yy_ch_buf has to be 2 characters longer than the size given because
1979  * we need to put in 2 end-of-buffer characters.
1980  */
1981  b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) );
1982  if ( ! b->yy_ch_buf )
1983  YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1984 
1985  b->yy_is_our_buffer = 1;
1986 
1987  yy_init_buffer( b, file );
1988 
1989  return b;
1990 }
1991 
1997 {
1998 
1999  if ( ! b )
2000  return;
2001 
2002  if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
2004 
2005  if ( b->yy_is_our_buffer )
2006  yyfree( (void *) b->yy_ch_buf );
2007 
2008  yyfree( (void *) b );
2009 }
2010 
2011 /* Initializes or reinitializes a buffer.
2012  * This function is sometimes called more than once on the same buffer,
2013  * such as during a yyrestart() or at EOF.
2014  */
2015  static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file )
2016 
2017 {
2018  int oerrno = errno;
2019 
2020  yy_flush_buffer( b );
2021 
2022  b->yy_input_file = file;
2023  b->yy_fill_buffer = 1;
2024 
2025  /* If b is the current buffer, then yy_init_buffer was _probably_
2026  * called from yyrestart() or through yy_get_next_buffer.
2027  * In that case, we don't want to reset the lineno or column.
2028  */
2029  if (b != YY_CURRENT_BUFFER){
2030  b->yy_bs_lineno = 1;
2031  b->yy_bs_column = 0;
2032  }
2033 
2034  b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
2035 
2036  errno = oerrno;
2037 }
2038 
2044 {
2045  if ( ! b )
2046  return;
2047 
2048  b->yy_n_chars = 0;
2049 
2050  /* We always need two end-of-buffer characters. The first causes
2051  * a transition to the end-of-buffer state. The second causes
2052  * a jam in that state.
2053  */
2054  b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
2055  b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
2056 
2057  b->yy_buf_pos = &b->yy_ch_buf[0];
2058 
2059  b->yy_at_bol = 1;
2060  b->yy_buffer_status = YY_BUFFER_NEW;
2061 
2062  if ( b == YY_CURRENT_BUFFER )
2064 }
2065 
2073 {
2074  if (new_buffer == NULL)
2075  return;
2076 
2078 
2079  /* This block is copied from yy_switch_to_buffer. */
2080  if ( YY_CURRENT_BUFFER )
2081  {
2082  /* Flush out information for old buffer. */
2083  *(yy_c_buf_p) = (yy_hold_char);
2084  YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
2085  YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
2086  }
2087 
2088  /* Only push if top exists. Otherwise, replace top. */
2089  if (YY_CURRENT_BUFFER)
2090  (yy_buffer_stack_top)++;
2091  YY_CURRENT_BUFFER_LVALUE = new_buffer;
2092 
2093  /* copied from yy_switch_to_buffer. */
2096 }
2097 
2102 void yypop_buffer_state (void)
2103 {
2104  if (!YY_CURRENT_BUFFER)
2105  return;
2106 
2108  YY_CURRENT_BUFFER_LVALUE = NULL;
2109  if ((yy_buffer_stack_top) > 0)
2110  --(yy_buffer_stack_top);
2111 
2112  if (YY_CURRENT_BUFFER) {
2115  }
2116 }
2117 
2118 /* Allocates the stack if it does not exist.
2119  * Guarantees space for at least one push.
2120  */
2121 static void yyensure_buffer_stack (void)
2122 {
2123  yy_size_t num_to_alloc;
2124 
2125  if (!(yy_buffer_stack)) {
2126 
2127  /* First allocation is just for 2 elements, since we don't know if this
2128  * scanner will even need a stack. We use 2 instead of 1 to avoid an
2129  * immediate realloc on the next call.
2130  */
2131  num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
2133  (num_to_alloc * sizeof(struct yy_buffer_state*)
2134  );
2135  if ( ! (yy_buffer_stack) )
2136  YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
2137 
2138  memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
2139 
2140  (yy_buffer_stack_max) = num_to_alloc;
2141  (yy_buffer_stack_top) = 0;
2142  return;
2143  }
2144 
2145  if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
2146 
2147  /* Increase the buffer to prepare for a possible push. */
2148  yy_size_t grow_size = 8 /* arbitrary grow size */;
2149 
2150  num_to_alloc = (yy_buffer_stack_max) + grow_size;
2152  ((yy_buffer_stack),
2153  num_to_alloc * sizeof(struct yy_buffer_state*)
2154  );
2155  if ( ! (yy_buffer_stack) )
2156  YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
2157 
2158  /* zero only the new slots.*/
2159  memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
2160  (yy_buffer_stack_max) = num_to_alloc;
2161  }
2162 }
2163 
2171 {
2173 
2174  if ( size < 2 ||
2175  base[size-2] != YY_END_OF_BUFFER_CHAR ||
2176  base[size-1] != YY_END_OF_BUFFER_CHAR )
2177  /* They forgot to leave room for the EOB's. */
2178  return NULL;
2179 
2180  b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
2181  if ( ! b )
2182  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
2183 
2184  b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */
2185  b->yy_buf_pos = b->yy_ch_buf = base;
2186  b->yy_is_our_buffer = 0;
2187  b->yy_input_file = NULL;
2188  b->yy_n_chars = b->yy_buf_size;
2189  b->yy_is_interactive = 0;
2190  b->yy_at_bol = 1;
2191  b->yy_fill_buffer = 0;
2192  b->yy_buffer_status = YY_BUFFER_NEW;
2193 
2195 
2196  return b;
2197 }
2198 
2207 YY_BUFFER_STATE yy_scan_string (const char * yystr )
2208 {
2209 
2210  return yy_scan_bytes( yystr, (int) strlen(yystr) );
2211 }
2212 
2220 YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len )
2221 {
2223  char *buf;
2224  yy_size_t n;
2225  int i;
2226 
2227  /* Get memory for full buffer, including space for trailing EOB's. */
2228  n = (yy_size_t) (_yybytes_len + 2);
2229  buf = (char *) yyalloc( n );
2230  if ( ! buf )
2231  YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
2232 
2233  for ( i = 0; i < _yybytes_len; ++i )
2234  buf[i] = yybytes[i];
2235 
2236  buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
2237 
2238  b = yy_scan_buffer( buf, n );
2239  if ( ! b )
2240  YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
2241 
2242  /* It's okay to grow etc. this buffer, and we should throw it
2243  * away when we're done.
2244  */
2245  b->yy_is_our_buffer = 1;
2246 
2247  return b;
2248 }
2249 
2250 #ifndef YY_EXIT_FAILURE
2251 #define YY_EXIT_FAILURE 2
2252 #endif
2253 
2254 static void yynoreturn yy_fatal_error (const char* msg )
2255 {
2256  fprintf( stderr, "%s\n", msg );
2257  exit( YY_EXIT_FAILURE );
2258 }
2259 
2260 /* Redefine yyless() so it works in section 3 code. */
2261 
2262 #undef yyless
2263 #define yyless(n) \
2264  do \
2265  { \
2266  /* Undo effects of setting up yytext. */ \
2267  int yyless_macro_arg = (n); \
2268  YY_LESS_LINENO(yyless_macro_arg);\
2269  yytext[yyleng] = (yy_hold_char); \
2270  (yy_c_buf_p) = yytext + yyless_macro_arg; \
2271  (yy_hold_char) = *(yy_c_buf_p); \
2272  *(yy_c_buf_p) = '\0'; \
2273  yyleng = yyless_macro_arg; \
2274  } \
2275  while ( 0 )
2276 
2277 /* Accessor methods (get/set functions) to struct members. */
2278 
2282 int yyget_lineno (void)
2283 {
2284 
2285  return yylineno;
2286 }
2287 
2291 FILE *yyget_in (void)
2292 {
2293  return yyin;
2294 }
2295 
2299 FILE *yyget_out (void)
2300 {
2301  return yyout;
2302 }
2303 
2307 int yyget_leng (void)
2308 {
2309  return yyleng;
2310 }
2311 
2316 char *yyget_text (void)
2317 {
2318  return yytext;
2319 }
2320 
2325 void yyset_lineno (int _line_number )
2326 {
2327 
2328  yylineno = _line_number;
2329 }
2330 
2337 void yyset_in (FILE * _in_str )
2338 {
2339  yyin = _in_str ;
2340 }
2341 
2342 void yyset_out (FILE * _out_str )
2343 {
2344  yyout = _out_str ;
2345 }
2346 
2347 int yyget_debug (void)
2348 {
2349  return yy_flex_debug;
2350 }
2351 
2352 void yyset_debug (int _bdebug )
2353 {
2354  yy_flex_debug = _bdebug ;
2355 }
2356 
2357 static int yy_init_globals (void)
2358 {
2359  /* Initialization is the same as for the non-reentrant scanner.
2360  * This function is called from yylex_destroy(), so don't allocate here.
2361  */
2362 
2363  (yy_buffer_stack) = NULL;
2364  (yy_buffer_stack_top) = 0;
2365  (yy_buffer_stack_max) = 0;
2366  (yy_c_buf_p) = NULL;
2367  (yy_init) = 0;
2368  (yy_start) = 0;
2369 
2370 /* Defined in main.c */
2371 #ifdef YY_STDINIT
2372  yyin = stdin;
2373  yyout = stdout;
2374 #else
2375  yyin = NULL;
2376  yyout = NULL;
2377 #endif
2378 
2379  /* For future reference: Set errno on error, since we are called by
2380  * yylex_init()
2381  */
2382  return 0;
2383 }
2384 
2385 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
2386 int yylex_destroy (void)
2387 {
2388 
2389  /* Pop the buffer stack, destroying each element. */
2390  while(YY_CURRENT_BUFFER){
2392  YY_CURRENT_BUFFER_LVALUE = NULL;
2394  }
2395 
2396  /* Destroy the stack itself. */
2397  yyfree((yy_buffer_stack) );
2398  (yy_buffer_stack) = NULL;
2399 
2400  /* Reset the globals. This is important in a non-reentrant scanner so the next time
2401  * yylex() is called, initialization will occur. */
2402  yy_init_globals( );
2403 
2404  return 0;
2405 }
2406 
2407 /*
2408  * Internal utility routines.
2409  */
2410 
2411 #ifndef yytext_ptr
2412 static void yy_flex_strncpy (char* s1, const char * s2, int n )
2413 {
2414 
2415  int i;
2416  for ( i = 0; i < n; ++i )
2417  s1[i] = s2[i];
2418 }
2419 #endif
2420 
2421 #ifdef YY_NEED_STRLEN
2422 static int yy_flex_strlen (const char * s )
2423 {
2424  int n;
2425  for ( n = 0; s[n]; ++n )
2426  ;
2427 
2428  return n;
2429 }
2430 #endif
2431 
2432 void *yyalloc (yy_size_t size )
2433 {
2434  return malloc(size);
2435 }
2436 
2437 void *yyrealloc (void * ptr, yy_size_t size )
2438 {
2439 
2440  /* The cast to (char *) in the following accommodates both
2441  * implementations that use char* generic pointers, and those
2442  * that use void* generic pointers. It works with the latter
2443  * because both ANSI C and C++ allow castless assignment from
2444  * any pointer type to void*, and deal with argument conversions
2445  * as though doing an assignment.
2446  */
2447  return realloc(ptr, size);
2448 }
2449 
2450 void yyfree (void * ptr )
2451 {
2452  free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
2453 }
2454 
2455 #define YYTABLES_NAME "yytables"
2456 
2457 #line 129 "../random_maps/reader.l"
2458 
2459 
2460 /* Our save file syntax is very simple, so we can use a very simple
2461  * processing mechanism here instead using something like bison
2462  * This skips over the space and returns the value, or "" if no value
2463  * is found.
2464  */
2465 static char *rmap_yval(void) {
2466  static char em[] = "";
2467  char *cp;
2468 
2469  cp = strchr(yytext, ' ');
2470  if (cp)
2471  return cp+1;
2472  else
2473  return em;
2474 }
2475 
2476 int load_parameters(FILE *fp, int bufstate, RMParms *RP) {
2477  int retval;
2478  char inbuf[MAX_BUF];
2479 
2480  if (bufstate == LO_NEWFILE || bufstate == LO_NOREAD) {
2483  if (bufstate == LO_NOREAD)
2484  return LL_NORMAL;
2485  }
2486  if (bufstate == LO_LINEMODE) {
2487  YY_BUFFER_STATE yybufstate;
2488  while (fgets(inbuf, MAX_BUF-3, fp)) {
2489  yybufstate = yy_scan_string(inbuf);
2490  retval = rmap_lex_read(RP);
2491  yy_delete_buffer(yybufstate);
2492  if (retval == LL_NORMAL)
2493  return retval;
2494  }
2495  return LL_EOF;
2496  }
2497 
2498  retval = rmap_lex_read(RP);
2499 /* LOG(llevDebug, " load completed, object=%s\n", op->name);*/
2500  return retval;
2501 }
2502 
2503 
2504 /* This takes a buffer, scans it for variables, and sets those variables
2505  * as appropriate in op.
2506  *
2507  * This function appears to be used in only 2 places - in crossedit to
2508  * override values and in c_wiz to mutate values.
2509  */
2510 int set_random_map_variable(RMParms *rp, const char *buf) {
2511  YY_BUFFER_STATE yybufstate;
2512  int retval;
2513 
2514  yybufstate = yy_scan_string(buf);
2515  retval = rmap_lex_read(rp);
2516  yy_delete_buffer(yybufstate);
2517  return retval;
2518 }
2519 
flex_int32_t
int flex_int32_t
Definition: loader.c:52
rmap_lex_error
static int rmap_lex_error
Definition: reader.cpp:978
yyget_leng
#define yyget_leng
Definition: reader.cpp:195
global.h
yyget_out
#define yyget_out
Definition: reader.cpp:183
yy_scan_bytes
#define yy_scan_bytes
Definition: reader.cpp:13
YY_MORE_ADJ
#define YY_MORE_ADJ
Definition: reader.cpp:935
yynoreturn
#define yynoreturn
Definition: reader.cpp:362
random_map.h
yy_buffer_stack_max
static size_t yy_buffer_stack_max
Definition: reader.cpp:510
yylex_destroy
#define yylex_destroy
Definition: reader.cpp:141
yyset_debug
#define yyset_debug
Definition: reader.cpp:153
llevError
@ llevError
Definition: logger.h:11
LOG
void LOG(LogLevel logLevel, const char *format,...)
Definition: logger.cpp:51
load_parameters
int load_parameters(FILE *fp, int bufstate, RMParms *RP)
Definition: reader.cpp:2476
YY_BUFFER_EOF_PENDING
#define YY_BUFFER_EOF_PENDING
Definition: reader.cpp:503
yy_trans_info
Definition: loader.c:361
YY_RULE_SETUP
#define YY_RULE_SETUP
Definition: reader.cpp:1178
flex_uint8_t
unsigned char flex_uint8_t
Definition: reader.cpp:313
YY_AT_BOL
#define YY_AT_BOL()
Definition: reader.cpp:582
YY_RESTORE_YY_MORE_OFFSET
#define YY_RESTORE_YY_MORE_OFFSET
Definition: reader.cpp:936
yy_buffer_state::yy_input_file
FILE * yy_input_file
Definition: loader.c:187
yy_accept
static const flex_int16_t yy_accept[390]
Definition: reader.cpp:626
c
static event_registration c
Definition: citylife.cpp:425
YY_CHAR
flex_uint8_t YY_CHAR
Definition: loader.c:328
yy_size_t
size_t yy_size_t
Definition: loader.c:154
yy_flex_debug
#define yy_flex_debug
Definition: reader.cpp:21
yy_buffer_state
Definition: loader.c:185
RM_SIZE
#define RM_SIZE
Definition: random_map.h:9
YY_EXTRA_TYPE
#define YY_EXTRA_TYPE
Definition: reader.cpp:1014
yyout
#define yyout
Definition: reader.cpp:26
yy_scan_string
#define yy_scan_string
Definition: reader.cpp:12
mad_mage_user.file
file
Definition: mad_mage_user.py:15
YY_BUFFER_STATE
struct yy_buffer_state * YY_BUFFER_STATE
Definition: reader.cpp:409
rmap_lex_read
static int rmap_lex_read(RMParms *RP)
yy_bp
char * yy_bp
Definition: reader.cpp:1189
LO_NEWFILE
#define LO_NEWFILE
Definition: loader.h:17
YY_END_OF_BUFFER_CHAR
#define YY_END_OF_BUFFER_CHAR
Definition: reader.cpp:388
yy_act
int yy_act
Definition: reader.cpp:1190
yy_state_type
int yy_state_type
Definition: loader.c:332
yyset_in
#define yyset_in
Definition: reader.cpp:177
yy_buffer_state::yy_at_bol
int yy_at_bol
Definition: loader.c:219
yyget_debug
#define yyget_debug
Definition: reader.cpp:147
yy_scan_buffer
#define yy_scan_buffer
Definition: reader.cpp:11
buf
StringBuffer * buf
Definition: readable.cpp:1551
EOB_ACT_CONTINUE_SCAN
#define EOB_ACT_CONTINUE_SCAN
Definition: reader.cpp:421
RMParms
Definition: random_map.h:14
YY_EXIT_FAILURE
#define YY_EXIT_FAILURE
Definition: reader.cpp:2251
ECHO
#define ECHO
Definition: reader.cpp:1096
yy_buffer_state::yy_is_our_buffer
int yy_is_our_buffer
Definition: loader.c:206
flex_uint32_t
unsigned int flex_uint32_t
Definition: reader.cpp:315
yy_switch_to_buffer
#define yy_switch_to_buffer
Definition: reader.cpp:17
LO_NOREAD
#define LO_NOREAD
Definition: loader.h:18
yyrestart
#define yyrestart
Definition: reader.cpp:27
yy_try_NUL_trans
static yy_state_type yy_try_NUL_trans(yy_state_type current_state)
Definition: reader.cpp:1798
yy_size_t
size_t yy_size_t
Definition: reader.cpp:414
yytext
#define yytext
Definition: reader.cpp:28
yy_last_accepting_state
static yy_state_type yy_last_accepting_state
Definition: reader.cpp:924
yyleng
#define yyleng
Definition: reader.cpp:23
INITIAL
#define INITIAL
Definition: reader.cpp:1002
yyget_extra
#define yyget_extra
Definition: reader.cpp:159
YY_DECL
#define YY_DECL
Definition: reader.cpp:973
flex_uint16_t
unsigned short int flex_uint16_t
Definition: reader.cpp:314
YY_END_OF_BUFFER
#define YY_END_OF_BUFFER
Definition: reader.cpp:618
yy_delete_buffer
#define yy_delete_buffer
Definition: reader.cpp:10
MESSAGE
#define MESSAGE
Definition: reader.cpp:1003
yyerror
static int yyerror(const char *s)
Definition: reader.cpp:989
yy_init_buffer
#define yy_init_buffer
Definition: reader.cpp:14
YY_CHAR
flex_uint8_t YY_CHAR
Definition: reader.cpp:588
yyensure_buffer_stack
#define yyensure_buffer_stack
Definition: reader.cpp:20
yy_init
static int yy_init
Definition: reader.cpp:534
flex_int16_t
short int flex_int16_t
Definition: loader.c:51
yyget_text
#define yyget_text
Definition: reader.cpp:201
yylex
#define yylex
Definition: reader.cpp:24
yy_buffer_state::yy_fill_buffer
int yy_fill_buffer
Definition: loader.c:227
yyget_lineno
#define yyget_lineno
Definition: reader.cpp:207
navar-midane_pickup.msg
list msg
Definition: navar-midane_pickup.py:13
yyget_in
#define yyget_in
Definition: reader.cpp:171
Ice.b
b
Definition: Ice.py:48
yyset_extra
#define yyset_extra
Definition: reader.cpp:165
yy_buffer_state::yy_buf_size
int yy_buf_size
Definition: loader.c:195
yy_buffer_state::yy_ch_buf
char * yy_ch_buf
Definition: loader.c:189
yy_get_previous_state
static yy_state_type yy_get_previous_state(void)
Definition: reader.cpp:1765
yy_flush_buffer
#define yy_flush_buffer
Definition: reader.cpp:15
yy_create_buffer
#define yy_create_buffer
Definition: reader.cpp:9
yy_cp
char * yy_cp
Definition: reader.cpp:1189
yywrap
#define yywrap
Definition: reader.cpp:29
yy_state_type
int yy_state_type
Definition: reader.cpp:592
flex_uint8_t
unsigned char flex_uint8_t
Definition: loader.c:53
yy_load_buffer_state
#define yy_load_buffer_state
Definition: reader.cpp:16
yyalloc
#define yyalloc
Definition: reader.cpp:30
yy_hold_char
static char yy_hold_char
Definition: reader.cpp:528
yy_ec
static const YY_CHAR yy_ec[256]
Definition: reader.cpp:672
MAX_BUF
#define MAX_BUF
Definition: define.h:35
YY_BUFFER_NORMAL
#define YY_BUFFER_NORMAL
Definition: reader.cpp:492
yy_get_next_buffer
static int yy_get_next_buffer(void)
Definition: reader.cpp:1627
yyset_lineno
#define yyset_lineno
Definition: reader.cpp:213
YY_BUFFER_NEW
#define YY_BUFFER_NEW
Definition: reader.cpp:491
yy_base
static const flex_int16_t yy_base[427]
Definition: reader.cpp:712
YY_CURRENT_BUFFER
#define YY_CURRENT_BUFFER
Definition: reader.cpp:519
yy_buffer_state::yy_buffer_status
int yy_buffer_status
Definition: loader.c:229
yy_buffer_stack
static YY_BUFFER_STATE * yy_buffer_stack
Definition: reader.cpp:511
yy_buffer_state::yy_buf_pos
char * yy_buf_pos
Definition: loader.c:190
yy_trans_info::yy_nxt
flex_int32_t yy_nxt
Definition: loader.c:364
FVAL
#define FVAL
Definition: reader.cpp:981
YY_START
#define YY_START
Definition: reader.cpp:382
yy_chk
static const flex_int16_t yy_chk[465]
Definition: reader.cpp:869
newserver.h
LO_LINEMODE
#define LO_LINEMODE
Definition: loader.h:16
yy_trans_info::yy_verify
flex_int32_t yy_verify
Definition: loader.c:363
YY_DO_BEFORE_ACTION
#define YY_DO_BEFORE_ACTION
Definition: reader.cpp:611
yy_buffer_state::yy_bs_column
int yy_bs_column
Definition: loader.c:222
yy_c_buf_p
static char * yy_c_buf_p
Definition: reader.cpp:533
YY_BREAK
#define YY_BREAK
Definition: reader.cpp:1175
yy_buffer_state::yy_n_chars
int yy_n_chars
Definition: loader.c:200
convert.dest
dest
Definition: convert.py:25
yy_last_accepting_cpos
static char * yy_last_accepting_cpos
Definition: reader.cpp:925
yy_buffer_state::yy_is_interactive
int yy_is_interactive
Definition: loader.c:213
YY_NEW_FILE
#define YY_NEW_FILE
Definition: reader.cpp:387
yypop_buffer_state
#define yypop_buffer_state
Definition: reader.cpp:19
yy_meta
static const YY_CHAR yy_meta[33]
Definition: reader.cpp:704
YY_SC_TO_UI
#define YY_SC_TO_UI(c)
Definition: reader.cpp:371
yytext_ptr
#define yytext_ptr
Definition: reader.cpp:601
make_face_from_files.int
int
Definition: make_face_from_files.py:26
loader.h
YY_READ_BUF_SIZE
#define YY_READ_BUF_SIZE
Definition: reader.cpp:1087
yyfree
#define yyfree
Definition: reader.cpp:32
yy_start
static int yy_start
Definition: reader.cpp:535
IVAL
#define IVAL
Definition: reader.cpp:980
YY_STATE_EOF
#define YY_STATE_EOF(state)
Definition: reader.cpp:385
YY_INPUT
#define YY_INPUT(buf, result, max_size)
Definition: reader.cpp:1103
LL_NORMAL
#define LL_NORMAL
Definition: loader.h:12
yy_n_chars
static int yy_n_chars
Definition: reader.cpp:529
rmap_yval
static char * rmap_yval(void)
Definition: reader.cpp:2465
YY_CURRENT_BUFFER_LVALUE
#define YY_CURRENT_BUFFER_LVALUE
Definition: reader.cpp:525
set_random_map_variable
int set_random_map_variable(RMParms *rp, const char *buf)
Definition: reader.cpp:2510
yy_nxt
static const flex_int16_t yy_nxt[465]
Definition: reader.cpp:814
yypush_buffer_state
#define yypush_buffer_state
Definition: reader.cpp:18
yy_did_buffer_switch_on_eof
static int yy_did_buffer_switch_on_eof
Definition: reader.cpp:540
yyrealloc
#define yyrealloc
Definition: reader.cpp:31
flex_int32_t
int flex_int32_t
Definition: reader.cpp:312
YY_FATAL_ERROR
#define YY_FATAL_ERROR(msg)
Definition: reader.cpp:1150
yy_fatal_error
static void yynoreturn yy_fatal_error(const char *msg)
Definition: reader.cpp:2254
EOB_ACT_LAST_MATCH
#define EOB_ACT_LAST_MATCH
Definition: reader.cpp:423
yy_buffer_stack_top
static size_t yy_buffer_stack_top
Definition: reader.cpp:509
yy_def
static const flex_int16_t yy_def[427]
Definition: reader.cpp:763
yy_init_globals
static int yy_init_globals(void)
Definition: reader.cpp:2357
yy_buffer_state::yy_bs_lineno
int yy_bs_lineno
Definition: loader.c:221
yylineno
#define yylineno
Definition: reader.cpp:25
YY_BUF_SIZE
#define YY_BUF_SIZE
Definition: reader.cpp:399
flex_int8_t
signed char flex_int8_t
Definition: reader.cpp:310
flex_int16_t
short int flex_int16_t
Definition: reader.cpp:311
yyin
#define yyin
Definition: reader.cpp:22
EOB_ACT_END_OF_FILE
#define EOB_ACT_END_OF_FILE
Definition: reader.cpp:422
LL_EOF
#define LL_EOF
Definition: loader.h:10
yyset_out
#define yyset_out
Definition: reader.cpp:189