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