5
#define YY_INT_ALIGNED short int
7
/* A lexical scanner generated by flex */
9
#define yy_create_buffer seg_yy_create_buffer
10
#define yy_delete_buffer seg_yy_delete_buffer
11
#define yy_flex_debug seg_yy_flex_debug
12
#define yy_init_buffer seg_yy_init_buffer
13
#define yy_flush_buffer seg_yy_flush_buffer
14
#define yy_load_buffer_state seg_yy_load_buffer_state
15
#define yy_switch_to_buffer seg_yy_switch_to_buffer
17
#define yyleng seg_yyleng
18
#define yylex seg_yylex
19
#define yylineno seg_yylineno
20
#define yyout seg_yyout
21
#define yyrestart seg_yyrestart
22
#define yytext seg_yytext
23
#define yywrap seg_yywrap
24
#define yyalloc seg_yyalloc
25
#define yyrealloc seg_yyrealloc
26
#define yyfree seg_yyfree
29
#define YY_FLEX_MAJOR_VERSION 2
30
#define YY_FLEX_MINOR_VERSION 5
31
#define YY_FLEX_SUBMINOR_VERSION 35
32
#if YY_FLEX_SUBMINOR_VERSION > 0
36
/* First, we deal with platform-specific or compiler-specific issues. */
38
/* begin standard C headers. */
44
/* end standard C headers. */
46
/* flex integer type definitions */
51
/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
53
#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
55
/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
56
* if you want the limit (max/min) macros for int types.
58
#ifndef __STDC_LIMIT_MACROS
59
#define __STDC_LIMIT_MACROS 1
63
typedef int8_t flex_int8_t;
64
typedef uint8_t flex_uint8_t;
65
typedef int16_t flex_int16_t;
66
typedef uint16_t flex_uint16_t;
67
typedef int32_t flex_int32_t;
68
typedef uint32_t flex_uint32_t;
70
typedef signed char flex_int8_t;
71
typedef short int flex_int16_t;
72
typedef int flex_int32_t;
73
typedef unsigned char flex_uint8_t;
74
typedef unsigned short int flex_uint16_t;
75
typedef unsigned int flex_uint32_t;
77
/* Limits of integral types. */
79
#define INT8_MIN (-128)
82
#define INT16_MIN (-32767-1)
85
#define INT32_MIN (-2147483647-1)
88
#define INT8_MAX (127)
91
#define INT16_MAX (32767)
94
#define INT32_MAX (2147483647)
97
#define UINT8_MAX (255U)
100
#define UINT16_MAX (65535U)
103
#define UINT32_MAX (4294967295U)
108
#endif /* ! FLEXINT_H */
112
/* The "const" storage-class-modifier is valid. */
115
#else /* ! __cplusplus */
117
/* C99 requires __STDC__ to be defined as 1. */
118
#if defined (__STDC__)
122
#endif /* defined (__STDC__) */
123
#endif /* ! __cplusplus */
126
#define yyconst const
131
/* Returned upon end-of-file. */
134
/* Promotes a possibly negative, possibly signed char to an unsigned
135
* integer for use as an array index. If the signed char is negative,
136
* we want to instead treat it as an 8-bit unsigned char, hence the
139
#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
141
/* Enter a start condition. This macro really ought to take a parameter,
142
* but we do it the disgusting crufty way forced on us by the ()-less
143
* definition of BEGIN.
145
#define BEGIN (yy_start) = 1 + 2 *
147
/* Translate the current start state into a value that can be later handed
148
* to BEGIN to return to the state. The YYSTATE alias is for lex
151
#define YY_START (((yy_start) - 1) / 2)
152
#define YYSTATE YY_START
154
/* Action number for EOF rule of a given start state. */
155
#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
157
/* Special action meaning "start processing a new file". */
158
#define YY_NEW_FILE seg_yyrestart(seg_yyin )
160
#define YY_END_OF_BUFFER_CHAR 0
162
/* Size of default input buffer. */
165
/* On IA-64, the buffer size is 16k, not 8k.
166
* Moreover, YY_BUF_SIZE is 2*YY_READ_BUF_SIZE in the general case.
167
* Ditto for the __ia64__ case accordingly.
169
#define YY_BUF_SIZE 32768
171
#define YY_BUF_SIZE 16384
172
#endif /* __ia64__ */
175
/* The state buf must be large enough to hold one state per character in the main buffer.
177
#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
179
#ifndef YY_TYPEDEF_YY_BUFFER_STATE
180
#define YY_TYPEDEF_YY_BUFFER_STATE
181
typedef struct yy_buffer_state *YY_BUFFER_STATE;
184
extern int seg_yyleng;
186
extern FILE *seg_yyin, *seg_yyout;
188
#define EOB_ACT_CONTINUE_SCAN 0
189
#define EOB_ACT_END_OF_FILE 1
190
#define EOB_ACT_LAST_MATCH 2
192
#define YY_LESS_LINENO(n)
194
/* Return all but the first "n" matched characters back to the input stream. */
198
/* Undo effects of setting up seg_yytext. */ \
199
int yyless_macro_arg = (n); \
200
YY_LESS_LINENO(yyless_macro_arg);\
201
*yy_cp = (yy_hold_char); \
202
YY_RESTORE_YY_MORE_OFFSET \
203
(yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
204
YY_DO_BEFORE_ACTION; /* set up seg_yytext again */ \
208
#define unput(c) yyunput( c, (yytext_ptr) )
210
#ifndef YY_TYPEDEF_YY_SIZE_T
211
#define YY_TYPEDEF_YY_SIZE_T
212
typedef size_t yy_size_t;
215
#ifndef YY_STRUCT_YY_BUFFER_STATE
216
#define YY_STRUCT_YY_BUFFER_STATE
217
struct yy_buffer_state
221
char *yy_ch_buf; /* input buffer */
222
char *yy_buf_pos; /* current position in input buffer */
224
/* Size of input buffer in bytes, not including room for EOB
227
yy_size_t yy_buf_size;
229
/* Number of characters read into yy_ch_buf, not including EOB
234
/* Whether we "own" the buffer - i.e., we know we created it,
235
* and can realloc() it to grow it, and should free() it to
238
int yy_is_our_buffer;
240
/* Whether this is an "interactive" input source; if so, and
241
* if we're using stdio for input, then we want to use getc()
242
* instead of fread(), to make sure we stop fetching input after
245
int yy_is_interactive;
247
/* Whether we're considered to be at the beginning of a line.
248
* If so, '^' rules will be active on the next match, otherwise
253
int yy_bs_lineno; /**< The line count. */
254
int yy_bs_column; /**< The column count. */
256
/* Whether to try to fill the input buffer when we reach the
261
int yy_buffer_status;
263
#define YY_BUFFER_NEW 0
264
#define YY_BUFFER_NORMAL 1
265
/* When an EOF's been seen but there's still some text to process
266
* then we mark the buffer as YY_EOF_PENDING, to indicate that we
267
* shouldn't try reading from the input source any more. We might
268
* still have a bunch of tokens to match, though, because of
269
* possible backing-up.
271
* When we actually see the EOF, we change the status to "new"
272
* (via seg_yyrestart()), so that the user can continue scanning by
273
* just pointing seg_yyin at a new input file.
275
#define YY_BUFFER_EOF_PENDING 2
278
#endif /* !YY_STRUCT_YY_BUFFER_STATE */
280
/* Stack of input buffers. */
281
static size_t yy_buffer_stack_top = 0; /**< index of top of stack. */
282
static size_t yy_buffer_stack_max = 0; /**< capacity of stack. */
283
static YY_BUFFER_STATE * yy_buffer_stack = 0; /**< Stack as an array. */
285
/* We provide macros for accessing buffer states in case in the
286
* future we want to put the buffer states in a more general
289
* Returns the top of the stack, or NULL.
291
#define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
292
? (yy_buffer_stack)[(yy_buffer_stack_top)] \
295
/* Same as previous macro, but useful when we know that the buffer stack is not
296
* NULL or when we need an lvalue. For internal use only.
298
#define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
300
/* yy_hold_char holds the character lost when seg_yytext is formed. */
301
static char yy_hold_char;
302
static int yy_n_chars; /* number of characters read into yy_ch_buf */
305
/* Points to current character in buffer. */
306
static char *yy_c_buf_p = (char *) 0;
307
static int yy_init = 0; /* whether we need to initialize */
308
static int yy_start = 0; /* start state number */
310
/* Flag which is used to allow seg_yywrap()'s to do buffer switches
311
* instead of setting up a fresh seg_yyin. A bit of a hack ...
313
static int yy_did_buffer_switch_on_eof;
315
void seg_yyrestart (FILE *input_file );
316
void seg_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer );
317
YY_BUFFER_STATE seg_yy_create_buffer (FILE *file,int size );
318
void seg_yy_delete_buffer (YY_BUFFER_STATE b );
319
void seg_yy_flush_buffer (YY_BUFFER_STATE b );
320
void seg_yypush_buffer_state (YY_BUFFER_STATE new_buffer );
321
void seg_yypop_buffer_state (void );
323
static void seg_yyensure_buffer_stack (void );
324
static void seg_yy_load_buffer_state (void );
325
static void seg_yy_init_buffer (YY_BUFFER_STATE b,FILE *file );
327
#define YY_FLUSH_BUFFER seg_yy_flush_buffer(YY_CURRENT_BUFFER )
329
YY_BUFFER_STATE seg_yy_scan_buffer (char *base,yy_size_t size );
330
YY_BUFFER_STATE seg_yy_scan_string (yyconst char *yy_str );
331
YY_BUFFER_STATE seg_yy_scan_bytes (yyconst char *bytes,int len );
333
void *seg_yyalloc (yy_size_t );
334
void *seg_yyrealloc (void *,yy_size_t );
335
void seg_yyfree (void * );
337
#define yy_new_buffer seg_yy_create_buffer
339
#define yy_set_interactive(is_interactive) \
341
if ( ! YY_CURRENT_BUFFER ){ \
342
seg_yyensure_buffer_stack (); \
343
YY_CURRENT_BUFFER_LVALUE = \
344
seg_yy_create_buffer(seg_yyin,YY_BUF_SIZE ); \
346
YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
349
#define yy_set_bol(at_bol) \
351
if ( ! YY_CURRENT_BUFFER ){\
352
seg_yyensure_buffer_stack (); \
353
YY_CURRENT_BUFFER_LVALUE = \
354
seg_yy_create_buffer(seg_yyin,YY_BUF_SIZE ); \
356
YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
359
#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
361
/* Begin user sect3 */
363
#define seg_yywrap(n) 1
364
#define YY_SKIP_YYWRAP
366
typedef unsigned char YY_CHAR;
368
FILE *seg_yyin = (FILE *) 0, *seg_yyout = (FILE *) 0;
370
typedef int yy_state_type;
372
extern int seg_yylineno;
374
int seg_yylineno = 1;
376
extern char *seg_yytext;
377
#define yytext_ptr seg_yytext
379
static yy_state_type yy_get_previous_state (void );
380
static yy_state_type yy_try_NUL_trans (yy_state_type current_state );
381
static int yy_get_next_buffer (void );
382
static void yy_fatal_error (yyconst char msg[] );
384
/* Done after the current pattern has been matched and before the
385
* corresponding action - sets up seg_yytext.
387
#define YY_DO_BEFORE_ACTION \
388
(yytext_ptr) = yy_bp; \
389
seg_yyleng = (size_t) (yy_cp - yy_bp); \
390
(yy_hold_char) = *yy_cp; \
392
(yy_c_buf_p) = yy_cp;
394
#define YY_NUM_RULES 9
395
#define YY_END_OF_BUFFER 10
396
/* This struct is not used in this scanner,
397
but its presence is necessary. */
400
flex_int32_t yy_verify;
403
static yyconst flex_int16_t yy_accept[30] =
405
0, 0, 10, 8, 7, 7, 8, 8, 8, 8,
406
3, 4, 5, 6, 7, 0, 0, 3, 1, 0,
407
0, 0, 0, 1, 3, 0, 3, 2, 0
410
static yyconst flex_int32_t yy_ec[256] =
412
1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
413
1, 2, 2, 1, 1, 1, 1, 1, 1, 1,
414
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
415
1, 2, 1, 1, 1, 1, 1, 1, 4, 5,
416
6, 1, 7, 1, 8, 9, 1, 10, 10, 10,
417
10, 10, 10, 10, 10, 10, 10, 1, 1, 11,
418
1, 12, 1, 1, 1, 1, 1, 1, 13, 1,
419
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
420
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
421
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
423
13, 1, 1, 1, 1, 1, 1, 1, 1, 1,
424
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
425
1, 1, 1, 1, 1, 14, 1, 1, 1, 1,
426
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
427
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
428
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
429
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
430
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
431
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
432
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
434
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
435
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
436
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
437
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
438
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
442
static yyconst flex_int32_t yy_meta[15] =
444
1, 1, 1, 1, 1, 1, 2, 2, 1, 2,
448
static yyconst flex_int16_t yy_base[31] =
450
0, 0, 40, 41, 13, 15, 32, 31, 27, 27,
451
10, 41, 41, 41, 19, 27, 26, 0, 24, 22,
452
21, 26, 23, 41, 14, 18, 16, 41, 41, 23
455
static yyconst flex_int16_t yy_def[31] =
457
29, 1, 29, 29, 29, 29, 29, 29, 29, 29,
458
29, 29, 29, 29, 29, 29, 29, 11, 29, 29,
459
30, 29, 29, 29, 29, 29, 29, 29, 0, 29
462
static yyconst flex_int16_t yy_nxt[56] =
464
4, 5, 6, 7, 8, 4, 9, 9, 10, 11,
465
12, 13, 4, 14, 15, 15, 15, 15, 20, 18,
466
15, 15, 21, 25, 26, 27, 21, 27, 28, 28,
467
27, 25, 24, 23, 22, 19, 18, 17, 16, 29,
468
3, 29, 29, 29, 29, 29, 29, 29, 29, 29,
472
static yyconst flex_int16_t yy_chk[56] =
474
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
475
1, 1, 1, 1, 5, 5, 6, 6, 11, 11,
476
15, 15, 11, 25, 30, 27, 25, 26, 23, 22,
477
21, 20, 19, 17, 16, 10, 9, 8, 7, 3,
478
29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
482
static yy_state_type yy_last_accepting_state;
483
static char *yy_last_accepting_cpos;
485
extern int seg_yy_flex_debug;
486
int seg_yy_flex_debug = 0;
488
/* The intent behind this definition is that it'll catch
489
* any uses of REJECT which flex missed.
491
#define REJECT reject_used_but_not_detected
492
#define yymore() yymore_used_but_not_detected
493
#define YY_MORE_ADJ 0
494
#define YY_RESTORE_YY_MORE_OFFSET
499
* A scanner for EMP-style numeric ranges
502
#include "postgres.h"
504
/* No reason to constrain amount of data slurped */
505
#define YY_READ_BUF_SIZE 16777216
507
/* Avoid exit() on fatal scanner errors (a bit ugly -- see yy_fatal_error) */
509
#define fprintf(file, fmt, msg) fprintf_to_ereport(fmt, msg)
512
fprintf_to_ereport(const char *fmt, const char *msg)
514
ereport(ERROR, (errmsg_internal("%s", msg)));
517
/* Handles to the buffer that the lexer uses internally */
518
static YY_BUFFER_STATE scanbufhandle;
519
static char *scanbuf;
520
static int scanbuflen;
522
/* flex 2.5.4 doesn't bother with a decl for this */
525
void seg_scanner_init(const char *str);
526
void seg_scanner_finish(void);
527
#define YY_NO_INPUT 1
528
#line 529 "segscan.c"
532
#ifndef YY_NO_UNISTD_H
533
/* Special case for "unistd.h", since it is non-ANSI. We include it way
534
* down here because we want the user's section 1 to have been scanned first.
535
* The user has a chance to override it with an option.
540
#ifndef YY_EXTRA_TYPE
541
#define YY_EXTRA_TYPE void *
544
static int yy_init_globals (void );
546
/* Accessor methods to globals.
547
These are made visible to non-reentrant scanners for convenience. */
549
int seg_yylex_destroy (void );
551
int seg_yyget_debug (void );
553
void seg_yyset_debug (int debug_flag );
555
YY_EXTRA_TYPE seg_yyget_extra (void );
557
void seg_yyset_extra (YY_EXTRA_TYPE user_defined );
559
FILE *seg_yyget_in (void );
561
void seg_yyset_in (FILE * in_str );
563
FILE *seg_yyget_out (void );
565
void seg_yyset_out (FILE * out_str );
567
int seg_yyget_leng (void );
569
char *seg_yyget_text (void );
571
int seg_yyget_lineno (void );
573
void seg_yyset_lineno (int line_number );
575
/* Macros after this point can all be overridden by user definitions in
579
#ifndef YY_SKIP_YYWRAP
581
extern "C" int seg_yywrap (void );
583
extern int seg_yywrap (void );
588
static void yy_flex_strncpy (char *,yyconst char *,int );
591
#ifdef YY_NEED_STRLEN
592
static int yy_flex_strlen (yyconst char * );
598
static int yyinput (void );
600
static int input (void );
605
/* Amount of stuff to slurp up with each read. */
606
#ifndef YY_READ_BUF_SIZE
608
/* On IA-64, the buffer size is 16k, not 8k */
609
#define YY_READ_BUF_SIZE 16384
611
#define YY_READ_BUF_SIZE 8192
612
#endif /* __ia64__ */
615
/* Copy whatever the last rule matched to the standard output. */
617
/* This used to be an fputs(), but since the string might contain NUL's,
618
* we now use fwrite().
620
#define ECHO do { if (fwrite( seg_yytext, seg_yyleng, 1, seg_yyout )) {} } while (0)
623
/* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
624
* is returned in "result".
627
#define YY_INPUT(buf,result,max_size) \
628
if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
632
for ( n = 0; n < max_size && \
633
(c = getc( seg_yyin )) != EOF && c != '\n'; ++n ) \
636
buf[n++] = (char) c; \
637
if ( c == EOF && ferror( seg_yyin ) ) \
638
YY_FATAL_ERROR( "input in flex scanner failed" ); \
644
while ( (result = fread(buf, 1, max_size, seg_yyin))==0 && ferror(seg_yyin)) \
646
if( errno != EINTR) \
648
YY_FATAL_ERROR( "input in flex scanner failed" ); \
652
clearerr(seg_yyin); \
659
/* No semi-colon after return; correct usage is to write "yyterminate();" -
660
* we don't want an extra ';' after the "return" because that will cause
661
* some compilers to complain about unreachable statements.
664
#define yyterminate() return YY_NULL
667
/* Number of entries by which start-condition stack grows. */
668
#ifndef YY_START_STACK_INCR
669
#define YY_START_STACK_INCR 25
672
/* Report a fatal error. */
673
#ifndef YY_FATAL_ERROR
674
#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
677
/* end tables serialization structures and prototypes */
679
/* Default declaration of generated scanner - a define so the user can
680
* easily add parameters.
683
#define YY_DECL_IS_OURS 1
685
extern int seg_yylex (void);
687
#define YY_DECL int seg_yylex (void)
688
#endif /* !YY_DECL */
690
/* Code executed at the beginning of each rule, after seg_yytext and seg_yyleng
693
#ifndef YY_USER_ACTION
694
#define YY_USER_ACTION
697
/* Code executed at the end of each rule. */
699
#define YY_BREAK break;
702
#define YY_RULE_SETUP \
705
/** The main scanner function which does all the work.
709
register yy_state_type yy_current_state;
710
register char *yy_cp, *yy_bp;
716
#line 717 "segscan.c"
727
(yy_start) = 1; /* first start state */
735
if ( ! YY_CURRENT_BUFFER ) {
736
seg_yyensure_buffer_stack ();
737
YY_CURRENT_BUFFER_LVALUE =
738
seg_yy_create_buffer(seg_yyin,YY_BUF_SIZE );
741
seg_yy_load_buffer_state( );
744
while ( 1 ) /* loops until end-of-file is reached */
746
yy_cp = (yy_c_buf_p);
748
/* Support of seg_yytext. */
749
*yy_cp = (yy_hold_char);
751
/* yy_bp points to the position in yy_ch_buf of the start of
756
yy_current_state = (yy_start);
760
register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
761
if ( yy_accept[yy_current_state] )
763
(yy_last_accepting_state) = yy_current_state;
764
(yy_last_accepting_cpos) = yy_cp;
766
while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
768
yy_current_state = (int) yy_def[yy_current_state];
769
if ( yy_current_state >= 30 )
770
yy_c = yy_meta[(unsigned int) yy_c];
772
yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
775
while ( yy_current_state != 29 );
776
yy_cp = (yy_last_accepting_cpos);
777
yy_current_state = (yy_last_accepting_state);
780
yy_act = yy_accept[yy_current_state];
784
do_action: /* This label is used only to access EOF actions. */
787
{ /* beginning of action switch */
788
case 0: /* must back up */
789
/* undo the effects of YY_DO_BEFORE_ACTION */
790
*yy_cp = (yy_hold_char);
791
yy_cp = (yy_last_accepting_cpos);
792
yy_current_state = (yy_last_accepting_state);
798
yylval.text = seg_yytext; return RANGE;
803
yylval.text = seg_yytext; return PLUMIN;
808
yylval.text = seg_yytext; return SEGFLOAT;
813
yylval.text = "<"; return EXTENSION;
818
yylval.text = ">"; return EXTENSION;
823
yylval.text = "~"; return EXTENSION;
826
/* rule 7 can match eol */
834
return seg_yytext[0]; /* alert parser of the garbage */
839
YY_FATAL_ERROR( "flex scanner jammed" );
841
#line 842 "segscan.c"
842
case YY_STATE_EOF(INITIAL):
845
case YY_END_OF_BUFFER:
847
/* Amount of text matched not including the EOB char. */
848
int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
850
/* Undo the effects of YY_DO_BEFORE_ACTION. */
851
*yy_cp = (yy_hold_char);
852
YY_RESTORE_YY_MORE_OFFSET
854
if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
856
/* We're scanning a new file or input source. It's
857
* possible that this happened because the user
858
* just pointed seg_yyin at a new source and called
859
* seg_yylex(). If so, then we have to assure
860
* consistency between YY_CURRENT_BUFFER and our
861
* globals. Here is the right place to do so, because
862
* this is the first action (other than possibly a
863
* back-up) that will match for the new input source.
865
(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
866
YY_CURRENT_BUFFER_LVALUE->yy_input_file = seg_yyin;
867
YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
870
/* Note that here we test for yy_c_buf_p "<=" to the position
871
* of the first EOB in the buffer, since yy_c_buf_p will
872
* already have been incremented past the NUL character
873
* (since all states make transitions on EOB to the
874
* end-of-buffer state). Contrast this with the test
877
if ( (yy_c_buf_p) <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
878
{ /* This was really a NUL. */
879
yy_state_type yy_next_state;
881
(yy_c_buf_p) = (yytext_ptr) + yy_amount_of_matched_text;
883
yy_current_state = yy_get_previous_state( );
885
/* Okay, we're now positioned to make the NUL
886
* transition. We couldn't have
887
* yy_get_previous_state() go ahead and do it
888
* for us because it doesn't know how to deal
889
* with the possibility of jamming (and we don't
890
* want to build jamming into it because then it
891
* will run more slowly).
894
yy_next_state = yy_try_NUL_trans( yy_current_state );
896
yy_bp = (yytext_ptr) + YY_MORE_ADJ;
900
/* Consume the NUL. */
901
yy_cp = ++(yy_c_buf_p);
902
yy_current_state = yy_next_state;
908
yy_cp = (yy_last_accepting_cpos);
909
yy_current_state = (yy_last_accepting_state);
914
else switch ( yy_get_next_buffer( ) )
916
case EOB_ACT_END_OF_FILE:
918
(yy_did_buffer_switch_on_eof) = 0;
922
/* Note: because we've taken care in
923
* yy_get_next_buffer() to have set up
924
* seg_yytext, we can now set up
925
* yy_c_buf_p so that if some total
926
* hoser (like flex itself) wants to
927
* call the scanner after we return the
928
* YY_NULL, it'll still work - another
929
* YY_NULL will get returned.
931
(yy_c_buf_p) = (yytext_ptr) + YY_MORE_ADJ;
933
yy_act = YY_STATE_EOF(YY_START);
939
if ( ! (yy_did_buffer_switch_on_eof) )
945
case EOB_ACT_CONTINUE_SCAN:
947
(yytext_ptr) + yy_amount_of_matched_text;
949
yy_current_state = yy_get_previous_state( );
951
yy_cp = (yy_c_buf_p);
952
yy_bp = (yytext_ptr) + YY_MORE_ADJ;
955
case EOB_ACT_LAST_MATCH:
957
&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)];
959
yy_current_state = yy_get_previous_state( );
961
yy_cp = (yy_c_buf_p);
962
yy_bp = (yytext_ptr) + YY_MORE_ADJ;
970
"fatal flex scanner internal error--no action found" );
971
} /* end of action switch */
972
} /* end of scanning one token */
973
} /* end of seg_yylex */
975
/* yy_get_next_buffer - try to read in a new buffer
977
* Returns a code representing an action:
978
* EOB_ACT_LAST_MATCH -
979
* EOB_ACT_CONTINUE_SCAN - continue scanning from current position
980
* EOB_ACT_END_OF_FILE - end of file
982
static int yy_get_next_buffer (void)
984
register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
985
register char *source = (yytext_ptr);
986
register int number_to_move, i;
989
if ( (yy_c_buf_p) > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] )
991
"fatal flex scanner internal error--end of buffer missed" );
993
if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
994
{ /* Don't try to fill the buffer, so this is an EOF. */
995
if ( (yy_c_buf_p) - (yytext_ptr) - YY_MORE_ADJ == 1 )
997
/* We matched a single character, the EOB, so
998
* treat this as a final EOF.
1000
return EOB_ACT_END_OF_FILE;
1005
/* We matched some text prior to the EOB, first
1008
return EOB_ACT_LAST_MATCH;
1012
/* Try to read more data. */
1014
/* First move last chars to start of buffer. */
1015
number_to_move = (int) ((yy_c_buf_p) - (yytext_ptr)) - 1;
1017
for ( i = 0; i < number_to_move; ++i )
1018
*(dest++) = *(source++);
1020
if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1021
/* don't do the read, it's not guaranteed to return an EOF,
1024
YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
1029
YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1031
while ( num_to_read <= 0 )
1032
{ /* Not enough room in the buffer - grow it. */
1034
/* just a shorter name for the current buffer */
1035
YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
1037
int yy_c_buf_p_offset =
1038
(int) ((yy_c_buf_p) - b->yy_ch_buf);
1040
if ( b->yy_is_our_buffer )
1042
int new_size = b->yy_buf_size * 2;
1044
if ( new_size <= 0 )
1045
b->yy_buf_size += b->yy_buf_size / 8;
1047
b->yy_buf_size *= 2;
1049
b->yy_ch_buf = (char *)
1050
/* Include room in for 2 EOB chars. */
1051
seg_yyrealloc((void *) b->yy_ch_buf,b->yy_buf_size + 2 );
1054
/* Can't grow it, we don't own it. */
1057
if ( ! b->yy_ch_buf )
1059
"fatal error - scanner input buffer overflow" );
1061
(yy_c_buf_p) = &b->yy_ch_buf[yy_c_buf_p_offset];
1063
num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1068
if ( num_to_read > YY_READ_BUF_SIZE )
1069
num_to_read = YY_READ_BUF_SIZE;
1071
/* Read in more data. */
1072
YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1073
(yy_n_chars), (size_t) num_to_read );
1075
YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1078
if ( (yy_n_chars) == 0 )
1080
if ( number_to_move == YY_MORE_ADJ )
1082
ret_val = EOB_ACT_END_OF_FILE;
1083
seg_yyrestart(seg_yyin );
1088
ret_val = EOB_ACT_LAST_MATCH;
1089
YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1090
YY_BUFFER_EOF_PENDING;
1095
ret_val = EOB_ACT_CONTINUE_SCAN;
1097
if ((yy_size_t) ((yy_n_chars) + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1098
/* Extend the array by 50%, plus the number we really need. */
1099
yy_size_t new_size = (yy_n_chars) + number_to_move + ((yy_n_chars) >> 1);
1100
YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (char *) seg_yyrealloc((void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size );
1101
if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1102
YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1105
(yy_n_chars) += number_to_move;
1106
YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] = YY_END_OF_BUFFER_CHAR;
1107
YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars) + 1] = YY_END_OF_BUFFER_CHAR;
1109
(yytext_ptr) = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1114
/* yy_get_previous_state - get the state just before the EOB char was reached */
1116
static yy_state_type yy_get_previous_state (void)
1118
register yy_state_type yy_current_state;
1119
register char *yy_cp;
1121
yy_current_state = (yy_start);
1123
for ( yy_cp = (yytext_ptr) + YY_MORE_ADJ; yy_cp < (yy_c_buf_p); ++yy_cp )
1125
register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1126
if ( yy_accept[yy_current_state] )
1128
(yy_last_accepting_state) = yy_current_state;
1129
(yy_last_accepting_cpos) = yy_cp;
1131
while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1133
yy_current_state = (int) yy_def[yy_current_state];
1134
if ( yy_current_state >= 30 )
1135
yy_c = yy_meta[(unsigned int) yy_c];
1137
yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1140
return yy_current_state;
1143
/* yy_try_NUL_trans - try to make a transition on the NUL character
1146
* next_state = yy_try_NUL_trans( current_state );
1148
static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state )
1150
register int yy_is_jam;
1151
register char *yy_cp = (yy_c_buf_p);
1153
register YY_CHAR yy_c = 1;
1154
if ( yy_accept[yy_current_state] )
1156
(yy_last_accepting_state) = yy_current_state;
1157
(yy_last_accepting_cpos) = yy_cp;
1159
while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1161
yy_current_state = (int) yy_def[yy_current_state];
1162
if ( yy_current_state >= 30 )
1163
yy_c = yy_meta[(unsigned int) yy_c];
1165
yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
1166
yy_is_jam = (yy_current_state == 29);
1168
return yy_is_jam ? 0 : yy_current_state;
1173
static int yyinput (void)
1175
static int input (void)
1181
*(yy_c_buf_p) = (yy_hold_char);
1183
if ( *(yy_c_buf_p) == YY_END_OF_BUFFER_CHAR )
1185
/* yy_c_buf_p now points to the character we want to return.
1186
* If this occurs *before* the EOB characters, then it's a
1187
* valid NUL; if not, then we've hit the end of the buffer.
1189
if ( (yy_c_buf_p) < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[(yy_n_chars)] )
1190
/* This was really a NUL. */
1191
*(yy_c_buf_p) = '\0';
1194
{ /* need more input */
1195
int offset = (yy_c_buf_p) - (yytext_ptr);
1198
switch ( yy_get_next_buffer( ) )
1200
case EOB_ACT_LAST_MATCH:
1201
/* This happens because yy_g_n_b()
1202
* sees that we've accumulated a
1203
* token and flags that we need to
1204
* try matching the token before
1205
* proceeding. But for input(),
1206
* there's no matching to consider.
1207
* So convert the EOB_ACT_LAST_MATCH
1208
* to EOB_ACT_END_OF_FILE.
1211
/* Reset buffer status. */
1212
seg_yyrestart(seg_yyin );
1216
case EOB_ACT_END_OF_FILE:
1218
if ( seg_yywrap( ) )
1221
if ( ! (yy_did_buffer_switch_on_eof) )
1230
case EOB_ACT_CONTINUE_SCAN:
1231
(yy_c_buf_p) = (yytext_ptr) + offset;
1237
c = *(unsigned char *) (yy_c_buf_p); /* cast for 8-bit char's */
1238
*(yy_c_buf_p) = '\0'; /* preserve seg_yytext */
1239
(yy_hold_char) = *++(yy_c_buf_p);
1243
#endif /* ifndef YY_NO_INPUT */
1245
/** Immediately switch to a different input stream.
1246
* @param input_file A readable stream.
1248
* @note This function does not reset the start condition to @c INITIAL .
1250
void seg_yyrestart (FILE * input_file )
1253
if ( ! YY_CURRENT_BUFFER ){
1254
seg_yyensure_buffer_stack ();
1255
YY_CURRENT_BUFFER_LVALUE =
1256
seg_yy_create_buffer(seg_yyin,YY_BUF_SIZE );
1259
seg_yy_init_buffer(YY_CURRENT_BUFFER,input_file );
1260
seg_yy_load_buffer_state( );
1263
/** Switch to a different input buffer.
1264
* @param new_buffer The new input buffer.
1267
void seg_yy_switch_to_buffer (YY_BUFFER_STATE new_buffer )
1270
/* TODO. We should be able to replace this entire function body
1272
* seg_yypop_buffer_state();
1273
* seg_yypush_buffer_state(new_buffer);
1275
seg_yyensure_buffer_stack ();
1276
if ( YY_CURRENT_BUFFER == new_buffer )
1279
if ( YY_CURRENT_BUFFER )
1281
/* Flush out information for old buffer. */
1282
*(yy_c_buf_p) = (yy_hold_char);
1283
YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1284
YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1287
YY_CURRENT_BUFFER_LVALUE = new_buffer;
1288
seg_yy_load_buffer_state( );
1290
/* We don't actually know whether we did this switch during
1291
* EOF (seg_yywrap()) processing, but the only time this flag
1292
* is looked at is after seg_yywrap() is called, so it's safe
1293
* to go ahead and always set it.
1295
(yy_did_buffer_switch_on_eof) = 1;
1298
static void seg_yy_load_buffer_state (void)
1300
(yy_n_chars) = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1301
(yytext_ptr) = (yy_c_buf_p) = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1302
seg_yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1303
(yy_hold_char) = *(yy_c_buf_p);
1306
/** Allocate and initialize an input buffer state.
1307
* @param file A readable stream.
1308
* @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1310
* @return the allocated buffer state.
1312
YY_BUFFER_STATE seg_yy_create_buffer (FILE * file, int size )
1316
b = (YY_BUFFER_STATE) seg_yyalloc(sizeof( struct yy_buffer_state ) );
1318
YY_FATAL_ERROR( "out of dynamic memory in seg_yy_create_buffer()" );
1320
b->yy_buf_size = size;
1322
/* yy_ch_buf has to be 2 characters longer than the size given because
1323
* we need to put in 2 end-of-buffer characters.
1325
b->yy_ch_buf = (char *) seg_yyalloc(b->yy_buf_size + 2 );
1326
if ( ! b->yy_ch_buf )
1327
YY_FATAL_ERROR( "out of dynamic memory in seg_yy_create_buffer()" );
1329
b->yy_is_our_buffer = 1;
1331
seg_yy_init_buffer(b,file );
1336
/** Destroy the buffer.
1337
* @param b a buffer created with seg_yy_create_buffer()
1340
void seg_yy_delete_buffer (YY_BUFFER_STATE b )
1346
if ( b == YY_CURRENT_BUFFER ) /* Not sure if we should pop here. */
1347
YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1349
if ( b->yy_is_our_buffer )
1350
seg_yyfree((void *) b->yy_ch_buf );
1352
seg_yyfree((void *) b );
1355
/* Initializes or reinitializes a buffer.
1356
* This function is sometimes called more than once on the same buffer,
1357
* such as during a seg_yyrestart() or at EOF.
1359
static void seg_yy_init_buffer (YY_BUFFER_STATE b, FILE * file )
1364
seg_yy_flush_buffer(b );
1366
b->yy_input_file = file;
1367
b->yy_fill_buffer = 1;
1369
/* If b is the current buffer, then seg_yy_init_buffer was _probably_
1370
* called from seg_yyrestart() or through yy_get_next_buffer.
1371
* In that case, we don't want to reset the lineno or column.
1373
if (b != YY_CURRENT_BUFFER){
1374
b->yy_bs_lineno = 1;
1375
b->yy_bs_column = 0;
1378
b->yy_is_interactive = 0;
1383
/** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1384
* @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1387
void seg_yy_flush_buffer (YY_BUFFER_STATE b )
1394
/* We always need two end-of-buffer characters. The first causes
1395
* a transition to the end-of-buffer state. The second causes
1396
* a jam in that state.
1398
b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1399
b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1401
b->yy_buf_pos = &b->yy_ch_buf[0];
1404
b->yy_buffer_status = YY_BUFFER_NEW;
1406
if ( b == YY_CURRENT_BUFFER )
1407
seg_yy_load_buffer_state( );
1410
/** Pushes the new state onto the stack. The new state becomes
1411
* the current state. This function will allocate the stack
1413
* @param new_buffer The new state.
1416
void seg_yypush_buffer_state (YY_BUFFER_STATE new_buffer )
1418
if (new_buffer == NULL)
1421
seg_yyensure_buffer_stack();
1423
/* This block is copied from seg_yy_switch_to_buffer. */
1424
if ( YY_CURRENT_BUFFER )
1426
/* Flush out information for old buffer. */
1427
*(yy_c_buf_p) = (yy_hold_char);
1428
YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = (yy_c_buf_p);
1429
YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars);
1432
/* Only push if top exists. Otherwise, replace top. */
1433
if (YY_CURRENT_BUFFER)
1434
(yy_buffer_stack_top)++;
1435
YY_CURRENT_BUFFER_LVALUE = new_buffer;
1437
/* copied from seg_yy_switch_to_buffer. */
1438
seg_yy_load_buffer_state( );
1439
(yy_did_buffer_switch_on_eof) = 1;
1442
/** Removes and deletes the top of the stack, if present.
1443
* The next element becomes the new top.
1446
void seg_yypop_buffer_state (void)
1448
if (!YY_CURRENT_BUFFER)
1451
seg_yy_delete_buffer(YY_CURRENT_BUFFER );
1452
YY_CURRENT_BUFFER_LVALUE = NULL;
1453
if ((yy_buffer_stack_top) > 0)
1454
--(yy_buffer_stack_top);
1456
if (YY_CURRENT_BUFFER) {
1457
seg_yy_load_buffer_state( );
1458
(yy_did_buffer_switch_on_eof) = 1;
1462
/* Allocates the stack if it does not exist.
1463
* Guarantees space for at least one push.
1465
static void seg_yyensure_buffer_stack (void)
1469
if (!(yy_buffer_stack)) {
1471
/* First allocation is just for 2 elements, since we don't know if this
1472
* scanner will even need a stack. We use 2 instead of 1 to avoid an
1473
* immediate realloc on the next call.
1476
(yy_buffer_stack) = (struct yy_buffer_state**)seg_yyalloc
1477
(num_to_alloc * sizeof(struct yy_buffer_state*)
1479
if ( ! (yy_buffer_stack) )
1480
YY_FATAL_ERROR( "out of dynamic memory in seg_yyensure_buffer_stack()" );
1482
memset((yy_buffer_stack), 0, num_to_alloc * sizeof(struct yy_buffer_state*));
1484
(yy_buffer_stack_max) = num_to_alloc;
1485
(yy_buffer_stack_top) = 0;
1489
if ((yy_buffer_stack_top) >= ((yy_buffer_stack_max)) - 1){
1491
/* Increase the buffer to prepare for a possible push. */
1492
int grow_size = 8 /* arbitrary grow size */;
1494
num_to_alloc = (yy_buffer_stack_max) + grow_size;
1495
(yy_buffer_stack) = (struct yy_buffer_state**)seg_yyrealloc
1497
num_to_alloc * sizeof(struct yy_buffer_state*)
1499
if ( ! (yy_buffer_stack) )
1500
YY_FATAL_ERROR( "out of dynamic memory in seg_yyensure_buffer_stack()" );
1502
/* zero only the new slots.*/
1503
memset((yy_buffer_stack) + (yy_buffer_stack_max), 0, grow_size * sizeof(struct yy_buffer_state*));
1504
(yy_buffer_stack_max) = num_to_alloc;
1508
/** Setup the input buffer state to scan directly from a user-specified character buffer.
1509
* @param base the character buffer
1510
* @param size the size in bytes of the character buffer
1512
* @return the newly allocated buffer state object.
1514
YY_BUFFER_STATE seg_yy_scan_buffer (char * base, yy_size_t size )
1519
base[size-2] != YY_END_OF_BUFFER_CHAR ||
1520
base[size-1] != YY_END_OF_BUFFER_CHAR )
1521
/* They forgot to leave room for the EOB's. */
1524
b = (YY_BUFFER_STATE) seg_yyalloc(sizeof( struct yy_buffer_state ) );
1526
YY_FATAL_ERROR( "out of dynamic memory in seg_yy_scan_buffer()" );
1528
b->yy_buf_size = size - 2; /* "- 2" to take care of EOB's */
1529
b->yy_buf_pos = b->yy_ch_buf = base;
1530
b->yy_is_our_buffer = 0;
1531
b->yy_input_file = 0;
1532
b->yy_n_chars = b->yy_buf_size;
1533
b->yy_is_interactive = 0;
1535
b->yy_fill_buffer = 0;
1536
b->yy_buffer_status = YY_BUFFER_NEW;
1538
seg_yy_switch_to_buffer(b );
1543
/** Setup the input buffer state to scan a string. The next call to seg_yylex() will
1544
* scan from a @e copy of @a str.
1545
* @param yystr a NUL-terminated string to scan
1547
* @return the newly allocated buffer state object.
1548
* @note If you want to scan bytes that may contain NUL values, then use
1549
* seg_yy_scan_bytes() instead.
1551
YY_BUFFER_STATE seg_yy_scan_string (yyconst char * yystr )
1554
return seg_yy_scan_bytes(yystr,strlen(yystr) );
1557
/** Setup the input buffer state to scan the given bytes. The next call to seg_yylex() will
1558
* scan from a @e copy of @a bytes.
1559
* @param yybytes the byte buffer to scan
1560
* @param _yybytes_len the number of bytes in the buffer pointed to by @a bytes.
1562
* @return the newly allocated buffer state object.
1564
YY_BUFFER_STATE seg_yy_scan_bytes (yyconst char * yybytes, int _yybytes_len )
1571
/* Get memory for full buffer, including space for trailing EOB's. */
1572
n = _yybytes_len + 2;
1573
buf = (char *) seg_yyalloc(n );
1575
YY_FATAL_ERROR( "out of dynamic memory in seg_yy_scan_bytes()" );
1577
for ( i = 0; i < _yybytes_len; ++i )
1578
buf[i] = yybytes[i];
1580
buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1582
b = seg_yy_scan_buffer(buf,n );
1584
YY_FATAL_ERROR( "bad buffer in seg_yy_scan_bytes()" );
1586
/* It's okay to grow etc. this buffer, and we should throw it
1587
* away when we're done.
1589
b->yy_is_our_buffer = 1;
1594
#ifndef YY_EXIT_FAILURE
1595
#define YY_EXIT_FAILURE 2
1598
static void yy_fatal_error (yyconst char* msg )
1600
(void) fprintf( stderr, "%s\n", msg );
1601
exit( YY_EXIT_FAILURE );
1604
/* Redefine yyless() so it works in section 3 code. */
1610
/* Undo effects of setting up seg_yytext. */ \
1611
int yyless_macro_arg = (n); \
1612
YY_LESS_LINENO(yyless_macro_arg);\
1613
seg_yytext[seg_yyleng] = (yy_hold_char); \
1614
(yy_c_buf_p) = seg_yytext + yyless_macro_arg; \
1615
(yy_hold_char) = *(yy_c_buf_p); \
1616
*(yy_c_buf_p) = '\0'; \
1617
seg_yyleng = yyless_macro_arg; \
1621
/* Accessor methods (get/set functions) to struct members. */
1623
/** Get the current line number.
1626
int seg_yyget_lineno (void)
1629
return seg_yylineno;
1632
/** Get the input stream.
1635
FILE *seg_yyget_in (void)
1640
/** Get the output stream.
1643
FILE *seg_yyget_out (void)
1648
/** Get the length of the current token.
1651
int seg_yyget_leng (void)
1656
/** Get the current token.
1660
char *seg_yyget_text (void)
1665
/** Set the current line number.
1666
* @param line_number
1669
void seg_yyset_lineno (int line_number )
1672
seg_yylineno = line_number;
1675
/** Set the input stream. This does not discard the current
1677
* @param in_str A readable stream.
1679
* @see seg_yy_switch_to_buffer
1681
void seg_yyset_in (FILE * in_str )
1686
void seg_yyset_out (FILE * out_str )
1688
seg_yyout = out_str ;
1691
int seg_yyget_debug (void)
1693
return seg_yy_flex_debug;
1696
void seg_yyset_debug (int bdebug )
1698
seg_yy_flex_debug = bdebug ;
1701
static int yy_init_globals (void)
1703
/* Initialization is the same as for the non-reentrant scanner.
1704
* This function is called from seg_yylex_destroy(), so don't allocate here.
1707
(yy_buffer_stack) = 0;
1708
(yy_buffer_stack_top) = 0;
1709
(yy_buffer_stack_max) = 0;
1710
(yy_c_buf_p) = (char *) 0;
1714
/* Defined in main.c */
1719
seg_yyin = (FILE *) 0;
1720
seg_yyout = (FILE *) 0;
1723
/* For future reference: Set errno on error, since we are called by
1729
/* seg_yylex_destroy is for both reentrant and non-reentrant scanners. */
1730
int seg_yylex_destroy (void)
1733
/* Pop the buffer stack, destroying each element. */
1734
while(YY_CURRENT_BUFFER){
1735
seg_yy_delete_buffer(YY_CURRENT_BUFFER );
1736
YY_CURRENT_BUFFER_LVALUE = NULL;
1737
seg_yypop_buffer_state();
1740
/* Destroy the stack itself. */
1741
seg_yyfree((yy_buffer_stack) );
1742
(yy_buffer_stack) = NULL;
1744
/* Reset the globals. This is important in a non-reentrant scanner so the next time
1745
* seg_yylex() is called, initialization will occur. */
1752
* Internal utility routines.
1756
static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
1759
for ( i = 0; i < n; ++i )
1764
#ifdef YY_NEED_STRLEN
1765
static int yy_flex_strlen (yyconst char * s )
1768
for ( n = 0; s[n]; ++n )
1775
void *seg_yyalloc (yy_size_t size )
1777
return (void *) malloc( size );
1780
void *seg_yyrealloc (void * ptr, yy_size_t size )
1782
/* The cast to (char *) in the following accommodates both
1783
* implementations that use char* generic pointers, and those
1784
* that use void* generic pointers. It works with the latter
1785
* because both ANSI C and C++ allow castless assignment from
1786
* any pointer type to void*, and deal with argument conversions
1787
* as though doing an assignment.
1789
return (void *) realloc( (char *) ptr, size );
1792
void seg_yyfree (void * ptr )
1794
free( (char *) ptr ); /* see seg_yyrealloc() for (char *) cast */
1797
#define YYTABLES_NAME "yytables"
1799
#line 60 "segscan.l"
1803
void __attribute__((noreturn))
1804
yyerror(const char *message)
1806
if (*seg_yytext == YY_END_OF_BUFFER_CHAR)
1809
(errcode(ERRCODE_SYNTAX_ERROR),
1810
errmsg("bad seg representation"),
1811
/* translator: %s is typically "syntax error" */
1812
errdetail("%s at end of input", message)));
1817
(errcode(ERRCODE_SYNTAX_ERROR),
1818
errmsg("bad seg representation"),
1819
/* translator: first %s is typically "syntax error" */
1820
errdetail("%s at or near \"%s\"", message, seg_yytext)));
1826
* Called before any actual parsing is done
1829
seg_scanner_init(const char *str)
1831
Size slen = strlen(str);
1834
* Might be left over after ereport()
1836
if (YY_CURRENT_BUFFER)
1837
seg_yy_delete_buffer(YY_CURRENT_BUFFER);
1840
* Make a scan buffer with special termination needed by flex.
1843
scanbuf = palloc(slen + 2);
1844
memcpy(scanbuf, str, slen);
1845
scanbuf[slen] = scanbuf[slen + 1] = YY_END_OF_BUFFER_CHAR;
1846
scanbufhandle = seg_yy_scan_buffer(scanbuf,slen + 2);
1853
* Called after parsing is done to clean up after seg_scanner_init()
1856
seg_scanner_finish(void)
1858
seg_yy_delete_buffer(scanbufhandle);
added
removed
contrib/seg/segscan.c
