5 #define YY_INT_ALIGNED short int
7 /* A lexical scanner generated by flex */
9 #define yy_create_buffer __ktrfmt_create_buffer
10 #define yy_delete_buffer __ktrfmt_delete_buffer
11 #define yy_flex_debug __ktrfmt_flex_debug
12 #define yy_init_buffer __ktrfmt_init_buffer
13 #define yy_flush_buffer __ktrfmt_flush_buffer
14 #define yy_load_buffer_state __ktrfmt_load_buffer_state
15 #define yy_switch_to_buffer __ktrfmt_switch_to_buffer
16 #define yyin __ktrfmtin
17 #define yyleng __ktrfmtleng
18 #define yylex __ktrfmtlex
19 #define yylineno __ktrfmtlineno
20 #define yyout __ktrfmtout
21 #define yyrestart __ktrfmtrestart
22 #define yytext __ktrfmttext
23 #define yywrap __ktrfmtwrap
24 #define yyalloc __ktrfmtalloc
25 #define yyrealloc __ktrfmtrealloc
26 #define yyfree __ktrfmtfree
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
;
78 /* Limits of integral types. */
80 #define INT8_MIN (-128)
83 #define INT16_MIN (-32767-1)
86 #define INT32_MIN (-2147483647-1)
89 #define INT8_MAX (127)
92 #define INT16_MAX (32767)
95 #define INT32_MAX (2147483647)
98 #define UINT8_MAX (255U)
101 #define UINT16_MAX (65535U)
104 #define UINT32_MAX (4294967295U)
107 #endif /* ! FLEXINT_H */
111 /* The "const" storage-class-modifier is valid. */
114 #else /* ! __cplusplus */
116 /* C99 requires __STDC__ to be defined as 1. */
117 #if defined (__STDC__)
121 #endif /* defined (__STDC__) */
122 #endif /* ! __cplusplus */
125 #define yyconst const
130 /* Returned upon end-of-file. */
133 /* Promotes a possibly negative, possibly signed char to an unsigned
134 * integer for use as an array index. If the signed char is negative,
135 * we want to instead treat it as an 8-bit unsigned char, hence the
138 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
140 /* Enter a start condition. This macro really ought to take a parameter,
141 * but we do it the disgusting crufty way forced on us by the ()-less
142 * definition of BEGIN.
144 #define BEGIN (yy_start) = 1 + 2 *
146 /* Translate the current start state into a value that can be later handed
147 * to BEGIN to return to the state. The YYSTATE alias is for lex
150 #define YY_START (((yy_start) - 1) / 2)
151 #define YYSTATE YY_START
153 /* Action number for EOF rule of a given start state. */
154 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
156 /* Special action meaning "start processing a new file". */
157 #define YY_NEW_FILE __ktrfmtrestart(__ktrfmtin )
159 #define YY_END_OF_BUFFER_CHAR 0
161 /* Size of default input buffer. */
163 #define YY_BUF_SIZE 16384
166 /* The state buf must be large enough to hold one state per character in the main buffer.
168 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
170 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
171 #define YY_TYPEDEF_YY_BUFFER_STATE
172 typedef struct yy_buffer_state
*YY_BUFFER_STATE
;
175 extern int __ktrfmtleng
;
177 extern FILE *__ktrfmtin
, *__ktrfmtout
;
179 #define EOB_ACT_CONTINUE_SCAN 0
180 #define EOB_ACT_END_OF_FILE 1
181 #define EOB_ACT_LAST_MATCH 2
183 #define YY_LESS_LINENO(n)
185 /* Return all but the first "n" matched characters back to the input stream. */
189 /* Undo effects of setting up __ktrfmttext. */ \
190 int yyless_macro_arg = (n); \
191 YY_LESS_LINENO(yyless_macro_arg);\
192 *yy_cp = (yy_hold_char); \
193 YY_RESTORE_YY_MORE_OFFSET \
194 (yy_c_buf_p) = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
195 YY_DO_BEFORE_ACTION; /* set up __ktrfmttext again */ \
199 #define unput(c) yyunput( c, (yytext_ptr) )
201 #ifndef YY_TYPEDEF_YY_SIZE_T
202 #define YY_TYPEDEF_YY_SIZE_T
203 typedef size_t yy_size_t
;
206 #ifndef YY_STRUCT_YY_BUFFER_STATE
207 #define YY_STRUCT_YY_BUFFER_STATE
208 struct yy_buffer_state
212 char *yy_ch_buf
; /* input buffer */
213 char *yy_buf_pos
; /* current position in input buffer */
215 /* Size of input buffer in bytes, not including room for EOB
218 yy_size_t yy_buf_size
;
220 /* Number of characters read into yy_ch_buf, not including EOB
225 /* Whether we "own" the buffer - i.e., we know we created it,
226 * and can realloc() it to grow it, and should free() it to
229 int yy_is_our_buffer
;
231 /* Whether this is an "interactive" input source; if so, and
232 * if we're using stdio for input, then we want to use getc()
233 * instead of fread(), to make sure we stop fetching input after
236 int yy_is_interactive
;
238 /* Whether we're considered to be at the beginning of a line.
239 * If so, '^' rules will be active on the next match, otherwise
244 int yy_bs_lineno
; /**< The line count. */
245 int yy_bs_column
; /**< The column count. */
247 /* Whether to try to fill the input buffer when we reach the
252 int yy_buffer_status
;
254 #define YY_BUFFER_NEW 0
255 #define YY_BUFFER_NORMAL 1
256 /* When an EOF's been seen but there's still some text to process
257 * then we mark the buffer as YY_EOF_PENDING, to indicate that we
258 * shouldn't try reading from the input source any more. We might
259 * still have a bunch of tokens to match, though, because of
260 * possible backing-up.
262 * When we actually see the EOF, we change the status to "new"
263 * (via __ktrfmtrestart()), so that the user can continue scanning by
264 * just pointing __ktrfmtin at a new input file.
266 #define YY_BUFFER_EOF_PENDING 2
269 #endif /* !YY_STRUCT_YY_BUFFER_STATE */
271 /* Stack of input buffers. */
272 static size_t yy_buffer_stack_top
= 0; /**< index of top of stack. */
273 static size_t yy_buffer_stack_max
= 0; /**< capacity of stack. */
274 static YY_BUFFER_STATE
* yy_buffer_stack
= 0; /**< Stack as an array. */
276 /* We provide macros for accessing buffer states in case in the
277 * future we want to put the buffer states in a more general
280 * Returns the top of the stack, or NULL.
282 #define YY_CURRENT_BUFFER ( (yy_buffer_stack) \
283 ? (yy_buffer_stack)[(yy_buffer_stack_top)] \
286 /* Same as previous macro, but useful when we know that the buffer stack is not
287 * NULL or when we need an lvalue. For internal use only.
289 #define YY_CURRENT_BUFFER_LVALUE (yy_buffer_stack)[(yy_buffer_stack_top)]
291 /* yy_hold_char holds the character lost when __ktrfmttext is formed. */
292 static char yy_hold_char
;
293 static int yy_n_chars
; /* number of characters read into yy_ch_buf */
296 /* Points to current character in buffer. */
297 static char *yy_c_buf_p
= (char *) 0;
298 static int yy_init
= 0; /* whether we need to initialize */
299 static int yy_start
= 0; /* start state number */
301 /* Flag which is used to allow __ktrfmtwrap()'s to do buffer switches
302 * instead of setting up a fresh __ktrfmtin. A bit of a hack ...
304 static int yy_did_buffer_switch_on_eof
;
306 void __ktrfmtrestart (FILE *input_file
);
307 void __ktrfmt_switch_to_buffer (YY_BUFFER_STATE new_buffer
);
308 YY_BUFFER_STATE
__ktrfmt_create_buffer (FILE *file
,int size
);
309 void __ktrfmt_delete_buffer (YY_BUFFER_STATE b
);
310 void __ktrfmt_flush_buffer (YY_BUFFER_STATE b
);
311 void __ktrfmtpush_buffer_state (YY_BUFFER_STATE new_buffer
);
312 void __ktrfmtpop_buffer_state (void );
314 static void __ktrfmtensure_buffer_stack (void );
315 static void __ktrfmt_load_buffer_state (void );
316 static void __ktrfmt_init_buffer (YY_BUFFER_STATE b
,FILE *file
);
318 #define YY_FLUSH_BUFFER __ktrfmt_flush_buffer(YY_CURRENT_BUFFER )
320 YY_BUFFER_STATE
__ktrfmt_scan_buffer (char *base
,yy_size_t size
);
321 YY_BUFFER_STATE
__ktrfmt_scan_string (yyconst
char *yy_str
);
322 YY_BUFFER_STATE
__ktrfmt_scan_bytes (yyconst
char *bytes
,int len
);
324 void *__ktrfmtalloc (yy_size_t
);
325 void *__ktrfmtrealloc (void *,yy_size_t
);
326 void __ktrfmtfree (void * );
328 #define yy_new_buffer __ktrfmt_create_buffer
330 #define yy_set_interactive(is_interactive) \
332 if ( ! YY_CURRENT_BUFFER ){ \
333 __ktrfmtensure_buffer_stack (); \
334 YY_CURRENT_BUFFER_LVALUE = \
335 __ktrfmt_create_buffer(__ktrfmtin,YY_BUF_SIZE ); \
337 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
340 #define yy_set_bol(at_bol) \
342 if ( ! YY_CURRENT_BUFFER ){\
343 __ktrfmtensure_buffer_stack (); \
344 YY_CURRENT_BUFFER_LVALUE = \
345 __ktrfmt_create_buffer(__ktrfmtin,YY_BUF_SIZE ); \
347 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
350 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
352 /* Begin user sect3 */
354 #define __ktrfmtwrap(n) 1
355 #define YY_SKIP_YYWRAP
357 typedef unsigned char YY_CHAR
;
359 FILE *__ktrfmtin
= (FILE *) 0, *__ktrfmtout
= (FILE *) 0;
361 typedef int yy_state_type
;
363 extern int __ktrfmtlineno
;
365 int __ktrfmtlineno
= 1;
367 extern char *__ktrfmttext
;
368 #define yytext_ptr __ktrfmttext
370 static yy_state_type
yy_get_previous_state (void );
371 static yy_state_type
yy_try_NUL_trans (yy_state_type current_state
);
372 static int yy_get_next_buffer (void );
373 static void yy_fatal_error (yyconst
char msg
[] );
375 /* Done after the current pattern has been matched and before the
376 * corresponding action - sets up __ktrfmttext.
378 #define YY_DO_BEFORE_ACTION \
379 (yytext_ptr) = yy_bp; \
380 __ktrfmtleng = (size_t) (yy_cp - yy_bp); \
381 (yy_hold_char) = *yy_cp; \
383 (yy_c_buf_p) = yy_cp;
385 #define YY_NUM_RULES 11
386 #define YY_END_OF_BUFFER 12
387 /* This struct is not used in this scanner,
388 but its presence is necessary. */
391 flex_int32_t yy_verify
;
394 static yyconst flex_int16_t yy_accept
[26] =
396 0, 0, 12, 11, 1, 11, 3, 8, 5, 5,
397 7, 4, 9, 10, 1, 0, 0, 3, 5, 0,
401 static yyconst flex_int32_t yy_ec
[256] =
403 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
404 1, 1, 2, 1, 1, 1, 1, 1, 1, 1,
405 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
406 1, 2, 1, 4, 1, 5, 1, 1, 1, 1,
407 1, 1, 1, 1, 1, 6, 1, 7, 8, 8,
408 8, 8, 8, 8, 8, 8, 8, 1, 1, 1,
409 9, 1, 1, 1, 10, 10, 10, 10, 10, 10,
410 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
411 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
412 12, 13, 14, 1, 15, 1, 16, 16, 16, 16,
414 16, 16, 15, 15, 15, 15, 15, 15, 15, 15,
415 15, 15, 15, 15, 15, 15, 15, 15, 15, 17,
416 15, 15, 1, 1, 1, 1, 1, 1, 1, 1,
417 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
418 1, 1, 1, 1, 1, 1, 1, 1, 1, 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,
422 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
423 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
425 1, 1, 1, 1, 1, 1, 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,
433 static yyconst flex_int32_t yy_meta
[18] =
435 1, 1, 2, 2, 1, 1, 3, 3, 1, 4,
439 static yyconst flex_int16_t yy_base
[31] =
441 0, 0, 31, 54, 26, 14, 0, 54, 9, 11,
442 54, 0, 54, 54, 23, 16, 17, 0, 15, 0,
443 0, 54, 20, 0, 54, 33, 37, 41, 45, 49
446 static yyconst flex_int16_t yy_def
[31] =
448 25, 1, 25, 25, 25, 26, 27, 25, 28, 25,
449 25, 29, 25, 25, 25, 26, 26, 27, 25, 30,
450 29, 25, 26, 30, 0, 25, 25, 25, 25, 25
453 static yyconst flex_int16_t yy_nxt
[72] =
455 4, 5, 4, 6, 7, 8, 9, 10, 11, 12,
456 12, 13, 4, 14, 7, 7, 7, 19, 19, 22,
457 23, 19, 19, 22, 15, 20, 17, 15, 17, 17,
458 25, 25, 17, 16, 25, 16, 16, 16, 16, 18,
459 18, 18, 18, 19, 25, 25, 19, 21, 21, 21,
460 21, 24, 24, 3, 25, 25, 25, 25, 25, 25,
461 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
465 static yyconst flex_int16_t yy_chk
[72] =
467 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
468 1, 1, 1, 1, 1, 1, 1, 10, 10, 16,
469 17, 19, 19, 23, 15, 9, 6, 5, 16, 17,
470 3, 0, 23, 26, 0, 26, 26, 26, 26, 27,
471 27, 27, 27, 28, 0, 0, 28, 29, 29, 29,
472 29, 30, 30, 25, 25, 25, 25, 25, 25, 25,
473 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
477 static yy_state_type yy_last_accepting_state
;
478 static char *yy_last_accepting_cpos
;
480 extern int __ktrfmt_flex_debug
;
481 int __ktrfmt_flex_debug
= 0;
483 /* The intent behind this definition is that it'll catch
484 * any uses of REJECT which flex missed.
486 #define REJECT reject_used_but_not_detected
487 #define yymore() yymore_used_but_not_detected
488 #define YY_MORE_ADJ 0
489 #define YY_RESTORE_YY_MORE_OFFSET
495 //#define YYSTYPE struct token
498 #include "ktrfmt.tab.h"
500 #include "internal.h"
506 /* XXX: need to switch to reentrant lexer */
507 static struct token tokens
[NR_TOKENS
];
509 static struct symtab
*strtab
;
516 if (curr_tok
== NR_TOKENS
) {
518 fprintf(stderr
, "Reached max number of tokens\n");
521 return &tokens
[curr_tok
];
525 tok_free(struct token
*tok
)
527 assert(&tokens
[curr_tok
] == tok
);
532 * We keep track of strings we've seen before so string comparison
533 * can be done w/ a simple pointer comparison
537 newstr(const char *s
)
541 strtab
= symtab_new();
542 if ((r
= symtab_find(strtab
, s
)))
544 if (!(r
= strdup(s
)))
546 symtab_insert(strtab
, r
, r
);
550 #line 551 "ktrfmt.yy.c"
554 #ifndef YY_NO_UNISTD_H
555 /* Special case for "unistd.h", since it is non-ANSI. We include it way
556 * down here because we want the user's section 1 to have been scanned first.
557 * The user has a chance to override it with an option.
562 #ifndef YY_EXTRA_TYPE
563 #define YY_EXTRA_TYPE void *
566 static int yy_init_globals (void );
568 /* Accessor methods to globals.
569 These are made visible to non-reentrant scanners for convenience. */
571 int __ktrfmtlex_destroy (void );
573 int __ktrfmtget_debug (void );
575 void __ktrfmtset_debug (int debug_flag
);
577 YY_EXTRA_TYPE
__ktrfmtget_extra (void );
579 void __ktrfmtset_extra (YY_EXTRA_TYPE user_defined
);
581 FILE *__ktrfmtget_in (void );
583 void __ktrfmtset_in (FILE * in_str
);
585 FILE *__ktrfmtget_out (void );
587 void __ktrfmtset_out (FILE * out_str
);
589 int __ktrfmtget_leng (void );
591 char *__ktrfmtget_text (void );
593 int __ktrfmtget_lineno (void );
595 void __ktrfmtset_lineno (int line_number
);
597 YYSTYPE
* __ktrfmtget_lval (void );
599 void __ktrfmtset_lval (YYSTYPE
* yylval_param
);
601 /* Macros after this point can all be overridden by user definitions in
605 #ifndef YY_SKIP_YYWRAP
607 extern "C" int __ktrfmtwrap (void );
609 extern int __ktrfmtwrap (void );
614 static void yy_flex_strncpy (char *,yyconst
char *,int );
617 #ifdef YY_NEED_STRLEN
618 static int yy_flex_strlen (yyconst
char * );
624 static int yyinput (void );
626 static int input (void );
631 /* Amount of stuff to slurp up with each read. */
632 #ifndef YY_READ_BUF_SIZE
633 #define YY_READ_BUF_SIZE 8192
636 /* Copy whatever the last rule matched to the standard output. */
638 /* This used to be an fputs(), but since the string might contain NUL's,
639 * we now use fwrite().
641 #define ECHO fwrite( __ktrfmttext, __ktrfmtleng, 1, __ktrfmtout )
644 /* Gets input and stuffs it into "buf". number of characters read, or YY_NULL,
645 * is returned in "result".
648 #define YY_INPUT(buf,result,max_size) \
649 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
653 for ( n = 0; n < max_size && \
654 (c = getc( __ktrfmtin )) != EOF && c != '\n'; ++n ) \
657 buf[n++] = (char) c; \
658 if ( c == EOF && ferror( __ktrfmtin ) ) \
659 YY_FATAL_ERROR( "input in flex scanner failed" ); \
665 while ( (result = fread(buf, 1, max_size, __ktrfmtin))==0 && ferror(__ktrfmtin)) \
667 if( errno != EINTR) \
669 YY_FATAL_ERROR( "input in flex scanner failed" ); \
673 clearerr(__ktrfmtin); \
680 /* No semi-colon after return; correct usage is to write "yyterminate();" -
681 * we don't want an extra ';' after the "return" because that will cause
682 * some compilers to complain about unreachable statements.
685 #define yyterminate() return YY_NULL
688 /* Number of entries by which start-condition stack grows. */
689 #ifndef YY_START_STACK_INCR
690 #define YY_START_STACK_INCR 25
693 /* Report a fatal error. */
694 #ifndef YY_FATAL_ERROR
695 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
698 /* end tables serialization structures and prototypes */
700 /* Default declaration of generated scanner - a define so the user can
701 * easily add parameters.
704 #define YY_DECL_IS_OURS 1
706 extern int __ktrfmtlex \
707 (YYSTYPE
* yylval_param
);
709 #define YY_DECL int __ktrfmtlex \
710 (YYSTYPE * yylval_param )
711 #endif /* !YY_DECL */
713 /* Code executed at the beginning of each rule, after __ktrfmttext and __ktrfmtleng
716 #ifndef YY_USER_ACTION
717 #define YY_USER_ACTION
720 /* Code executed at the end of each rule. */
722 #define YY_BREAK break;
725 #define YY_RULE_SETUP \
728 /** The main scanner function which does all the work.
732 register yy_state_type yy_current_state
;
733 register char *yy_cp
, *yy_bp
;
740 #line 741 "ktrfmt.yy.c"
742 yylval
= yylval_param
;
753 (yy_start
) = 1; /* first start state */
759 __ktrfmtout
= stdout
;
761 if ( ! YY_CURRENT_BUFFER
) {
762 __ktrfmtensure_buffer_stack ();
763 YY_CURRENT_BUFFER_LVALUE
=
764 __ktrfmt_create_buffer(__ktrfmtin
,YY_BUF_SIZE
);
767 __ktrfmt_load_buffer_state( );
770 while ( 1 ) /* loops until end-of-file is reached */
772 yy_cp
= (yy_c_buf_p
);
774 /* Support of __ktrfmttext. */
775 *yy_cp
= (yy_hold_char
);
777 /* yy_bp points to the position in yy_ch_buf of the start of
782 yy_current_state
= (yy_start
);
786 register YY_CHAR yy_c
= yy_ec
[YY_SC_TO_UI(*yy_cp
)];
787 if ( yy_accept
[yy_current_state
] )
789 (yy_last_accepting_state
) = yy_current_state
;
790 (yy_last_accepting_cpos
) = yy_cp
;
792 while ( yy_chk
[yy_base
[yy_current_state
] + yy_c
] != yy_current_state
)
794 yy_current_state
= (int) yy_def
[yy_current_state
];
795 if ( yy_current_state
>= 26 )
796 yy_c
= yy_meta
[(unsigned int) yy_c
];
798 yy_current_state
= yy_nxt
[yy_base
[yy_current_state
] + (unsigned int) yy_c
];
801 while ( yy_base
[yy_current_state
] != 54 );
804 yy_act
= yy_accept
[yy_current_state
];
806 { /* have to back up */
807 yy_cp
= (yy_last_accepting_cpos
);
808 yy_current_state
= (yy_last_accepting_state
);
809 yy_act
= yy_accept
[yy_current_state
];
814 do_action
: /* This label is used only to access EOF actions. */
817 { /* beginning of action switch */
818 case 0: /* must back up */
819 /* undo the effects of YY_DO_BEFORE_ACTION */
820 *yy_cp
= (yy_hold_char
);
821 yy_cp
= (yy_last_accepting_cpos
);
822 yy_current_state
= (yy_last_accepting_state
);
835 yylval
->tok
= tok_new();
836 yylval
->tok
->type
= TOK_STR
;
837 len
= strlen(__ktrfmttext
);
838 assert(__ktrfmttext
[len
- 1] == '"');
839 __ktrfmttext
[len
- 1] = '\0'; /* kill trailing quote */
840 printd(LEX
, "newstr(\"%s\")\n", __ktrfmttext
+ 1);
841 yylval
->tok
->str
= newstr(__ktrfmttext
+ 1); /* parser detects oom */
842 __ktrfmttext
[len
- 1] = '"'; /* restore quote */
843 printd(LEX
, "TOK_STR: \"%s\"\n", yylval
->tok
->str
);
851 yylval
->tok
= tok_new();
852 yylval
->tok
->type
= TOK_ID
;
853 printd(LEX
, "tok %p TOK_ID %p:%s\n", yylval
->tok
, __ktrfmttext
, __ktrfmttext
);
854 yylval
->tok
->str
= newstr(__ktrfmttext
); /* parser detects oom */
862 yylval
->tok
= tok_new();
863 yylval
->tok
->type
= TOK_CTOR
;
864 printd(LEX
, "tok %p TOK_CTOR %p:%s\n", yylval
->tok
, __ktrfmttext
, __ktrfmttext
);
865 yylval
->tok
->str
= newstr(__ktrfmttext
); /* parser detects oom */
873 yylval
->tok
= tok_new();
874 yylval
->tok
->type
= TOK_INT
;
875 yylval
->tok
->str
= strdup(__ktrfmttext
); /* parser detects oom */
876 printd(LEX
, "TOK_INT\n");
884 yylval
->tok
= tok_new();
885 yylval
->tok
->type
= TOK_INT
;
886 yylval
->tok
->str
= strdup(__ktrfmttext
); /* parser detects oom */
887 printd(LEX
, "TOK_INT\n");
896 printd(LEX
, "TOK_EQ\n");
905 printd(LEX
, "TOK_DOT\n");
914 printd(LEX
, "TOK_LEFT_BRACK\n");
915 return TOK_LEFT_BRACK
;
923 printd(LEX
, "TOK_RIGHT_BRACK\n");
924 return TOK_RIGHT_BRACK
;
932 #line 933 "ktrfmt.yy.c"
933 case YY_STATE_EOF(INITIAL
):
936 case YY_END_OF_BUFFER
:
938 /* Amount of text matched not including the EOB char. */
939 int yy_amount_of_matched_text
= (int) (yy_cp
- (yytext_ptr
)) - 1;
941 /* Undo the effects of YY_DO_BEFORE_ACTION. */
942 *yy_cp
= (yy_hold_char
);
943 YY_RESTORE_YY_MORE_OFFSET
945 if ( YY_CURRENT_BUFFER_LVALUE
->yy_buffer_status
== YY_BUFFER_NEW
)
947 /* We're scanning a new file or input source. It's
948 * possible that this happened because the user
949 * just pointed __ktrfmtin at a new source and called
950 * __ktrfmtlex(). If so, then we have to assure
951 * consistency between YY_CURRENT_BUFFER and our
952 * globals. Here is the right place to do so, because
953 * this is the first action (other than possibly a
954 * back-up) that will match for the new input source.
956 (yy_n_chars
) = YY_CURRENT_BUFFER_LVALUE
->yy_n_chars
;
957 YY_CURRENT_BUFFER_LVALUE
->yy_input_file
= __ktrfmtin
;
958 YY_CURRENT_BUFFER_LVALUE
->yy_buffer_status
= YY_BUFFER_NORMAL
;
961 /* Note that here we test for yy_c_buf_p "<=" to the position
962 * of the first EOB in the buffer, since yy_c_buf_p will
963 * already have been incremented past the NUL character
964 * (since all states make transitions on EOB to the
965 * end-of-buffer state). Contrast this with the test
968 if ( (yy_c_buf_p
) <= &YY_CURRENT_BUFFER_LVALUE
->yy_ch_buf
[(yy_n_chars
)] )
969 { /* This was really a NUL. */
970 yy_state_type yy_next_state
;
972 (yy_c_buf_p
) = (yytext_ptr
) + yy_amount_of_matched_text
;
974 yy_current_state
= yy_get_previous_state( );
976 /* Okay, we're now positioned to make the NUL
977 * transition. We couldn't have
978 * yy_get_previous_state() go ahead and do it
979 * for us because it doesn't know how to deal
980 * with the possibility of jamming (and we don't
981 * want to build jamming into it because then it
982 * will run more slowly).
985 yy_next_state
= yy_try_NUL_trans( yy_current_state
);
987 yy_bp
= (yytext_ptr
) + YY_MORE_ADJ
;
991 /* Consume the NUL. */
992 yy_cp
= ++(yy_c_buf_p
);
993 yy_current_state
= yy_next_state
;
999 yy_cp
= (yy_c_buf_p
);
1000 goto yy_find_action
;
1004 else switch ( yy_get_next_buffer( ) )
1006 case EOB_ACT_END_OF_FILE
:
1008 (yy_did_buffer_switch_on_eof
) = 0;
1010 if ( __ktrfmtwrap( ) )
1012 /* Note: because we've taken care in
1013 * yy_get_next_buffer() to have set up
1014 * __ktrfmttext, we can now set up
1015 * yy_c_buf_p so that if some total
1016 * hoser (like flex itself) wants to
1017 * call the scanner after we return the
1018 * YY_NULL, it'll still work - another
1019 * YY_NULL will get returned.
1021 (yy_c_buf_p
) = (yytext_ptr
) + YY_MORE_ADJ
;
1023 yy_act
= YY_STATE_EOF(YY_START
);
1029 if ( ! (yy_did_buffer_switch_on_eof
) )
1035 case EOB_ACT_CONTINUE_SCAN
:
1037 (yytext_ptr
) + yy_amount_of_matched_text
;
1039 yy_current_state
= yy_get_previous_state( );
1041 yy_cp
= (yy_c_buf_p
);
1042 yy_bp
= (yytext_ptr
) + YY_MORE_ADJ
;
1045 case EOB_ACT_LAST_MATCH
:
1047 &YY_CURRENT_BUFFER_LVALUE
->yy_ch_buf
[(yy_n_chars
)];
1049 yy_current_state
= yy_get_previous_state( );
1051 yy_cp
= (yy_c_buf_p
);
1052 yy_bp
= (yytext_ptr
) + YY_MORE_ADJ
;
1053 goto yy_find_action
;
1060 "fatal flex scanner internal error--no action found" );
1061 } /* end of action switch */
1062 } /* end of scanning one token */
1063 } /* end of __ktrfmtlex */
1065 /* yy_get_next_buffer - try to read in a new buffer
1067 * Returns a code representing an action:
1068 * EOB_ACT_LAST_MATCH -
1069 * EOB_ACT_CONTINUE_SCAN - continue scanning from current position
1070 * EOB_ACT_END_OF_FILE - end of file
1072 static int yy_get_next_buffer (void)
1074 register char *dest
= YY_CURRENT_BUFFER_LVALUE
->yy_ch_buf
;
1075 register char *source
= (yytext_ptr
);
1076 register int number_to_move
, i
;
1079 if ( (yy_c_buf_p
) > &YY_CURRENT_BUFFER_LVALUE
->yy_ch_buf
[(yy_n_chars
) + 1] )
1081 "fatal flex scanner internal error--end of buffer missed" );
1083 if ( YY_CURRENT_BUFFER_LVALUE
->yy_fill_buffer
== 0 )
1084 { /* Don't try to fill the buffer, so this is an EOF. */
1085 if ( (yy_c_buf_p
) - (yytext_ptr
) - YY_MORE_ADJ
== 1 )
1087 /* We matched a single character, the EOB, so
1088 * treat this as a final EOF.
1090 return EOB_ACT_END_OF_FILE
;
1095 /* We matched some text prior to the EOB, first
1098 return EOB_ACT_LAST_MATCH
;
1102 /* Try to read more data. */
1104 /* First move last chars to start of buffer. */
1105 number_to_move
= (int) ((yy_c_buf_p
) - (yytext_ptr
)) - 1;
1107 for ( i
= 0; i
< number_to_move
; ++i
)
1108 *(dest
++) = *(source
++);
1110 if ( YY_CURRENT_BUFFER_LVALUE
->yy_buffer_status
== YY_BUFFER_EOF_PENDING
)
1111 /* don't do the read, it's not guaranteed to return an EOF,
1114 YY_CURRENT_BUFFER_LVALUE
->yy_n_chars
= (yy_n_chars
) = 0;
1119 YY_CURRENT_BUFFER_LVALUE
->yy_buf_size
- number_to_move
- 1;
1121 while ( num_to_read
<= 0 )
1122 { /* Not enough room in the buffer - grow it. */
1124 /* just a shorter name for the current buffer */
1125 YY_BUFFER_STATE b
= YY_CURRENT_BUFFER
;
1127 int yy_c_buf_p_offset
=
1128 (int) ((yy_c_buf_p
) - b
->yy_ch_buf
);
1130 if ( b
->yy_is_our_buffer
)
1132 int new_size
= b
->yy_buf_size
* 2;
1134 if ( new_size
<= 0 )
1135 b
->yy_buf_size
+= b
->yy_buf_size
/ 8;
1137 b
->yy_buf_size
*= 2;
1139 b
->yy_ch_buf
= (char *)
1140 /* Include room in for 2 EOB chars. */
1141 __ktrfmtrealloc((void *) b
->yy_ch_buf
,b
->yy_buf_size
+ 2 );
1144 /* Can't grow it, we don't own it. */
1147 if ( ! b
->yy_ch_buf
)
1149 "fatal error - scanner input buffer overflow" );
1151 (yy_c_buf_p
) = &b
->yy_ch_buf
[yy_c_buf_p_offset
];
1153 num_to_read
= YY_CURRENT_BUFFER_LVALUE
->yy_buf_size
-
1158 if ( num_to_read
> YY_READ_BUF_SIZE
)
1159 num_to_read
= YY_READ_BUF_SIZE
;
1161 /* Read in more data. */
1162 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE
->yy_ch_buf
[number_to_move
]),
1163 (yy_n_chars
), (size_t) num_to_read
);
1165 YY_CURRENT_BUFFER_LVALUE
->yy_n_chars
= (yy_n_chars
);
1168 if ( (yy_n_chars
) == 0 )
1170 if ( number_to_move
== YY_MORE_ADJ
)
1172 ret_val
= EOB_ACT_END_OF_FILE
;
1173 __ktrfmtrestart(__ktrfmtin
);
1178 ret_val
= EOB_ACT_LAST_MATCH
;
1179 YY_CURRENT_BUFFER_LVALUE
->yy_buffer_status
=
1180 YY_BUFFER_EOF_PENDING
;
1185 ret_val
= EOB_ACT_CONTINUE_SCAN
;
1187 if ((yy_size_t
) ((yy_n_chars
) + number_to_move
) > YY_CURRENT_BUFFER_LVALUE
->yy_buf_size
) {
1188 /* Extend the array by 50%, plus the number we really need. */
1189 yy_size_t new_size
= (yy_n_chars
) + number_to_move
+ ((yy_n_chars
) >> 1);
1190 YY_CURRENT_BUFFER_LVALUE
->yy_ch_buf
= (char *) __ktrfmtrealloc((void *) YY_CURRENT_BUFFER_LVALUE
->yy_ch_buf
,new_size
);
1191 if ( ! YY_CURRENT_BUFFER_LVALUE
->yy_ch_buf
)
1192 YY_FATAL_ERROR( "out of dynamic memory in yy_get_next_buffer()" );
1195 (yy_n_chars
) += number_to_move
;
1196 YY_CURRENT_BUFFER_LVALUE
->yy_ch_buf
[(yy_n_chars
)] = YY_END_OF_BUFFER_CHAR
;
1197 YY_CURRENT_BUFFER_LVALUE
->yy_ch_buf
[(yy_n_chars
) + 1] = YY_END_OF_BUFFER_CHAR
;
1199 (yytext_ptr
) = &YY_CURRENT_BUFFER_LVALUE
->yy_ch_buf
[0];
1204 /* yy_get_previous_state - get the state just before the EOB char was reached */
1206 static yy_state_type
yy_get_previous_state (void)
1208 register yy_state_type yy_current_state
;
1209 register char *yy_cp
;
1211 yy_current_state
= (yy_start
);
1213 for ( yy_cp
= (yytext_ptr
) + YY_MORE_ADJ
; yy_cp
< (yy_c_buf_p
); ++yy_cp
)
1215 register YY_CHAR yy_c
= (*yy_cp
? yy_ec
[YY_SC_TO_UI(*yy_cp
)] : 1);
1216 if ( yy_accept
[yy_current_state
] )
1218 (yy_last_accepting_state
) = yy_current_state
;
1219 (yy_last_accepting_cpos
) = yy_cp
;
1221 while ( yy_chk
[yy_base
[yy_current_state
] + yy_c
] != yy_current_state
)
1223 yy_current_state
= (int) yy_def
[yy_current_state
];
1224 if ( yy_current_state
>= 26 )
1225 yy_c
= yy_meta
[(unsigned int) yy_c
];
1227 yy_current_state
= yy_nxt
[yy_base
[yy_current_state
] + (unsigned int) yy_c
];
1230 return yy_current_state
;
1233 /* yy_try_NUL_trans - try to make a transition on the NUL character
1236 * next_state = yy_try_NUL_trans( current_state );
1238 static yy_state_type
yy_try_NUL_trans (yy_state_type yy_current_state
)
1240 register int yy_is_jam
;
1241 register char *yy_cp
= (yy_c_buf_p
);
1243 register YY_CHAR yy_c
= 1;
1244 if ( yy_accept
[yy_current_state
] )
1246 (yy_last_accepting_state
) = yy_current_state
;
1247 (yy_last_accepting_cpos
) = yy_cp
;
1249 while ( yy_chk
[yy_base
[yy_current_state
] + yy_c
] != yy_current_state
)
1251 yy_current_state
= (int) yy_def
[yy_current_state
];
1252 if ( yy_current_state
>= 26 )
1253 yy_c
= yy_meta
[(unsigned int) yy_c
];
1255 yy_current_state
= yy_nxt
[yy_base
[yy_current_state
] + (unsigned int) yy_c
];
1256 yy_is_jam
= (yy_current_state
== 25);
1258 return yy_is_jam
? 0 : yy_current_state
;
1263 static int yyinput (void)
1265 static int input (void)
1271 *(yy_c_buf_p
) = (yy_hold_char
);
1273 if ( *(yy_c_buf_p
) == YY_END_OF_BUFFER_CHAR
)
1275 /* yy_c_buf_p now points to the character we want to return.
1276 * If this occurs *before* the EOB characters, then it's a
1277 * valid NUL; if not, then we've hit the end of the buffer.
1279 if ( (yy_c_buf_p
) < &YY_CURRENT_BUFFER_LVALUE
->yy_ch_buf
[(yy_n_chars
)] )
1280 /* This was really a NUL. */
1281 *(yy_c_buf_p
) = '\0';
1284 { /* need more input */
1285 int offset
= (yy_c_buf_p
) - (yytext_ptr
);
1288 switch ( yy_get_next_buffer( ) )
1290 case EOB_ACT_LAST_MATCH
:
1291 /* This happens because yy_g_n_b()
1292 * sees that we've accumulated a
1293 * token and flags that we need to
1294 * try matching the token before
1295 * proceeding. But for input(),
1296 * there's no matching to consider.
1297 * So convert the EOB_ACT_LAST_MATCH
1298 * to EOB_ACT_END_OF_FILE.
1301 /* Reset buffer status. */
1302 __ktrfmtrestart(__ktrfmtin
);
1306 case EOB_ACT_END_OF_FILE
:
1308 if ( __ktrfmtwrap( ) )
1311 if ( ! (yy_did_buffer_switch_on_eof
) )
1320 case EOB_ACT_CONTINUE_SCAN
:
1321 (yy_c_buf_p
) = (yytext_ptr
) + offset
;
1327 c
= *(unsigned char *) (yy_c_buf_p
); /* cast for 8-bit char's */
1328 *(yy_c_buf_p
) = '\0'; /* preserve __ktrfmttext */
1329 (yy_hold_char
) = *++(yy_c_buf_p
);
1333 #endif /* ifndef YY_NO_INPUT */
1335 /** Immediately switch to a different input stream.
1336 * @param input_file A readable stream.
1338 * @note This function does not reset the start condition to @c INITIAL .
1340 void __ktrfmtrestart (FILE * input_file
)
1343 if ( ! YY_CURRENT_BUFFER
){
1344 __ktrfmtensure_buffer_stack ();
1345 YY_CURRENT_BUFFER_LVALUE
=
1346 __ktrfmt_create_buffer(__ktrfmtin
,YY_BUF_SIZE
);
1349 __ktrfmt_init_buffer(YY_CURRENT_BUFFER
,input_file
);
1350 __ktrfmt_load_buffer_state( );
1353 /** Switch to a different input buffer.
1354 * @param new_buffer The new input buffer.
1357 void __ktrfmt_switch_to_buffer (YY_BUFFER_STATE new_buffer
)
1360 /* TODO. We should be able to replace this entire function body
1362 * __ktrfmtpop_buffer_state();
1363 * __ktrfmtpush_buffer_state(new_buffer);
1365 __ktrfmtensure_buffer_stack ();
1366 if ( YY_CURRENT_BUFFER
== new_buffer
)
1369 if ( YY_CURRENT_BUFFER
)
1371 /* Flush out information for old buffer. */
1372 *(yy_c_buf_p
) = (yy_hold_char
);
1373 YY_CURRENT_BUFFER_LVALUE
->yy_buf_pos
= (yy_c_buf_p
);
1374 YY_CURRENT_BUFFER_LVALUE
->yy_n_chars
= (yy_n_chars
);
1377 YY_CURRENT_BUFFER_LVALUE
= new_buffer
;
1378 __ktrfmt_load_buffer_state( );
1380 /* We don't actually know whether we did this switch during
1381 * EOF (__ktrfmtwrap()) processing, but the only time this flag
1382 * is looked at is after __ktrfmtwrap() is called, so it's safe
1383 * to go ahead and always set it.
1385 (yy_did_buffer_switch_on_eof
) = 1;
1388 static void __ktrfmt_load_buffer_state (void)
1390 (yy_n_chars
) = YY_CURRENT_BUFFER_LVALUE
->yy_n_chars
;
1391 (yytext_ptr
) = (yy_c_buf_p
) = YY_CURRENT_BUFFER_LVALUE
->yy_buf_pos
;
1392 __ktrfmtin
= YY_CURRENT_BUFFER_LVALUE
->yy_input_file
;
1393 (yy_hold_char
) = *(yy_c_buf_p
);
1396 /** Allocate and initialize an input buffer state.
1397 * @param file A readable stream.
1398 * @param size The character buffer size in bytes. When in doubt, use @c YY_BUF_SIZE.
1400 * @return the allocated buffer state.
1402 YY_BUFFER_STATE
__ktrfmt_create_buffer (FILE * file
, int size
)
1406 b
= (YY_BUFFER_STATE
) __ktrfmtalloc(sizeof( struct yy_buffer_state
) );
1408 YY_FATAL_ERROR( "out of dynamic memory in __ktrfmt_create_buffer()" );
1410 b
->yy_buf_size
= size
;
1412 /* yy_ch_buf has to be 2 characters longer than the size given because
1413 * we need to put in 2 end-of-buffer characters.
1415 b
->yy_ch_buf
= (char *) __ktrfmtalloc(b
->yy_buf_size
+ 2 );
1416 if ( ! b
->yy_ch_buf
)
1417 YY_FATAL_ERROR( "out of dynamic memory in __ktrfmt_create_buffer()" );
1419 b
->yy_is_our_buffer
= 1;
1421 __ktrfmt_init_buffer(b
,file
);
1426 /** Destroy the buffer.
1427 * @param b a buffer created with __ktrfmt_create_buffer()
1430 void __ktrfmt_delete_buffer (YY_BUFFER_STATE b
)
1436 if ( b
== YY_CURRENT_BUFFER
) /* Not sure if we should pop here. */
1437 YY_CURRENT_BUFFER_LVALUE
= (YY_BUFFER_STATE
) 0;
1439 if ( b
->yy_is_our_buffer
)
1440 __ktrfmtfree((void *) b
->yy_ch_buf
);
1442 __ktrfmtfree((void *) b
);
1446 extern int isatty (int );
1447 #endif /* __cplusplus */
1449 /* Initializes or reinitializes a buffer.
1450 * This function is sometimes called more than once on the same buffer,
1451 * such as during a __ktrfmtrestart() or at EOF.
1453 static void __ktrfmt_init_buffer (YY_BUFFER_STATE b
, FILE * file
)
1458 __ktrfmt_flush_buffer(b
);
1460 b
->yy_input_file
= file
;
1461 b
->yy_fill_buffer
= 1;
1463 /* If b is the current buffer, then __ktrfmt_init_buffer was _probably_
1464 * called from __ktrfmtrestart() or through yy_get_next_buffer.
1465 * In that case, we don't want to reset the lineno or column.
1467 if (b
!= YY_CURRENT_BUFFER
){
1468 b
->yy_bs_lineno
= 1;
1469 b
->yy_bs_column
= 0;
1472 b
->yy_is_interactive
= file
? (isatty( fileno(file
) ) > 0) : 0;
1477 /** Discard all buffered characters. On the next scan, YY_INPUT will be called.
1478 * @param b the buffer state to be flushed, usually @c YY_CURRENT_BUFFER.
1481 void __ktrfmt_flush_buffer (YY_BUFFER_STATE b
)
1488 /* We always need two end-of-buffer characters. The first causes
1489 * a transition to the end-of-buffer state. The second causes
1490 * a jam in that state.
1492 b
->yy_ch_buf
[0] = YY_END_OF_BUFFER_CHAR
;
1493 b
->yy_ch_buf
[1] = YY_END_OF_BUFFER_CHAR
;
1495 b
->yy_buf_pos
= &b
->yy_ch_buf
[0];
1498 b
->yy_buffer_status
= YY_BUFFER_NEW
;
1500 if ( b
== YY_CURRENT_BUFFER
)
1501 __ktrfmt_load_buffer_state( );
1504 /** Pushes the new state onto the stack. The new state becomes
1505 * the current state. This function will allocate the stack
1507 * @param new_buffer The new state.
1510 void __ktrfmtpush_buffer_state (YY_BUFFER_STATE new_buffer
)
1512 if (new_buffer
== NULL
)
1515 __ktrfmtensure_buffer_stack();
1517 /* This block is copied from __ktrfmt_switch_to_buffer. */
1518 if ( YY_CURRENT_BUFFER
)
1520 /* Flush out information for old buffer. */
1521 *(yy_c_buf_p
) = (yy_hold_char
);
1522 YY_CURRENT_BUFFER_LVALUE
->yy_buf_pos
= (yy_c_buf_p
);
1523 YY_CURRENT_BUFFER_LVALUE
->yy_n_chars
= (yy_n_chars
);
1526 /* Only push if top exists. Otherwise, replace top. */
1527 if (YY_CURRENT_BUFFER
)
1528 (yy_buffer_stack_top
)++;
1529 YY_CURRENT_BUFFER_LVALUE
= new_buffer
;
1531 /* copied from __ktrfmt_switch_to_buffer. */
1532 __ktrfmt_load_buffer_state( );
1533 (yy_did_buffer_switch_on_eof
) = 1;
1536 /** Removes and deletes the top of the stack, if present.
1537 * The next element becomes the new top.
1540 void __ktrfmtpop_buffer_state (void)
1542 if (!YY_CURRENT_BUFFER
)
1545 __ktrfmt_delete_buffer(YY_CURRENT_BUFFER
);
1546 YY_CURRENT_BUFFER_LVALUE
= NULL
;
1547 if ((yy_buffer_stack_top
) > 0)
1548 --(yy_buffer_stack_top
);
1550 if (YY_CURRENT_BUFFER
) {
1551 __ktrfmt_load_buffer_state( );
1552 (yy_did_buffer_switch_on_eof
) = 1;
1556 /* Allocates the stack if it does not exist.
1557 * Guarantees space for at least one push.
1559 static void __ktrfmtensure_buffer_stack (void)
1563 if (!(yy_buffer_stack
)) {
1565 /* First allocation is just for 2 elements, since we don't know if this
1566 * scanner will even need a stack. We use 2 instead of 1 to avoid an
1567 * immediate realloc on the next call.
1570 (yy_buffer_stack
) = (struct yy_buffer_state
**)__ktrfmtalloc
1571 (num_to_alloc
* sizeof(struct yy_buffer_state
*)
1573 if ( ! (yy_buffer_stack
) )
1574 YY_FATAL_ERROR( "out of dynamic memory in __ktrfmtensure_buffer_stack()" );
1576 memset((yy_buffer_stack
), 0, num_to_alloc
* sizeof(struct yy_buffer_state
*));
1578 (yy_buffer_stack_max
) = num_to_alloc
;
1579 (yy_buffer_stack_top
) = 0;
1583 if ((yy_buffer_stack_top
) >= ((yy_buffer_stack_max
)) - 1){
1585 /* Increase the buffer to prepare for a possible push. */
1586 int grow_size
= 8 /* arbitrary grow size */;
1588 num_to_alloc
= (yy_buffer_stack_max
) + grow_size
;
1589 (yy_buffer_stack
) = (struct yy_buffer_state
**)__ktrfmtrealloc
1591 num_to_alloc
* sizeof(struct yy_buffer_state
*)
1593 if ( ! (yy_buffer_stack
) )
1594 YY_FATAL_ERROR( "out of dynamic memory in __ktrfmtensure_buffer_stack()" );
1596 /* zero only the new slots.*/
1597 memset((yy_buffer_stack
) + (yy_buffer_stack_max
), 0, grow_size
* sizeof(struct yy_buffer_state
*));
1598 (yy_buffer_stack_max
) = num_to_alloc
;
1602 /** Setup the input buffer state to scan directly from a user-specified character buffer.
1603 * @param base the character buffer
1604 * @param size the size in bytes of the character buffer
1606 * @return the newly allocated buffer state object.
1608 YY_BUFFER_STATE
__ktrfmt_scan_buffer (char * base
, yy_size_t size
)
1613 base
[size
-2] != YY_END_OF_BUFFER_CHAR
||
1614 base
[size
-1] != YY_END_OF_BUFFER_CHAR
)
1615 /* They forgot to leave room for the EOB's. */
1618 b
= (YY_BUFFER_STATE
) __ktrfmtalloc(sizeof( struct yy_buffer_state
) );
1620 YY_FATAL_ERROR( "out of dynamic memory in __ktrfmt_scan_buffer()" );
1622 b
->yy_buf_size
= size
- 2; /* "- 2" to take care of EOB's */
1623 b
->yy_buf_pos
= b
->yy_ch_buf
= base
;
1624 b
->yy_is_our_buffer
= 0;
1625 b
->yy_input_file
= 0;
1626 b
->yy_n_chars
= b
->yy_buf_size
;
1627 b
->yy_is_interactive
= 0;
1629 b
->yy_fill_buffer
= 0;
1630 b
->yy_buffer_status
= YY_BUFFER_NEW
;
1632 __ktrfmt_switch_to_buffer(b
);
1637 /** Setup the input buffer state to scan a string. The next call to __ktrfmtlex() will
1638 * scan from a @e copy of @a str.
1639 * @param yystr a NUL-terminated string to scan
1641 * @return the newly allocated buffer state object.
1642 * @note If you want to scan bytes that may contain NUL values, then use
1643 * __ktrfmt_scan_bytes() instead.
1645 YY_BUFFER_STATE
__ktrfmt_scan_string (yyconst
char * yystr
)
1648 return __ktrfmt_scan_bytes(yystr
,strlen(yystr
) );
1651 /** Setup the input buffer state to scan the given bytes. The next call to __ktrfmtlex() will
1652 * scan from a @e copy of @a bytes.
1653 * @param bytes the byte buffer to scan
1654 * @param len the number of bytes in the buffer pointed to by @a bytes.
1656 * @return the newly allocated buffer state object.
1658 YY_BUFFER_STATE
__ktrfmt_scan_bytes (yyconst
char * yybytes
, int _yybytes_len
)
1665 /* Get memory for full buffer, including space for trailing EOB's. */
1666 n
= _yybytes_len
+ 2;
1667 buf
= (char *) __ktrfmtalloc(n
);
1669 YY_FATAL_ERROR( "out of dynamic memory in __ktrfmt_scan_bytes()" );
1671 for ( i
= 0; i
< _yybytes_len
; ++i
)
1672 buf
[i
] = yybytes
[i
];
1674 buf
[_yybytes_len
] = buf
[_yybytes_len
+1] = YY_END_OF_BUFFER_CHAR
;
1676 b
= __ktrfmt_scan_buffer(buf
,n
);
1678 YY_FATAL_ERROR( "bad buffer in __ktrfmt_scan_bytes()" );
1680 /* It's okay to grow etc. this buffer, and we should throw it
1681 * away when we're done.
1683 b
->yy_is_our_buffer
= 1;
1688 #ifndef YY_EXIT_FAILURE
1689 #define YY_EXIT_FAILURE 2
1692 static void yy_fatal_error (yyconst
char* msg
)
1694 (void) fprintf( stderr
, "%s\n", msg
);
1695 exit( YY_EXIT_FAILURE
);
1698 /* Redefine yyless() so it works in section 3 code. */
1704 /* Undo effects of setting up __ktrfmttext. */ \
1705 int yyless_macro_arg = (n); \
1706 YY_LESS_LINENO(yyless_macro_arg);\
1707 __ktrfmttext[__ktrfmtleng] = (yy_hold_char); \
1708 (yy_c_buf_p) = __ktrfmttext + yyless_macro_arg; \
1709 (yy_hold_char) = *(yy_c_buf_p); \
1710 *(yy_c_buf_p) = '\0'; \
1711 __ktrfmtleng = yyless_macro_arg; \
1715 /* Accessor methods (get/set functions) to struct members. */
1717 /** Get the current line number.
1720 int __ktrfmtget_lineno (void)
1723 return __ktrfmtlineno
;
1726 /** Get the input stream.
1729 FILE *__ktrfmtget_in (void)
1734 /** Get the output stream.
1737 FILE *__ktrfmtget_out (void)
1742 /** Get the length of the current token.
1745 int __ktrfmtget_leng (void)
1747 return __ktrfmtleng
;
1750 /** Get the current token.
1754 char *__ktrfmtget_text (void)
1756 return __ktrfmttext
;
1759 /** Set the current line number.
1760 * @param line_number
1763 void __ktrfmtset_lineno (int line_number
)
1766 __ktrfmtlineno
= line_number
;
1769 /** Set the input stream. This does not discard the current
1771 * @param in_str A readable stream.
1773 * @see __ktrfmt_switch_to_buffer
1775 void __ktrfmtset_in (FILE * in_str
)
1777 __ktrfmtin
= in_str
;
1780 void __ktrfmtset_out (FILE * out_str
)
1782 __ktrfmtout
= out_str
;
1785 int __ktrfmtget_debug (void)
1787 return __ktrfmt_flex_debug
;
1790 void __ktrfmtset_debug (int bdebug
)
1792 __ktrfmt_flex_debug
= bdebug
;
1795 static int yy_init_globals (void)
1797 /* Initialization is the same as for the non-reentrant scanner.
1798 * This function is called from __ktrfmtlex_destroy(), so don't allocate here.
1801 (yy_buffer_stack
) = 0;
1802 (yy_buffer_stack_top
) = 0;
1803 (yy_buffer_stack_max
) = 0;
1804 (yy_c_buf_p
) = (char *) 0;
1808 /* Defined in main.c */
1811 __ktrfmtout
= stdout
;
1813 __ktrfmtin
= (FILE *) 0;
1814 __ktrfmtout
= (FILE *) 0;
1817 /* For future reference: Set errno on error, since we are called by
1818 * __ktrfmtlex_init()
1823 /* __ktrfmtlex_destroy is for both reentrant and non-reentrant scanners. */
1824 int __ktrfmtlex_destroy (void)
1827 /* Pop the buffer stack, destroying each element. */
1828 while(YY_CURRENT_BUFFER
){
1829 __ktrfmt_delete_buffer(YY_CURRENT_BUFFER
);
1830 YY_CURRENT_BUFFER_LVALUE
= NULL
;
1831 __ktrfmtpop_buffer_state();
1834 /* Destroy the stack itself. */
1835 __ktrfmtfree((yy_buffer_stack
) );
1836 (yy_buffer_stack
) = NULL
;
1838 /* Reset the globals. This is important in a non-reentrant scanner so the next time
1839 * __ktrfmtlex() is called, initialization will occur. */
1846 * Internal utility routines.
1850 static void yy_flex_strncpy (char* s1
, yyconst
char * s2
, int n
)
1853 for ( i
= 0; i
< n
; ++i
)
1858 #ifdef YY_NEED_STRLEN
1859 static int yy_flex_strlen (yyconst
char * s
)
1862 for ( n
= 0; s
[n
]; ++n
)
1869 void *__ktrfmtalloc (yy_size_t size
)
1871 return (void *) malloc( size
);
1874 void *__ktrfmtrealloc (void * ptr
, yy_size_t size
)
1876 /* The cast to (char *) in the following accommodates both
1877 * implementations that use char* generic pointers, and those
1878 * that use void* generic pointers. It works with the latter
1879 * because both ANSI C and C++ allow castless assignment from
1880 * any pointer type to void*, and deal with argument conversions
1881 * as though doing an assignment.
1883 return (void *) realloc( (char *) ptr
, size
);
1886 void __ktrfmtfree (void * ptr
)
1888 free( (char *) ptr
); /* see __ktrfmtrealloc() for (char *) cast */
1891 #define YYTABLES_NAME "yytables"
1893 #line 137 "ktrfmt.l"