/[svn]/hopm/trunk/src/config-lexer.c
ViewVC logotype

Contents of /hopm/trunk/src/config-lexer.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 5135 - (show annotations)
Thu Dec 25 18:51:51 2014 UTC (5 years, 5 months ago) by michael
File MIME type: text/x-chdr
File size: 71638 byte(s)
- propset svn:eol-style native

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

Properties

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

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