/[svn]/hopm/branches/1.0.x/src/config-lexer.c
ViewVC logotype

Contents of /hopm/branches/1.0.x/src/config-lexer.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 5174 - (show annotations)
Fri Dec 26 21:08:42 2014 UTC (4 years, 10 months ago) by michael
File MIME type: text/x-chdr
File size: 71619 byte(s)
- Removed now unused inet.c and inet.h

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

Properties

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

svnadmin@ircd-hybrid.org
ViewVC Help
Powered by ViewVC 1.1.26