ViewVC Help
View File | Revision Log | Show Annotations | View Changeset | Root Listing
root/svn/hopm/trunk/src/config-lexer.c
Revision: 5405
Committed: Tue Jan 20 19:14:40 2015 UTC (9 years, 2 months ago) by michael
Content type: text/x-csrc
File size: 72722 byte(s)
Log Message:
- Added irc::notice configuration option (notice(s) to send to a newly connected client).

File Contents

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

Properties

Name Value
svn:eol-style native
svn:keywords Id