Debian Codegraph @

src/config_file_lex.c

raw
1
2 #line 3 "config_file_lex.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 6
11 #define YY_FLEX_SUBMINOR_VERSION 4
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 #ifndef SIZE_MAX
87 #define SIZE_MAX (~(size_t)0)
88 #endif
89
90 #endif /* ! C99 */
91
92 #endif /* ! FLEXINT_H */
93
94 /* begin standard C++ headers. */
95
96 /* TODO: this is always defined, so inline it */
97 #define yyconst const
98
99 #if defined(__GNUC__) && __GNUC__ >= 3
100 #define yynoreturn __attribute__((__noreturn__))
101 #else
102 #define yynoreturn
103 #endif
104
105 /* Returned upon end-of-file. */
106 #define YY_NULL 0
107
108 /* Promotes a possibly negative, possibly signed char to an
109 * integer in range [0..255] for use as an array index.
110 */
111 #define YY_SC_TO_UI(c) ((YY_CHAR) (c))
112
113 /* Enter a start condition. This macro really ought to take a parameter,
114 * but we do it the disgusting crufty way forced on us by the ()-less
115 * definition of BEGIN.
116 */
117 #define BEGIN (yy_start) = 1 + 2 *
118 /* Translate the current start state into a value that can be later handed
119 * to BEGIN to return to the state. The YYSTATE alias is for lex
120 * compatibility.
121 */
122 #define YY_START (((yy_start) - 1) / 2)
123 #define YYSTATE YY_START
124 /* Action number for EOF rule of a given start state. */
125 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
126 /* Special action meaning "start processing a new file". */
127 #define YY_NEW_FILE yyrestart( yyin )
128 #define YY_END_OF_BUFFER_CHAR 0
129
130 /* Size of default input buffer. */
131 #ifndef YY_BUF_SIZE
132 #ifdef __ia64__
133 /* On IA-64, the buffer size is 16k, not 8k.
134 * Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
135 * Ditto for the __ia64__ case accordingly.
136 */
137 #define YY_BUF_SIZE 32768
138 #else
139 #define YY_BUF_SIZE 16384
140 #endif /* __ia64__ */
141 #endif
142
143 /* The state buf must be large enough to hold one state per character in the main buffer.
144 */
145 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
146
147 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
148 #define YY_TYPEDEF_YY_BUFFER_STATE
149 typedef struct yy_buffer_state *YY_BUFFER_STATE;
150 #endif
151
152 #ifndef YY_TYPEDEF_YY_SIZE_T
153 #define YY_TYPEDEF_YY_SIZE_T
154 typedef size_t yy_size_t;
155 #endif
156
157 extern int yyleng;
158
159 extern FILE *yyin, *yyout;
160
161 #define EOB_ACT_CONTINUE_SCAN 0
162 #define EOB_ACT_END_OF_FILE 1
163 #define EOB_ACT_LAST_MATCH 2
164
165 #define YY_LESS_LINENO(n)
166 #define YY_LINENO_REWIND_TO(ptr)
167
168 /* Return all but the first "n" matched characters back to the input stream. */
169 #define yyless(n) \
170 do \
171 { \
172 /* Undo effects of setting up yytext. */ \
173 int yyless_macro_arg = (n); \
174 YY_LESS_LINENO(yyless_macro_arg);\
175 *yy_cp = (yy_hold_char); \
176 YY_RESTORE_YY_MORE_OFFSET \
177 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
178 YY_DO_BEFORE_ACTION; /* set up yytext again */ \
179 } \
180 while ( 0 )
181 #define unput(c) yyunput( c, (yytext_ptr) )
182
183 #ifndef YY_STRUCT_YY_BUFFER_STATE
184 #define YY_STRUCT_YY_BUFFER_STATE
185 struct yy_buffer_state
186 {
187 FILE *yy_input_file;
188
189 char *yy_ch_buf; /* input buffer */
190 char *yy_buf_pos; /* current position in input buffer */
191
192 /* Size of input buffer in bytes, not including room for EOB
193 * characters.
194 */
195 int yy_buf_size;
196
197 /* Number of characters read into yy_ch_buf, not including EOB
198 * characters.
199 */
200 int yy_n_chars;
201
202 /* Whether we "own" the buffer - i.e., we know we created it,
203 * and can realloc() it to grow it, and should free() it to
204 * delete it.
205 */
206 int yy_is_our_buffer;
207
208 /* Whether this is an "interactive" input source; if so, and
209 * if we're using stdio for input, then we want to use getc()
210 * instead of fread(), to make sure we stop fetching input after
211 * each newline.
212 */
213 int yy_is_interactive;
214
215 /* Whether we're considered to be at the beginning of a line.
216 * If so, '^' rules will be active on the next match, otherwise
217 * not.
218 */
219 int yy_at_bol;
220
221 int yy_bs_lineno; /**< The line count. */
222 int yy_bs_column; /**< The column count. */
223
224 /* Whether to try to fill the input buffer when we reach the
225 * end of it.
226 */
227 int yy_fill_buffer;
228
229 int yy_buffer_status;
230
231 #define YY_BUFFER_NEW 0
232 #define YY_BUFFER_NORMAL 1
233 /* When an EOF's been seen but there's still some text to process
234 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
235 * shouldn't try reading from the input source any more. We might
236 * still have a bunch of tokens to match, though, because of
237 * possible backing-up.
238 *
239 * When we actually see the EOF, we change the status to "new"
240 * (via yyrestart()), so that the user can continue scanning by
241 * just pointing yyin at a new input file.
242 */
243 #define YY_BUFFER_EOF_PENDING 2
244
245 };
246 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
247
248 /* Stack of input buffers. */
249 static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
250 static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
251 static YY_BUFFER_STATE * yy_buffer_stack = NULL; /**< Stack as an array. */
252
253 /* We provide macros for accessing buffer states in case in the
254 * future we want to put the buffer states in a more general
255 * "scanner state".
256 *
257 * Returns the top of the stack, or NULL.
258 */
259 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
260 ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
261 : NULL)
262 /* Same as previous macro, but useful when we know that the buffer stack is not
263 * NULL or when we need an lvalue. For internal use only.
264 */
265 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
266
267 /* yy_hold_char holds the character lost when yytext is formed. */
268 static char yy_hold_char;
269 static int yy_n_chars; /* number of characters read into yy_ch_buf */
270 int yyleng;
271
272 /* Points to current character in buffer. */
273 static char *yy_c_buf_p = NULL;
274 static int yy_init = 0; /* whether we need to initialize */
275 static int yy_start = 0; /* start state number */
276
277 /* Flag which is used to allow yywrap()'s to do buffer switches
278 * instead of setting up a fresh yyin. A bit of a hack ...
279 */
280 static int yy_did_buffer_switch_on_eof;
281
282 void yyrestart ( FILE *input_file );
283 void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer );
284 YY_BUFFER_STATE yy_create_buffer ( FILE *file, int size );
285 void yy_delete_buffer ( YY_BUFFER_STATE b );
286 void yy_flush_buffer ( YY_BUFFER_STATE b );
287 void yypush_buffer_state ( YY_BUFFER_STATE new_buffer );
288 void yypop_buffer_state ( void );
289
290 static void yyensure_buffer_stack ( void );
291 static void yy_load_buffer_state ( void );
292 static void yy_init_buffer ( YY_BUFFER_STATE b, FILE *file );
293 #define YY_FLUSH_BUFFER yy_flush_buffer( YY_CURRENT_BUFFER )
294
295 YY_BUFFER_STATE yy_scan_buffer ( char *base, yy_size_t size );
296 YY_BUFFER_STATE yy_scan_string ( const char *yy_str );
297 YY_BUFFER_STATE yy_scan_bytes ( const char *bytes, int len );
298
299 void *yyalloc ( yy_size_t );
300 void *yyrealloc ( void *, yy_size_t );
301 void yyfree ( void * );
302
303 #define yy_new_buffer yy_create_buffer
304 #define yy_set_interactive(is_interactive) \
305 { \
306 if ( ! YY_CURRENT_BUFFER ){ \
307 yyensure_buffer_stack (); \
308 YY_CURRENT_BUFFER_LVALUE = \
309 yy_create_buffer( yyin, YY_BUF_SIZE ); \
310 } \
311 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
312 }
313 #define yy_set_bol(at_bol) \
314 { \
315 if ( ! YY_CURRENT_BUFFER ){\
316 yyensure_buffer_stack (); \
317 YY_CURRENT_BUFFER_LVALUE = \
318 yy_create_buffer( yyin, YY_BUF_SIZE ); \
319 } \
320 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
321 }
322 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
323
324 /* Begin user sect3 */
325
326 #define yywrap() (/*CONSTCOND*/1)
327 #define YY_SKIP_YYWRAP
328 typedef flex_uint8_t YY_CHAR;
329
330 FILE *yyin = NULL, *yyout = NULL;
331
332 typedef int yy_state_type;
333
334 extern int yylineno;
335 int yylineno = 1;
336
337 extern char *yytext;
338 #ifdef yytext_ptr
339 #undef yytext_ptr
340 #endif
341 #define yytext_ptr yytext
342
343 static yy_state_type yy_get_previous_state ( void );
344 static yy_state_type yy_try_NUL_trans ( yy_state_type current_state );
345 static int yy_get_next_buffer ( void );
346 static void yynoreturn yy_fatal_error ( const char* msg );
347
348 /* Done after the current pattern has been matched and before the
349 * corresponding action - sets up yytext.
350 */
351 #define YY_DO_BEFORE_ACTION \
352 (yytext_ptr) = yy_bp; \
353 yyleng = (int) (yy_cp - yy_bp); \
354 (yy_hold_char) = *yy_cp; \
355 *yy_cp = '\0'; \
356 (yy_c_buf_p) = yy_cp;
357 #define YY_NUM_RULES 23
358 #define YY_END_OF_BUFFER 24
359 /* This struct is not used in this scanner,
360 but its presence is necessary. */
361 struct yy_trans_info
362 {
363 flex_int32_t yy_verify;
364 flex_int32_t yy_nxt;
365 };
366 static const flex_int16_t yy_accept[111] =
367 { 0,
368 0, 0, 24, 23, 1, 3, 23, 2, 21, 22,
369 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
370 17, 18, 1, 0, 19, 2, 21, 20, 20, 20,
371 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
372 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
373 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
374 20, 20, 12, 20, 20, 20, 20, 20, 20, 20,
375 20, 20, 9, 20, 20, 20, 14, 15, 20, 20,
376 20, 6, 20, 8, 20, 20, 20, 16, 4, 20,
377 20, 20, 20, 20, 5, 20, 20, 20, 13, 7,
378
379 20, 20, 10, 20, 20, 20, 20, 20, 11, 0
380 } ;
381
382 static const YY_CHAR yy_ec[256] =
383 { 0,
384 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
385 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
386 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
387 1, 2, 1, 4, 5, 1, 1, 1, 1, 1,
388 1, 1, 1, 1, 1, 1, 1, 6, 7, 6,
389 6, 6, 8, 6, 6, 9, 10, 1, 11, 1,
390 1, 1, 1, 1, 12, 13, 14, 15, 16, 17,
391 18, 19, 20, 15, 15, 21, 22, 23, 24, 25,
392 26, 27, 28, 29, 30, 31, 32, 33, 15, 15,
393 1, 1, 1, 1, 34, 1, 35, 36, 37, 15,
394
395 38, 39, 40, 41, 42, 15, 15, 43, 44, 45,
396 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
397 15, 15, 56, 1, 57, 1, 1, 1, 1, 1,
398 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
399 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
400 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
401 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
402 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
403 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
404 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
405
406 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
407 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
408 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
409 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
410 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
411 1, 1, 1, 1, 1
412 } ;
413
414 static const YY_CHAR yy_meta[58] =
415 { 0,
416 1, 1, 2, 1, 1, 3, 3, 3, 3, 3,
417 1, 3, 3, 3, 3, 3, 3, 3, 3, 3,
418 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
419 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
420 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
421 3, 3, 3, 3, 3, 1, 1
422 } ;
423
424 static const flex_int16_t yy_base[114] =
425 { 0,
426 0, 0, 225, 234, 221, 234, 55, 0, 54, 234,
427 0, 35, 46, 49, 52, 57, 55, 62, 50, 52,
428 234, 234, 218, 77, 234, 0, 76, 0, 71, 75,
429 79, 79, 81, 73, 73, 85, 91, 83, 96, 95,
430 89, 94, 100, 93, 209, 101, 104, 177, 97, 106,
431 93, 114, 176, 119, 111, 123, 120, 200, 119, 122,
432 129, 120, 0, 136, 133, 199, 125, 136, 146, 144,
433 199, 142, 0, 147, 148, 142, 0, 0, 141, 144,
434 154, 0, 187, 0, 156, 125, 166, 0, 0, 168,
435 77, 172, 162, 176, 0, 68, 164, 167, 0, 0,
436
437 176, 184, 0, 179, 179, 182, 181, 187, 0, 234,
438 227, 230, 67
439 } ;
440
441 static const flex_int16_t yy_def[114] =
442 { 0,
443 110, 1, 110, 110, 110, 110, 111, 112, 110, 110,
444 113, 113, 113, 113, 113, 113, 113, 113, 113, 113,
445 110, 110, 110, 111, 110, 112, 110, 113, 113, 113,
446 113, 113, 113, 113, 113, 113, 113, 113, 113, 113,
447 113, 113, 113, 113, 113, 113, 113, 113, 113, 113,
448 113, 113, 113, 113, 113, 113, 113, 113, 113, 113,
449 113, 113, 113, 113, 113, 113, 113, 113, 113, 113,
450 113, 113, 113, 113, 113, 113, 113, 113, 113, 113,
451 113, 113, 113, 113, 113, 113, 113, 113, 113, 113,
452 113, 113, 113, 113, 113, 113, 113, 113, 113, 113,
453
454 113, 113, 113, 113, 113, 113, 113, 113, 113, 0,
455 110, 110, 110
456 } ;
457
458 static const flex_int16_t yy_nxt[292] =
459 { 0,
460 4, 5, 6, 7, 8, 9, 9, 9, 9, 9,
461 10, 11, 12, 11, 11, 11, 13, 11, 11, 14,
462 15, 16, 11, 11, 11, 11, 17, 18, 11, 19,
463 11, 20, 11, 4, 11, 12, 11, 11, 13, 11,
464 11, 14, 15, 16, 11, 11, 11, 11, 17, 18,
465 11, 19, 11, 20, 11, 21, 22, 25, 25, 27,
466 27, 27, 27, 27, 29, 30, 31, 33, 35, 28,
467 36, 41, 39, 37, 100, 34, 32, 38, 40, 25,
468 25, 27, 27, 27, 27, 27, 29, 30, 31, 33,
469 42, 35, 36, 41, 39, 43, 37, 34, 32, 38,
470
471 40, 44, 45, 46, 47, 48, 49, 50, 51, 52,
472 96, 53, 42, 54, 55, 56, 57, 43, 59, 60,
473 62, 63, 64, 44, 45, 46, 47, 48, 49, 50,
474 51, 65, 52, 53, 67, 54, 55, 56, 57, 68,
475 59, 60, 62, 63, 64, 69, 70, 72, 73, 74,
476 75, 76, 77, 65, 79, 80, 67, 81, 93, 82,
477 84, 68, 85, 86, 87, 88, 89, 69, 70, 72,
478 73, 74, 75, 76, 77, 90, 79, 80, 92, 94,
479 81, 82, 84, 95, 85, 86, 87, 88, 89, 97,
480 98, 99, 101, 102, 103, 104, 91, 90, 105, 106,
481
482 92, 107, 94, 108, 109, 95, 83, 78, 71, 66,
483 61, 97, 98, 99, 101, 102, 103, 58, 104, 23,
484 105, 106, 23, 107, 110, 108, 109, 24, 24, 24,
485 26, 110, 26, 3, 110, 110, 110, 110, 110, 110,
486 110, 110, 110, 110, 110, 110, 110, 110, 110, 110,
487 110, 110, 110, 110, 110, 110, 110, 110, 110, 110,
488 110, 110, 110, 110, 110, 110, 110, 110, 110, 110,
489 110, 110, 110, 110, 110, 110, 110, 110, 110, 110,
490 110, 110, 110, 110, 110, 110, 110, 110, 110, 110,
491 110
492
493 } ;
494
495 static const flex_int16_t yy_chk[292] =
496 { 0,
497 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
498 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
499 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
500 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
501 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
502 1, 1, 1, 1, 1, 1, 1, 7, 7, 9,
503 9, 9, 9, 9, 12, 13, 14, 15, 16, 113,
504 17, 20, 19, 18, 96, 15, 14, 18, 19, 24,
505 24, 27, 27, 27, 27, 27, 12, 13, 14, 15,
506 29, 16, 17, 20, 19, 30, 18, 15, 14, 18,
507
508 19, 31, 32, 33, 34, 35, 36, 37, 38, 39,
509 91, 40, 29, 41, 42, 43, 44, 30, 46, 47,
510 49, 50, 51, 31, 32, 33, 34, 35, 36, 37,
511 38, 52, 39, 40, 54, 41, 42, 43, 44, 55,
512 46, 47, 49, 50, 51, 56, 57, 59, 60, 61,
513 62, 64, 65, 52, 67, 68, 54, 69, 86, 70,
514 72, 55, 74, 75, 76, 79, 80, 56, 57, 59,
515 60, 61, 62, 64, 65, 81, 67, 68, 85, 87,
516 69, 70, 72, 90, 74, 75, 76, 79, 80, 92,
517 93, 94, 97, 98, 101, 102, 83, 81, 104, 105,
518
519 85, 106, 87, 107, 108, 90, 71, 66, 58, 53,
520 48, 92, 93, 94, 97, 98, 101, 45, 102, 23,
521 104, 105, 5, 106, 3, 107, 108, 111, 111, 111,
522 112, 0, 112, 110, 110, 110, 110, 110, 110, 110,
523 110, 110, 110, 110, 110, 110, 110, 110, 110, 110,
524 110, 110, 110, 110, 110, 110, 110, 110, 110, 110,
525 110, 110, 110, 110, 110, 110, 110, 110, 110, 110,
526 110, 110, 110, 110, 110, 110, 110, 110, 110, 110,
527 110, 110, 110, 110, 110, 110, 110, 110, 110, 110,
528 110
529
530 } ;
531
532 static yy_state_type yy_last_accepting_state;
533 static char *yy_last_accepting_cpos;
534
535 extern int yy_flex_debug;
536 int yy_flex_debug = 0;
537
538 /* The intent behind this definition is that it'll catch
539 * any uses of REJECT which flex missed.
540 */
541 #define REJECT reject_used_but_not_detected
542 #define yymore() yymore_used_but_not_detected
543 #define YY_MORE_ADJ 0
544 #define YY_RESTORE_YY_MORE_OFFSET
545 char *yytext;
546 #line 1 "config_file_lex.l"
547 #line 2 "config_file_lex.l"
548 /**
549 * This file is part of the Detox package.
550 *
551 * Copyright (c) Doug Harple <[email protected]>
552 *
553 * For the full copyright and license information, please view the LICENSE
554 * file that was distributed with this source code.
555 */
556
557 #include "config_file_yacc.h"
558 #include "config_file.h"
559
560 int config_file_lineno = 1;
561
562 #line 563 "config_file_lex.c"
563 #line 564 "config_file_lex.c"
564
565 #define INITIAL 0
566
567 #ifndef YY_NO_UNISTD_H
568 /* Special case for "unistd.h", since it is non-ANSI. We include it way
569 * down here because we want the user's section 1 to have been scanned first.
570 * The user has a chance to override it with an option.
571 */
572 #include <unistd.h>
573 #endif
574
575 #ifndef YY_EXTRA_TYPE
576 #define YY_EXTRA_TYPE void *
577 #endif
578
579 static int yy_init_globals ( void );
580
581 /* Accessor methods to globals.
582 These are made visible to non-reentrant scanners for convenience. */
583
584 int yylex_destroy ( void );
585
586 int yyget_debug ( void );
587
588 void yyset_debug ( int debug_flag );
589
590 YY_EXTRA_TYPE yyget_extra ( void );
591
592 void yyset_extra ( YY_EXTRA_TYPE user_defined );
593
594 FILE *yyget_in ( void );
595
596 void yyset_in ( FILE * _in_str );
597
598 FILE *yyget_out ( void );
599
600 void yyset_out ( FILE * _out_str );
601
602 int yyget_leng ( void );
603
604 char *yyget_text ( void );
605
606 int yyget_lineno ( void );
607
608 void yyset_lineno ( int _line_number );
609
610 /* Macros after this point can all be overridden by user definitions in
611 * section 1.
612 */
613
614 #ifndef YY_SKIP_YYWRAP
615 #ifdef __cplusplus
616 extern "C" int yywrap ( void );
617 #else
618 extern int yywrap ( void );
619 #endif
620 #endif
621
622 #ifndef YY_NO_UNPUT
623
624 static void yyunput ( int c, char *buf_ptr );
625
626 #endif
627
628 #ifndef yytext_ptr
629 static void yy_flex_strncpy ( char *, const char *, int );
630 #endif
631
632 #ifdef YY_NEED_STRLEN
633 static int yy_flex_strlen ( const char * );
634 #endif
635
636 #ifndef YY_NO_INPUT
637 #ifdef __cplusplus
638 static int yyinput ( void );
639 #else
640 static int input ( void );
641 #endif
642
643 #endif
644
645 /* Amount of stuff to slurp up with each read. */
646 #ifndef YY_READ_BUF_SIZE
647 #ifdef __ia64__
648 /* On IA-64, the buffer size is 16k, not 8k */
649 #define YY_READ_BUF_SIZE 16384
650 #else
651 #define YY_READ_BUF_SIZE 8192
652 #endif /* __ia64__ */
653 #endif
654
655 /* Copy whatever the last rule matched to the standard output. */
656 #ifndef ECHO
657 /* This used to be an fputs(), but since the string might contain NUL's,
658 * we now use fwrite().
659 */
660 #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
661 #endif
662
663 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
664 * is returned in "result".
665 */
666 #ifndef YY_INPUT
667 #define YY_INPUT(buf,result,max_size) \
668 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
669 { \
670 int c = '*'; \
671 int n; \
672 for ( n = 0; n < max_size && \
673 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
674 buf[n] = (char) c; \
675 if ( c == '\n' ) \
676 buf[n++] = (char) c; \
677 if ( c == EOF && ferror( yyin ) ) \
678 YY_FATAL_ERROR( "input in flex scanner failed" ); \
679 result = n; \
680 } \
681 else \
682 { \
683 errno=0; \
684 while ( (result = (int) fread(buf, 1, (yy_size_t) max_size, yyin)) == 0 && ferror(yyin)) \
685 { \
686 if( errno != EINTR) \
687 { \
688 YY_FATAL_ERROR( "input in flex scanner failed" ); \
689 break; \
690 } \
691 errno=0; \
692 clearerr(yyin); \
693 } \
694 }\
695 \
696
697 #endif
698
699 /* No semi-colon after return; correct usage is to write "yyterminate();" -
700 * we don't want an extra ';' after the "return" because that will cause
701 * some compilers to complain about unreachable statements.
702 */
703 #ifndef yyterminate
704 #define yyterminate() return YY_NULL
705 #endif
706
707 /* Number of entries by which start-condition stack grows. */
708 #ifndef YY_START_STACK_INCR
709 #define YY_START_STACK_INCR 25
710 #endif
711
712 /* Report a fatal error. */
713 #ifndef YY_FATAL_ERROR
714 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
715 #endif
716
717 /* end tables serialization structures and prototypes */
718
719 /* Default declaration of generated scanner - a define so the user can
720 * easily add parameters.
721 */
722 #ifndef YY_DECL
723 #define YY_DECL_IS_OURS 1
724
725 extern int yylex (void);
726
727 #define YY_DECL int yylex (void)
728 #endif /* !YY_DECL */
729
730 /* Code executed at the beginning of each rule, after yytext and yyleng
731 * have been set up.
732 */
733 #ifndef YY_USER_ACTION
734 #define YY_USER_ACTION
735 #endif
736
737 /* Code executed at the end of each rule. */
738 #ifndef YY_BREAK
739 #define YY_BREAK /*LINTED*/break;
740 #endif
741
742 #define YY_RULE_SETUP \
743 YY_USER_ACTION
744
745 /** The main scanner function which does all the work.
746 */
747 YY_DECL
748 {
749 yy_state_type yy_current_state;
750 char *yy_cp, *yy_bp;
751 int yy_act;
752
753 if ( !(yy_init) )
754 {
755 (yy_init) = 1;
756
757 #ifdef YY_USER_INIT
758 YY_USER_INIT;
759 #endif
760
761 if ( ! (yy_start) )
762 (yy_start) = 1; /* first start state */
763
764 if ( ! yyin )
765 yyin = stdin;
766
767 if ( ! yyout )
768 yyout = stdout;
769
770 if ( ! YY_CURRENT_BUFFER ) {
771 yyensure_buffer_stack ();
772 YY_CURRENT_BUFFER_LVALUE =
773 yy_create_buffer( yyin, YY_BUF_SIZE );
774 }
775
776 yy_load_buffer_state( );
777 }
778
779 {
780 #line 20 "config_file_lex.l"
781
782
783 #line 784 "config_file_lex.c"
784
785 while ( /*CONSTCOND*/1 ) /* loops until end-of-file is reached */
786 {
787 yy_cp = (yy_c_buf_p);
788
789 /* Support of yytext. */
790 *yy_cp = (yy_hold_char);
791
792 /* yy_bp points to the position in yy_ch_buf of the start of
793 * the current run.
794 */
795 yy_bp = yy_cp;
796
797 yy_current_state = (yy_start);
798 yy_match:
799 do
800 {
801 YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
802 if ( yy_accept[yy_current_state] )
803 {
804 (yy_last_accepting_state) = yy_current_state;
805 (yy_last_accepting_cpos) = yy_cp;
806 }
807 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
808 {
809 yy_current_state = (int) yy_def[yy_current_state];
810 if ( yy_current_state >= 111 )
811 yy_c = yy_meta[yy_c];
812 }
813 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
814 ++yy_cp;
815 }
816 while ( yy_base[yy_current_state] != 234 );
817
818 yy_find_action:
819 yy_act = yy_accept[yy_current_state];
820 if ( yy_act == 0 )
821 { /* have to back up */
822 yy_cp = (yy_last_accepting_cpos);
823 yy_current_state = (yy_last_accepting_state);
824 yy_act = yy_accept[yy_current_state];
825 }
826
827 YY_DO_BEFORE_ACTION;
828
829 do_action: /* This label is used only to access EOF actions. */
830
831 switch ( yy_act )
832 { /* beginning of action switch */
833 case 0: /* must back up */
834 /* undo the effects of YY_DO_BEFORE_ACTION */
835 *yy_cp = (yy_hold_char);
836 yy_cp = (yy_last_accepting_cpos);
837 yy_current_state = (yy_last_accepting_state);
838 goto yy_find_action;
839
840 case 1:
841 YY_RULE_SETUP
842 #line 22 "config_file_lex.l"
843 { /* ignore whitespace */ }
844 YY_BREAK
845 case 2:
846 YY_RULE_SETUP
847 #line 24 "config_file_lex.l"
848 { /* ignore comments */ }
849 YY_BREAK
850 case 3:
851 /* rule 3 can match eol */
852 YY_RULE_SETUP
853 #line 26 "config_file_lex.l"
854 { config_file_lineno++; }
855 YY_BREAK
856 case 4:
857 YY_RULE_SETUP
858 #line 28 "config_file_lex.l"
859 { return BUILTIN; }
860 YY_BREAK
861 case 5:
862 YY_RULE_SETUP
863 #line 29 "config_file_lex.l"
864 { return FILENAME; }
865 YY_BREAK
866 case 6:
867 YY_RULE_SETUP
868 #line 30 "config_file_lex.l"
869 { return IGNORE; }
870 YY_BREAK
871 case 7:
872 YY_RULE_SETUP
873 #line 31 "config_file_lex.l"
874 { return ISO8859_1; }
875 YY_BREAK
876 case 8:
877 YY_RULE_SETUP
878 #line 32 "config_file_lex.l"
879 { return LENGTH; }
880 YY_BREAK
881 case 9:
882 YY_RULE_SETUP
883 #line 33 "config_file_lex.l"
884 { return LOWER; }
885 YY_BREAK
886 case 10:
887 YY_RULE_SETUP
888 #line 34 "config_file_lex.l"
889 { return MAX_LENGTH; }
890 YY_BREAK
891 case 11:
892 YY_RULE_SETUP
893 #line 35 "config_file_lex.l"
894 { return REMOVE_TRAILING; }
895 YY_BREAK
896 case 12:
897 YY_RULE_SETUP
898 #line 36 "config_file_lex.l"
899 { return SAFE; }
900 YY_BREAK
901 case 13:
902 YY_RULE_SETUP
903 #line 37 "config_file_lex.l"
904 { return SEQUENCE; }
905 YY_BREAK
906 case 14:
907 YY_RULE_SETUP
908 #line 38 "config_file_lex.l"
909 { return UNCGI; }
910 YY_BREAK
911 case 15:
912 YY_RULE_SETUP
913 #line 39 "config_file_lex.l"
914 { return UTF_8; }
915 YY_BREAK
916 case 16:
917 YY_RULE_SETUP
918 #line 40 "config_file_lex.l"
919 { return WIPEUP; }
920 YY_BREAK
921 case 17:
922 YY_RULE_SETUP
923 #line 42 "config_file_lex.l"
924 { return OPEN; }
925 YY_BREAK
926 case 18:
927 YY_RULE_SETUP
928 #line 43 "config_file_lex.l"
929 { return CLOSE; }
930 YY_BREAK
931 case 19:
932 /* rule 19 can match eol */
933 YY_RULE_SETUP
934 #line 45 "config_file_lex.l"
935 {
936 yylval.string = strdup(yytext+1);
937 if (yylval.string[yyleng-2] != '"') {
938 printf("Unterminated character string\n");
939 }
940 else {
941 yylval.string[yyleng-2] = '\0';
942 }
943 return QSTRING;
944 }
945 YY_BREAK
946 case 20:
947 YY_RULE_SETUP
948 #line 56 "config_file_lex.l"
949 {
950 yylval.string = strdup(yytext);
951 return ID;
952 }
953 YY_BREAK
954 case 21:
955 YY_RULE_SETUP
956 #line 61 "config_file_lex.l"
957 {
958 yylval.nvalue = atoi(yytext);
959 return NVALUE;
960 }
961 YY_BREAK
962 case 22:
963 YY_RULE_SETUP
964 #line 66 "config_file_lex.l"
965 { return EOL; }
966 YY_BREAK
967 case 23:
968 YY_RULE_SETUP
969 #line 68 "config_file_lex.l"
970 ECHO;
971 YY_BREAK
972 #line 973 "config_file_lex.c"
973 case YY_STATE_EOF(INITIAL):
974 yyterminate();
975
976 case YY_END_OF_BUFFER:
977 {
978 /* Amount of text matched not including the EOB char. */
979 int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
980
981 /* Undo the effects of YY_DO_BEFORE_ACTION. */
982 *yy_cp = (yy_hold_char);
983 YY_RESTORE_YY_MORE_OFFSET
984
985 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
986 {
987 /* We're scanning a new file or input source. It's
988 * possible that this happened because the user
989 * just pointed yyin at a new source and called
990 * yylex(). If so, then we have to assure
991 * consistency between YY_CURRENT_BUFFER and our
992 * globals. Here is the right place to do so, because
993 * this is the first action (other than possibly a
994 * back-up) that will match for the new input source.
995 */
996 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
997 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
998 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
999 }
1000
1001 /* Note that here we test for yy_c_buf_p "<=" to the position
1002 * of the first EOB in the buffer, since yy_c_buf_p will
1003 * already have been incremented past the NUL character
1004 * (since all states make transitions on EOB to the
1005 * end-of-buffer state). Contrast this with the test
1006 * in input().
1007 */
1008 if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1009 { /* This was really a NUL. */
1010 yy_state_type yy_next_state;
1011
1012 (yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
1013
1014 yy_current_state = yy_get_previous_state( );
1015
1016 /* Okay, we're now positioned to make the NUL
1017 * transition. We couldn't have
1018 * yy_get_previous_state() go ahead and do it
1019 * for us because it doesn't know how to deal
1020 * with the possibility of jamming (and we don't
1021 * want to build jamming into it because then it
1022 * will run more slowly).
1023 */
1024
1025 yy_next_state = yy_try_NUL_trans( yy_current_state );
1026
1027 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1028
1029 if ( yy_next_state )
1030 {
1031 /* Consume the NUL. */
1032 yy_cp = ++(yy_c_buf_p);
1033 yy_current_state = yy_next_state;
1034 goto yy_match;
1035 }
1036
1037 else
1038 {
1039 yy_cp = (yy_c_buf_p);
1040 goto yy_find_action;
1041 }
1042 }
1043
1044 else switch ( yy_get_next_buffer( ) )
1045 {
1046 case EOB_ACT_END_OF_FILE:
1047 {
1048 (yy_did_buffer_switch_on_eof) = 0;
1049
1050 if ( yywrap( ) )
1051 {
1052 /* Note: because we've taken care in
1053 * yy_get_next_buffer() to have set up
1054 * yytext, we can now set up
1055 * yy_c_buf_p so that if some total
1056 * hoser (like flex itself) wants to
1057 * call the scanner after we return the
1058 * YY_NULL, it'll still work - another
1059 * YY_NULL will get returned.
1060 */
1061 (yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
1062
1063 yy_act = YY_STATE_EOF(YY_START);
1064 goto do_action;
1065 }
1066
1067 else
1068 {
1069 if ( ! (yy_did_buffer_switch_on_eof) )
1070 YY_NEW_FILE;
1071 }
1072 break;
1073 }
1074
1075 case EOB_ACT_CONTINUE_SCAN:
1076 (yy_c_buf_p) =
1077 (yytext_ptr) + yy_amount_of_matched_text;
1078
1079 yy_current_state = yy_get_previous_state( );
1080
1081 yy_cp = (yy_c_buf_p);
1082 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1083 goto yy_match;
1084
1085 case EOB_ACT_LAST_MATCH:
1086 (yy_c_buf_p) =
1087 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
1088
1089 yy_current_state = yy_get_previous_state( );
1090
1091 yy_cp = (yy_c_buf_p);
1092 yy_bp = (yytext_ptr) + YY_MORE_ADJ;
1093 goto yy_find_action;
1094 }
1095 break;
1096 }
1097
1098 default:
1099 YY_FATAL_ERROR(
1100 "fatal flex scanner internal error--no action found" );
1101 } /* end of action switch */
1102 } /* end of scanning one token */
1103 } /* end of user's declarations */
1104 } /* end of yylex */
1105
1106 /* yy_get_next_buffer - try to read in a new buffer
1107 *
1108 * Returns a code representing an action:
1109 * EOB_ACT_LAST_MATCH -
1110 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1111 * EOB_ACT_END_OF_FILE - end of file
1112 */
1113 static int yy_get_next_buffer (void)
1114 {
1115 char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1116 char *source = (yytext_ptr);
1117 int number_to_move, i;
1118 int ret_val;
1119
1120 if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
1121 YY_FATAL_ERROR(
1122 "fatal flex scanner internal error--end of buffer missed" );
1123
1124 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1125 { /* Don't try to fill the buffer, so this is an EOF. */
1126 if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
1127 {
1128 /* We matched a single character, the EOB, so
1129 * treat this as a final EOF.
1130 */
1131 return EOB_ACT_END_OF_FILE;
1132 }
1133
1134 else
1135 {
1136 /* We matched some text prior to the EOB, first
1137 * process it.
1138 */
1139 return EOB_ACT_LAST_MATCH;
1140 }
1141 }
1142
1143 /* Try to read more data. */
1144
1145 /* First move last chars to start of buffer. */
1146 number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr) - 1);
1147
1148 for ( i = 0; i < number_to_move; ++i )
1149 *(dest++) = *(source++);
1150
1151 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1152 /* don't do the read, it's not guaranteed to return an EOF,
1153 * just force an EOF
1154 */
1155 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1156
1157 else
1158 {
1159 int num_to_read =
1160 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1161
1162 while ( num_to_read <= 0 )
1163 { /* Not enough room in the buffer - grow it. */
1164
1165 /* just a shorter name for the current buffer */
1166 YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
1167
1168 int yy_c_buf_p_offset =
1169 (int) ((yy_c_buf_p) - b->yy_ch_buf);
1170
1171 if ( b->yy_is_our_buffer )
1172 {
1173 int new_size = b->yy_buf_size * 2;
1174
1175 if ( new_size <= 0 )
1176 b->yy_buf_size += b->yy_buf_size / 8;
1177 else
1178 b->yy_buf_size *= 2;
1179
1180 b->yy_ch_buf = (char *)
1181 /* Include room in for 2 EOB chars. */
1182 yyrealloc( (void *) b->yy_ch_buf,
1183 (yy_size_t) (b->yy_buf_size + 2) );
1184 }
1185 else
1186 /* Can't grow it, we don't own it. */
1187 b->yy_ch_buf = NULL;
1188
1189 if ( ! b->yy_ch_buf )
1190 YY_FATAL_ERROR(
1191 "fatal error - scanner input buffer overflow" );
1192
1193 (yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1194
1195 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1196 number_to_move - 1;
1197
1198 }
1199
1200 if ( num_to_read > YY_READ_BUF_SIZE )
1201 num_to_read = YY_READ_BUF_SIZE;
1202
1203 /* Read in more data. */
1204 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1205 (yy_n_chars), num_to_read );
1206
1207 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1208 }
1209
1210 if ( (yy_n_chars) == 0 )
1211 {
1212 if ( number_to_move == YY_MORE_ADJ )
1213 {
1214 ret_val = EOB_ACT_END_OF_FILE;
1215 yyrestart( yyin );
1216 }
1217
1218 else
1219 {
1220 ret_val = EOB_ACT_LAST_MATCH;
1221 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1222 YY_BUFFER_EOF_PENDING;
1223 }
1224 }
1225
1226 else
1227 ret_val = EOB_ACT_CONTINUE_SCAN;
1228
1229 if (((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1230 /* Extend the array by 50%, plus the number we really need. */
1231 int new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1232 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) yyrealloc(
1233 (void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf, (yy_size_t) new_size );
1234 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1235 YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1236 /* "- 2" to take care of EOB's */
1237 YY_CURRENT_BUFFER_LVALUE->yy_buf_size = (int) (new_size - 2);
1238 }
1239
1240 (yy_n_chars) += number_to_move;
1241 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1242 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1243
1244 (yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1245
1246 return ret_val;
1247 }
1248
1249 /* yy_get_previous_state - get the state just before the EOB char was reached */
1250
1251 static yy_state_type yy_get_previous_state (void)
1252 {
1253 yy_state_type yy_current_state;
1254 char *yy_cp;
1255
1256 yy_current_state = (yy_start);
1257
1258 for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1259 {
1260 YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1261 if ( yy_accept[yy_current_state] )
1262 {
1263 (yy_last_accepting_state) = yy_current_state;
1264 (yy_last_accepting_cpos) = yy_cp;
1265 }
1266 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1267 {
1268 yy_current_state = (int) yy_def[yy_current_state];
1269 if ( yy_current_state >= 111 )
1270 yy_c = yy_meta[yy_c];
1271 }
1272 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1273 }
1274
1275 return yy_current_state;
1276 }
1277
1278 /* yy_try_NUL_trans - try to make a transition on the NUL character
1279 *
1280 * synopsis
1281 * next_state = yy_try_NUL_trans( current_state );
1282 */
1283 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
1284 {
1285 int yy_is_jam;
1286 char *yy_cp = (yy_c_buf_p);
1287
1288 YY_CHAR yy_c = 1;
1289 if ( yy_accept[yy_current_state] )
1290 {
1291 (yy_last_accepting_state) = yy_current_state;
1292 (yy_last_accepting_cpos) = yy_cp;
1293 }
1294 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1295 {
1296 yy_current_state = (int) yy_def[yy_current_state];
1297 if ( yy_current_state >= 111 )
1298 yy_c = yy_meta[yy_c];
1299 }
1300 yy_current_state = yy_nxt[yy_base[yy_current_state] + yy_c];
1301 yy_is_jam = (yy_current_state == 110);
1302
1303 return yy_is_jam ? 0 : yy_current_state;
1304 }
1305
1306 #ifndef YY_NO_UNPUT
1307
1308 static void yyunput (int c, char * yy_bp )
1309 {
1310 char *yy_cp;
1311
1312 yy_cp = (yy_c_buf_p);
1313
1314 /* undo effects of setting up yytext */
1315 *yy_cp = (yy_hold_char);
1316
1317 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1318 { /* need to shift things up to make room */
1319 /* +2 for EOB chars. */
1320 int number_to_move = (yy_n_chars) + 2;
1321 char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1322 YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1323 char *source =
1324 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1325
1326 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1327 *--dest = *--source;
1328
1329 yy_cp += (int) (dest - source);
1330 yy_bp += (int) (dest - source);
1331 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1332 (yy_n_chars) = (int) YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1333
1334 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1335 YY_FATAL_ERROR( "flex scanner push-back overflow" );
1336 }
1337
1338 *--yy_cp = (char) c;
1339
1340 (yytext_ptr) = yy_bp;
1341 (yy_hold_char) = *yy_cp;
1342 (yy_c_buf_p) = yy_cp;
1343 }
1344
1345 #endif
1346
1347 #ifndef YY_NO_INPUT
1348 #ifdef __cplusplus
1349 static int yyinput (void)
1350 #else
1351 static int input (void)
1352 #endif
1353
1354 {
1355 int c;
1356
1357 *(yy_c_buf_p) = (yy_hold_char);
1358
1359 if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1360 {
1361 /* yy_c_buf_p now points to the character we want to return.
1362 * If this occurs *before* the EOB characters, then it's a
1363 * valid NUL; if not, then we've hit the end of the buffer.
1364 */
1365 if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1366 /* This was really a NUL. */
1367 *(yy_c_buf_p) = '\0';
1368
1369 else
1370 { /* need more input */
1371 int offset = (int) ((yy_c_buf_p) - (yytext_ptr));
1372 ++(yy_c_buf_p);
1373
1374 switch ( yy_get_next_buffer( ) )
1375 {
1376 case EOB_ACT_LAST_MATCH:
1377 /* This happens because yy_g_n_b()
1378 * sees that we've accumulated a
1379 * token and flags that we need to
1380 * try matching the token before
1381 * proceeding. But for input(),
1382 * there's no matching to consider.
1383 * So convert the EOB_ACT_LAST_MATCH
1384 * to EOB_ACT_END_OF_FILE.
1385 */
1386
1387 /* Reset buffer status. */
1388 yyrestart( yyin );
1389
1390 /*FALLTHROUGH*/
1391
1392 case EOB_ACT_END_OF_FILE:
1393 {
1394 if ( yywrap( ) )
1395 return 0;
1396
1397 if ( ! (yy_did_buffer_switch_on_eof) )
1398 YY_NEW_FILE;
1399 #ifdef __cplusplus
1400 return yyinput();
1401 #else
1402 return input();
1403 #endif
1404 }
1405
1406 case EOB_ACT_CONTINUE_SCAN:
1407 (yy_c_buf_p) = (yytext_ptr) + offset;
1408 break;
1409 }
1410 }
1411 }
1412
1413 c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
1414 *(yy_c_buf_p) = '\0'; /* preserve yytext */
1415 (yy_hold_char) = *++(yy_c_buf_p);
1416
1417 return c;
1418 }
1419 #endif /* ifndef YY_NO_INPUT */
1420
1421 /** Immediately switch to a different input stream.
1422 * @param input_file A readable stream.
1423 *
1424 * @note This function does not reset the start condition to @c INITIAL .
1425 */
1426 void yyrestart (FILE * input_file )
1427 {
1428
1429 if ( ! YY_CURRENT_BUFFER ){
1430 yyensure_buffer_stack ();
1431 YY_CURRENT_BUFFER_LVALUE =
1432 yy_create_buffer( yyin, YY_BUF_SIZE );
1433 }
1434
1435 yy_init_buffer( YY_CURRENT_BUFFER, input_file );
1436 yy_load_buffer_state( );
1437 }
1438
1439 /** Switch to a different input buffer.
1440 * @param new_buffer The new input buffer.
1441 *
1442 */
1443 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer )
1444 {
1445
1446 /* TODO. We should be able to replace this entire function body
1447 * with
1448 * yypop_buffer_state();
1449 * yypush_buffer_state(new_buffer);
1450 */
1451 yyensure_buffer_stack ();
1452 if ( YY_CURRENT_BUFFER == new_buffer )
1453 return;
1454
1455 if ( YY_CURRENT_BUFFER )
1456 {
1457 /* Flush out information for old buffer. */
1458 *(yy_c_buf_p) = (yy_hold_char);
1459 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1460 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1461 }
1462
1463 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1464 yy_load_buffer_state( );
1465
1466 /* We don't actually know whether we did this switch during
1467 * EOF (yywrap()) processing, but the only time this flag
1468 * is looked at is after yywrap() is called, so it's safe
1469 * to go ahead and always set it.
1470 */
1471 (yy_did_buffer_switch_on_eof) = 1;
1472 }
1473
1474 static void yy_load_buffer_state (void)
1475 {
1476 (yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1477 (yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1478 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1479 (yy_hold_char) = *(yy_c_buf_p);
1480 }
1481
1482 /** Allocate and initialize an input buffer state.
1483 * @param file A readable stream.
1484 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1485 *
1486 * @return the allocated buffer state.
1487 */
1488 YY_BUFFER_STATE yy_create_buffer (FILE * file, int size )
1489 {
1490 YY_BUFFER_STATE b;
1491
1492 b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
1493 if ( ! b )
1494 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1495
1496 b->yy_buf_size = size;
1497
1498 /* yy_ch_buf has to be 2 characters longer than the size given because
1499 * we need to put in 2 end-of-buffer characters.
1500 */
1501 b->yy_ch_buf = (char *) yyalloc( (yy_size_t) (b->yy_buf_size + 2) );
1502 if ( ! b->yy_ch_buf )
1503 YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
1504
1505 b->yy_is_our_buffer = 1;
1506
1507 yy_init_buffer( b, file );
1508
1509 return b;
1510 }
1511
1512 /** Destroy the buffer.
1513 * @param b a buffer created with yy_create_buffer()
1514 *
1515 */
1516 void yy_delete_buffer (YY_BUFFER_STATE b )
1517 {
1518
1519 if ( ! b )
1520 return;
1521
1522 if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1523 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1524
1525 if ( b->yy_is_our_buffer )
1526 yyfree( (void *) b->yy_ch_buf );
1527
1528 yyfree( (void *) b );
1529 }
1530
1531 /* Initializes or reinitializes a buffer.
1532 * This function is sometimes called more than once on the same buffer,
1533 * such as during a yyrestart() or at EOF.
1534 */
1535 static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file )
1536
1537 {
1538 int oerrno = errno;
1539
1540 yy_flush_buffer( b );
1541
1542 b->yy_input_file = file;
1543 b->yy_fill_buffer = 1;
1544
1545 /* If b is the current buffer, then yy_init_buffer was _probably_
1546 * called from yyrestart() or through yy_get_next_buffer.
1547 * In that case, we don't want to reset the lineno or column.
1548 */
1549 if (b != YY_CURRENT_BUFFER){
1550 b->yy_bs_lineno = 1;
1551 b->yy_bs_column = 0;
1552 }
1553
1554 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1555
1556 errno = oerrno;
1557 }
1558
1559 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1560 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1561 *
1562 */
1563 void yy_flush_buffer (YY_BUFFER_STATE b )
1564 {
1565 if ( ! b )
1566 return;
1567
1568 b->yy_n_chars = 0;
1569
1570 /* We always need two end-of-buffer characters. The first causes
1571 * a transition to the end-of-buffer state. The second causes
1572 * a jam in that state.
1573 */
1574 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1575 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1576
1577 b->yy_buf_pos = &b->yy_ch_buf[0];
1578
1579 b->yy_at_bol = 1;
1580 b->yy_buffer_status = YY_BUFFER_NEW;
1581
1582 if ( b == YY_CURRENT_BUFFER )
1583 yy_load_buffer_state( );
1584 }
1585
1586 /** Pushes the new state onto the stack. The new state becomes
1587 * the current state. This function will allocate the stack
1588 * if necessary.
1589 * @param new_buffer The new state.
1590 *
1591 */
1592 void yypush_buffer_state (YY_BUFFER_STATE new_buffer )
1593 {
1594 if (new_buffer == NULL)
1595 return;
1596
1597 yyensure_buffer_stack();
1598
1599 /* This block is copied from yy_switch_to_buffer. */
1600 if ( YY_CURRENT_BUFFER )
1601 {
1602 /* Flush out information for old buffer. */
1603 *(yy_c_buf_p) = (yy_hold_char);
1604 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1605 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1606 }
1607
1608 /* Only push if top exists. Otherwise, replace top. */
1609 if (YY_CURRENT_BUFFER)
1610 (yy_buffer_stack_top)++;
1611 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1612
1613 /* copied from yy_switch_to_buffer. */
1614 yy_load_buffer_state( );
1615 (yy_did_buffer_switch_on_eof) = 1;
1616 }
1617
1618 /** Removes and deletes the top of the stack, if present.
1619 * The next element becomes the new top.
1620 *
1621 */
1622 void yypop_buffer_state (void)
1623 {
1624 if (!YY_CURRENT_BUFFER)
1625 return;
1626
1627 yy_delete_buffer(YY_CURRENT_BUFFER );
1628 YY_CURRENT_BUFFER_LVALUE = NULL;
1629 if ((yy_buffer_stack_top) > 0)
1630 --(yy_buffer_stack_top);
1631
1632 if (YY_CURRENT_BUFFER) {
1633 yy_load_buffer_state( );
1634 (yy_did_buffer_switch_on_eof) = 1;
1635 }
1636 }
1637
1638 /* Allocates the stack if it does not exist.
1639 * Guarantees space for at least one push.
1640 */
1641 static void yyensure_buffer_stack (void)
1642 {
1643 yy_size_t num_to_alloc;
1644
1645 if (!(yy_buffer_stack)) {
1646
1647 /* First allocation is just for 2 elements, since we don't know if this
1648 * scanner will even need a stack. We use 2 instead of 1 to avoid an
1649 * immediate realloc on the next call.
1650 */
1651 num_to_alloc = 1; /* After all that talk, this was set to 1 anyways... */
1652 (yy_buffer_stack) = (struct yy_buffer_state**)yyalloc
1653 (num_to_alloc * sizeof(struct yy_buffer_state*)
1654 );
1655 if ( ! (yy_buffer_stack) )
1656 YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1657
1658 memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1659
1660 (yy_buffer_stack_max) = num_to_alloc;
1661 (yy_buffer_stack_top) = 0;
1662 return;
1663 }
1664
1665 if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1666
1667 /* Increase the buffer to prepare for a possible push. */
1668 yy_size_t grow_size = 8 /* arbitrary grow size */;
1669
1670 num_to_alloc = (yy_buffer_stack_max) + grow_size;
1671 (yy_buffer_stack) = (struct yy_buffer_state**)yyrealloc
1672 ((yy_buffer_stack),
1673 num_to_alloc * sizeof(struct yy_buffer_state*)
1674 );
1675 if ( ! (yy_buffer_stack) )
1676 YY_FATAL_ERROR( "out of dynamic memory in yyensure_buffer_stack()" );
1677
1678 /* zero only the new slots.*/
1679 memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
1680 (yy_buffer_stack_max) = num_to_alloc;
1681 }
1682 }
1683
1684 /** Setup the input buffer state to scan directly from a user-specified character buffer.
1685 * @param base the character buffer
1686 * @param size the size in bytes of the character buffer
1687 *
1688 * @return the newly allocated buffer state object.
1689 */
1690 YY_BUFFER_STATE yy_scan_buffer (char * base, yy_size_t size )
1691 {
1692 YY_BUFFER_STATE b;
1693
1694 if ( size < 2 ||
1695 base[size-2] != YY_END_OF_BUFFER_CHAR ||
1696 base[size-1] != YY_END_OF_BUFFER_CHAR )
1697 /* They forgot to leave room for the EOB's. */
1698 return NULL;
1699
1700 b = (YY_BUFFER_STATE) yyalloc( sizeof( struct yy_buffer_state ) );
1701 if ( ! b )
1702 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
1703
1704 b->yy_buf_size = (int) (size - 2); /* "- 2" to take care of EOB's */
1705 b->yy_buf_pos = b->yy_ch_buf = base;
1706 b->yy_is_our_buffer = 0;
1707 b->yy_input_file = NULL;
1708 b->yy_n_chars = b->yy_buf_size;
1709 b->yy_is_interactive = 0;
1710 b->yy_at_bol = 1;
1711 b->yy_fill_buffer = 0;
1712 b->yy_buffer_status = YY_BUFFER_NEW;
1713
1714 yy_switch_to_buffer( b );
1715
1716 return b;
1717 }
1718
1719 /** Setup the input buffer state to scan a string. The next call to yylex() will
1720 * scan from a @e copy of @a str.
1721 * @param yystr a NUL-terminated string to scan
1722 *
1723 * @return the newly allocated buffer state object.
1724 * @note If you want to scan bytes that may contain NUL values, then use
1725 * yy_scan_bytes() instead.
1726 */
1727 YY_BUFFER_STATE yy_scan_string (const char * yystr )
1728 {
1729
1730 return yy_scan_bytes( yystr, (int) strlen(yystr) );
1731 }
1732
1733 /** Setup the input buffer state to scan the given bytes. The next call to yylex() will
1734 * scan from a @e copy of @a bytes.
1735 * @param yybytes the byte buffer to scan
1736 * @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
1737 *
1738 * @return the newly allocated buffer state object.
1739 */
1740 YY_BUFFER_STATE yy_scan_bytes (const char * yybytes, int _yybytes_len )
1741 {
1742 YY_BUFFER_STATE b;
1743 char *buf;
1744 yy_size_t n;
1745 int i;
1746
1747 /* Get memory for full buffer, including space for trailing EOB's. */
1748 n = (yy_size_t) (_yybytes_len + 2);
1749 buf = (char *) yyalloc( n );
1750 if ( ! buf )
1751 YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
1752
1753 for ( i = 0; i < _yybytes_len; ++i )
1754 buf[i] = yybytes[i];
1755
1756 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1757
1758 b = yy_scan_buffer( buf, n );
1759 if ( ! b )
1760 YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
1761
1762 /* It's okay to grow etc. this buffer, and we should throw it
1763 * away when we're done.
1764 */
1765 b->yy_is_our_buffer = 1;
1766
1767 return b;
1768 }
1769
1770 #ifndef YY_EXIT_FAILURE
1771 #define YY_EXIT_FAILURE 2
1772 #endif
1773
1774 static void yynoreturn yy_fatal_error (const char* msg )
1775 {
1776 fprintf( stderr, "%s\n", msg );
1777 exit( YY_EXIT_FAILURE );
1778 }
1779
1780 /* Redefine yyless() so it works in section 3 code. */
1781
1782 #undef yyless
1783 #define yyless(n) \
1784 do \
1785 { \
1786 /* Undo effects of setting up yytext. */ \
1787 int yyless_macro_arg = (n); \
1788 YY_LESS_LINENO(yyless_macro_arg);\
1789 yytext[yyleng] = (yy_hold_char); \
1790 (yy_c_buf_p) = yytext + yyless_macro_arg; \
1791 (yy_hold_char) = *(yy_c_buf_p); \
1792 *(yy_c_buf_p) = '\0'; \
1793 yyleng = yyless_macro_arg; \
1794 } \
1795 while ( 0 )
1796
1797 /* Accessor methods (get/set functions) to struct members. */
1798
1799 /** Get the current line number.
1800 *
1801 */
1802 int yyget_lineno (void)
1803 {
1804
1805 return yylineno;
1806 }
1807
1808 /** Get the input stream.
1809 *
1810 */
1811 FILE *yyget_in (void)
1812 {
1813 return yyin;
1814 }
1815
1816 /** Get the output stream.
1817 *
1818 */
1819 FILE *yyget_out (void)
1820 {
1821 return yyout;
1822 }
1823
1824 /** Get the length of the current token.
1825 *
1826 */
1827 int yyget_leng (void)
1828 {
1829 return yyleng;
1830 }
1831
1832 /** Get the current token.
1833 *
1834 */
1835
1836 char *yyget_text (void)
1837 {
1838 return yytext;
1839 }
1840
1841 /** Set the current line number.
1842 * @param _line_number line number
1843 *
1844 */
1845 void yyset_lineno (int _line_number )
1846 {
1847
1848 yylineno = _line_number;
1849 }
1850
1851 /** Set the input stream. This does not discard the current
1852 * input buffer.
1853 * @param _in_str A readable stream.
1854 *
1855 * @see yy_switch_to_buffer
1856 */
1857 void yyset_in (FILE * _in_str )
1858 {
1859 yyin = _in_str ;
1860 }
1861
1862 void yyset_out (FILE * _out_str )
1863 {
1864 yyout = _out_str ;
1865 }
1866
1867 int yyget_debug (void)
1868 {
1869 return yy_flex_debug;
1870 }
1871
1872 void yyset_debug (int _bdebug )
1873 {
1874 yy_flex_debug = _bdebug ;
1875 }
1876
1877 static int yy_init_globals (void)
1878 {
1879 /* Initialization is the same as for the non-reentrant scanner.
1880 * This function is called from yylex_destroy(), so don't allocate here.
1881 */
1882
1883 (yy_buffer_stack) = NULL;
1884 (yy_buffer_stack_top) = 0;
1885 (yy_buffer_stack_max) = 0;
1886 (yy_c_buf_p) = NULL;
1887 (yy_init) = 0;
1888 (yy_start) = 0;
1889
1890 /* Defined in main.c */
1891 #ifdef YY_STDINIT
1892 yyin = stdin;
1893 yyout = stdout;
1894 #else
1895 yyin = NULL;
1896 yyout = NULL;
1897 #endif
1898
1899 /* For future reference: Set errno on error, since we are called by
1900 * yylex_init()
1901 */
1902 return 0;
1903 }
1904
1905 /* yylex_destroy is for both reentrant and non-reentrant scanners. */
1906 int yylex_destroy (void)
1907 {
1908
1909 /* Pop the buffer stack, destroying each element. */
1910 while(YY_CURRENT_BUFFER){
1911 yy_delete_buffer( YY_CURRENT_BUFFER );
1912 YY_CURRENT_BUFFER_LVALUE = NULL;
1913 yypop_buffer_state();
1914 }
1915
1916 /* Destroy the stack itself. */
1917 yyfree((yy_buffer_stack) );
1918 (yy_buffer_stack) = NULL;
1919
1920 /* Reset the globals. This is important in a non-reentrant scanner so the next time
1921 * yylex() is called, initialization will occur. */
1922 yy_init_globals( );
1923
1924 return 0;
1925 }
1926
1927 /*
1928 * Internal utility routines.
1929 */
1930
1931 #ifndef yytext_ptr
1932 static void yy_flex_strncpy (char* s1, const char * s2, int n )
1933 {
1934
1935 int i;
1936 for ( i = 0; i < n; ++i )
1937 s1[i] = s2[i];
1938 }
1939 #endif
1940
1941 #ifdef YY_NEED_STRLEN
1942 static int yy_flex_strlen (const char * s )
1943 {
1944 int n;
1945 for ( n = 0; s[n]; ++n )
1946 ;
1947
1948 return n;
1949 }
1950 #endif
1951
1952 void *yyalloc (yy_size_t size )
1953 {
1954 return malloc(size);
1955 }
1956
1957 void *yyrealloc (void * ptr, yy_size_t size )
1958 {
1959
1960 /* The cast to (char *) in the following accommodates both
1961 * implementations that use char* generic pointers, and those
1962 * that use void* generic pointers. It works with the latter
1963 * because both ANSI C and C++ allow castless assignment from
1964 * any pointer type to void*, and deal with argument conversions
1965 * as though doing an assignment.
1966 */
1967 return realloc(ptr, size);
1968 }
1969
1970 void yyfree (void * ptr )
1971 {
1972 free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
1973 }
1974
1975 #define YYTABLES_NAME "yytables"
1976
1977 #line 68 "config_file_lex.l"
1978
1979