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