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