1#line 2 "jsgf_scanner.c"
3#line 4 "jsgf_scanner.c"
5#define YY_INT_ALIGNED short int
10#define YY_FLEX_MAJOR_VERSION 2
11#define YY_FLEX_MINOR_VERSION 5
12#define YY_FLEX_SUBMINOR_VERSION 35
13#if YY_FLEX_SUBMINOR_VERSION > 0
34#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
39#ifndef __STDC_LIMIT_MACROS
40#define __STDC_LIMIT_MACROS 1
44typedef int8_t flex_int8_t;
45typedef uint8_t flex_uint8_t;
46typedef int16_t flex_int16_t;
47typedef uint16_t flex_uint16_t;
48typedef int32_t flex_int32_t;
49typedef uint32_t flex_uint32_t;
51typedef signed char flex_int8_t;
52typedef short int flex_int16_t;
53typedef int flex_int32_t;
54typedef unsigned char flex_uint8_t;
55typedef unsigned short int flex_uint16_t;
56typedef unsigned int flex_uint32_t;
61#define INT8_MIN (-128)
64#define INT16_MIN (-32767-1)
67#define INT32_MIN (-2147483647-1)
73#define INT16_MAX (32767)
76#define INT32_MAX (2147483647)
79#define UINT8_MAX (255U)
82#define UINT16_MAX (65535U)
85#define UINT32_MAX (4294967295U)
119#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
122#ifndef YY_TYPEDEF_YY_SCANNER_T
123#define YY_TYPEDEF_YY_SCANNER_T
124typedef void* yyscan_t;
129#define yyin yyg->yyin_r
130#define yyout yyg->yyout_r
131#define yyextra yyg->yyextra_r
132#define yyleng yyg->yyleng_r
133#define yytext yyg->yytext_r
134#define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
135#define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
136#define yy_flex_debug yyg->yy_flex_debug_r
142#define BEGIN yyg->yy_start = 1 + 2 *
148#define YY_START ((yyg->yy_start - 1) / 2)
149#define YYSTATE YY_START
152#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
155#define YY_NEW_FILE yyrestart(yyin ,yyscanner )
157#define YY_END_OF_BUFFER_CHAR 0
161#define YY_BUF_SIZE 16384
166#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
168#ifndef YY_TYPEDEF_YY_BUFFER_STATE
169#define YY_TYPEDEF_YY_BUFFER_STATE
173#define EOB_ACT_CONTINUE_SCAN 0
174#define EOB_ACT_END_OF_FILE 1
175#define EOB_ACT_LAST_MATCH 2
184 #define YY_LESS_LINENO(n) \
187 for ( yyl = n; yyl < yyleng; ++yyl )\
188 if ( yytext[yyl] == '\n' )\
197 int yyless_macro_arg = (n); \
198 YY_LESS_LINENO(yyless_macro_arg);\
199 *yy_cp = yyg->yy_hold_char; \
200 YY_RESTORE_YY_MORE_OFFSET \
201 yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
202 YY_DO_BEFORE_ACTION; \
206#define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
208#ifndef YY_TYPEDEF_YY_SIZE_T
209#define YY_TYPEDEF_YY_SIZE_T
210typedef size_t yy_size_t;
213#ifndef YY_STRUCT_YY_BUFFER_STATE
214#define YY_STRUCT_YY_BUFFER_STATE
225 yy_size_t yy_buf_size;
236 int yy_is_our_buffer;
243 int yy_is_interactive;
259 int yy_buffer_status;
261#define YY_BUFFER_NEW 0
262#define YY_BUFFER_NORMAL 1
273#define YY_BUFFER_EOF_PENDING 2
284#define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
285 ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
291#define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
293void yyrestart (FILE *input_file ,yyscan_t yyscanner );
294void yy_switch_to_buffer (
YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
295YY_BUFFER_STATE yy_create_buffer (FILE *file,
int size ,yyscan_t yyscanner );
298void yypush_buffer_state (
YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
299void yypop_buffer_state (yyscan_t yyscanner );
301static void yyensure_buffer_stack (yyscan_t yyscanner );
302static void yy_load_buffer_state (yyscan_t yyscanner );
303static void yy_init_buffer (
YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner );
305#define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER ,yyscanner)
307YY_BUFFER_STATE yy_scan_buffer (
char *base,yy_size_t size ,yyscan_t yyscanner );
308YY_BUFFER_STATE yy_scan_string (yyconst
char *yy_str ,yyscan_t yyscanner );
309YY_BUFFER_STATE yy_scan_bytes (yyconst
char *bytes,
int len ,yyscan_t yyscanner );
311void *
yyalloc (yy_size_t ,yyscan_t yyscanner );
312void *yyrealloc (
void *,yy_size_t ,yyscan_t yyscanner );
313void yyfree (
void * ,yyscan_t yyscanner );
315#define yy_new_buffer yy_create_buffer
317#define yy_set_interactive(is_interactive) \
319 if ( ! YY_CURRENT_BUFFER ){ \
320 yyensure_buffer_stack (yyscanner); \
321 YY_CURRENT_BUFFER_LVALUE = \
322 yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
324 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
327#define yy_set_bol(at_bol) \
329 if ( ! YY_CURRENT_BUFFER ){\
330 yyensure_buffer_stack (yyscanner); \
331 YY_CURRENT_BUFFER_LVALUE = \
332 yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
334 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
337#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
342#define YY_SKIP_YYWRAP
344typedef unsigned char YY_CHAR;
346typedef int yy_state_type;
348#define yytext_ptr yytext_r
350static yy_state_type yy_get_previous_state (yyscan_t yyscanner );
351static yy_state_type yy_try_NUL_trans (yy_state_type current_state ,yyscan_t yyscanner);
352static int yy_get_next_buffer (yyscan_t yyscanner );
353static void yy_fatal_error (yyconst
char msg[] ,yyscan_t yyscanner );
358#define YY_DO_BEFORE_ACTION \
359 yyg->yytext_ptr = yy_bp; \
360 yyleng = (size_t) (yy_cp - yy_bp); \
361 yyg->yy_hold_char = *yy_cp; \
363 yyg->yy_c_buf_p = yy_cp;
365#define YY_NUM_RULES 22
366#define YY_END_OF_BUFFER 23
371 flex_int32_t yy_verify;
374static yyconst flex_int16_t yy_accept[98] =
376 0, 0, 0, 0, 0, 0, 0, 0, 23, 22,
377 1, 22, 22, 22, 22, 22, 22, 22, 5, 1,
378 5, 17, 1, 17, 21, 21, 18, 21, 21, 9,
379 1, 9, 0, 3, 0, 0, 0, 0, 0, 0,
380 4, 17, 17, 0, 17, 17, 7, 0, 20, 0,
381 0, 0, 0, 0, 16, 8, 0, 0, 2, 14,
382 0, 0, 0, 0, 19, 0, 17, 0, 17, 17,
383 0, 0, 6, 20, 0, 15, 0, 0, 16, 0,
384 0, 0, 0, 0, 19, 0, 0, 0, 10, 0,
385 0, 0, 0, 12, 13, 11, 0
389static yyconst flex_int32_t yy_ec[256] =
391 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
392 1, 1, 2, 1, 1, 1, 1, 1, 1, 1,
393 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
394 1, 2, 1, 4, 5, 1, 1, 1, 1, 6,
395 6, 7, 6, 1, 8, 9, 10, 11, 11, 11,
396 11, 11, 11, 11, 11, 11, 11, 1, 12, 13,
397 6, 14, 1, 1, 1, 1, 1, 1, 1, 15,
398 16, 1, 1, 17, 1, 1, 1, 1, 1, 1,
399 1, 1, 18, 1, 1, 1, 1, 1, 1, 1,
400 6, 19, 6, 1, 1, 1, 20, 21, 22, 1,
402 23, 1, 24, 1, 25, 1, 1, 26, 27, 1,
403 28, 29, 1, 30, 1, 31, 32, 1, 1, 1,
404 1, 1, 33, 6, 34, 1, 1, 1, 1, 1,
405 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
406 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
407 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
408 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
409 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
410 1, 1, 1, 1, 1, 1, 35, 1, 1, 1,
411 36, 1, 1, 1, 1, 1, 1, 1, 1, 1,
413 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
414 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
415 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
416 1, 1, 1, 1, 1, 1, 1, 1, 37, 1,
417 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
421static yyconst flex_int32_t yy_meta[38] =
423 1, 2, 2, 1, 1, 2, 2, 1, 1, 2,
424 1, 2, 3, 3, 1, 1, 1, 1, 1, 1,
425 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
429static yyconst flex_int16_t yy_base[113] =
431 0, 36, 4, 12, 72, 105, 14, 20, 135, 312,
432 312, 117, 2, 0, 103, 105, 99, 95, 312, 312,
433 119, 0, 312, 138, 312, 21, 312, 0, 1, 312,
434 312, 118, 109, 312, 123, 111, 104, 94, 101, 85,
435 312, 0, 171, 14, 0, 204, 312, 109, 113, 41,
436 106, 96, 21, 23, 312, 312, 88, 98, 312, 312,
437 73, 71, 70, 89, 312, 44, 0, 39, 0, 237,
438 43, 90, 312, 312, 57, 312, 37, 69, 43, 77,
439 64, 57, 58, 64, 76, 94, 79, 59, 312, 39,
440 14, 14, 4, 312, 312, 312, 312, 271, 274, 277,
442 280, 283, 0, 285, 288, 290, 293, 296, 299, 302,
446static yyconst flex_int16_t yy_def[113] =
448 98, 98, 99, 99, 100, 100, 101, 101, 97, 97,
449 97, 97, 97, 102, 97, 97, 97, 97, 97, 97,
450 97, 103, 97, 104, 97, 97, 97, 105, 106, 97,
451 97, 97, 97, 97, 107, 102, 97, 97, 97, 97,
452 97, 103, 104, 108, 103, 109, 97, 97, 110, 97,
453 97, 105, 106, 111, 97, 97, 97, 107, 97, 97,
454 97, 97, 97, 97, 97, 112, 43, 108, 43, 109,
455 97, 110, 97, 97, 97, 97, 106, 111, 106, 97,
456 97, 97, 97, 97, 108, 112, 97, 97, 97, 97,
457 97, 97, 97, 97, 97, 97, 0, 97, 97, 97,
459 97, 97, 97, 97, 97, 97, 97, 97, 97, 97,
463static yyconst flex_int16_t yy_nxt[350] =
465 42, 11, 11, 97, 12, 20, 11, 97, 34, 13,
466 21, 35, 14, 20, 11, 31, 11, 65, 21, 54,
467 32, 31, 11, 15, 16, 53, 32, 47, 17, 48,
468 49, 50, 66, 96, 55, 95, 18, 11, 11, 54,
469 12, 78, 65, 51, 94, 13, 44, 85, 14, 48,
470 74, 50, 74, 87, 55, 54, 79, 66, 93, 15,
471 16, 54, 86, 51, 17, 51, 74, 88, 74, 88,
472 55, 53, 18, 23, 11, 24, 55, 25, 25, 65,
473 33, 26, 92, 27, 28, 25, 91, 78, 74, 87,
474 90, 89, 73, 84, 66, 83, 44, 85, 82, 81,
476 59, 51, 79, 80, 29, 25, 23, 11, 24, 76,
477 25, 25, 86, 75, 26, 73, 27, 28, 25, 71,
478 64, 63, 62, 61, 60, 59, 57, 56, 41, 40,
479 39, 38, 37, 33, 97, 97, 97, 29, 25, 44,
480 44, 45, 97, 44, 44, 97, 97, 44, 97, 44,
481 44, 44, 97, 97, 97, 97, 46, 97, 97, 97,
482 97, 97, 97, 97, 97, 97, 97, 97, 97, 97,
483 44, 44, 44, 44, 45, 97, 44, 44, 97, 97,
484 44, 97, 44, 44, 44, 97, 97, 97, 97, 46,
485 97, 97, 97, 97, 97, 97, 97, 97, 97, 97,
487 97, 97, 97, 44, 44, 68, 44, 69, 97, 68,
488 68, 97, 97, 68, 97, 68, 68, 68, 97, 97,
489 97, 97, 70, 97, 97, 97, 97, 97, 97, 97,
490 97, 97, 97, 97, 97, 97, 68, 68, 68, 44,
491 69, 97, 68, 68, 97, 97, 68, 97, 68, 68,
492 68, 97, 97, 97, 97, 70, 97, 97, 97, 97,
493 97, 97, 97, 97, 97, 97, 97, 97, 97, 68,
494 68, 10, 10, 10, 19, 19, 19, 22, 22, 22,
495 30, 30, 30, 36, 36, 43, 43, 43, 52, 52,
496 53, 53, 53, 58, 58, 58, 44, 44, 44, 67,
498 67, 67, 72, 72, 72, 77, 77, 77, 68, 68,
499 68, 9, 97, 97, 97, 97, 97, 97, 97, 97,
500 97, 97, 97, 97, 97, 97, 97, 97, 97, 97,
501 97, 97, 97, 97, 97, 97, 97, 97, 97, 97,
502 97, 97, 97, 97, 97, 97, 97, 97, 97
505static yyconst flex_int16_t yy_chk[350] =
507 103, 1, 1, 0, 1, 3, 3, 0, 13, 1,
508 3, 13, 1, 4, 4, 7, 7, 44, 4, 29,
509 7, 8, 8, 1, 1, 54, 8, 26, 1, 26,
510 26, 26, 44, 93, 29, 92, 1, 2, 2, 53,
511 2, 54, 68, 26, 91, 2, 66, 66, 2, 50,
512 50, 50, 71, 71, 53, 77, 54, 68, 90, 2,
513 2, 79, 66, 50, 2, 71, 75, 75, 88, 88,
514 77, 78, 2, 5, 5, 5, 79, 5, 5, 85,
515 84, 5, 83, 5, 5, 5, 82, 78, 87, 87,
516 81, 80, 72, 64, 85, 63, 86, 86, 62, 61,
518 58, 87, 78, 57, 5, 5, 6, 6, 6, 52,
519 6, 6, 86, 51, 6, 49, 6, 6, 6, 48,
520 40, 39, 38, 37, 36, 35, 33, 32, 21, 18,
521 17, 16, 15, 12, 9, 0, 0, 6, 6, 24,
522 24, 24, 0, 24, 24, 0, 0, 24, 0, 24,
523 24, 24, 0, 0, 0, 0, 24, 0, 0, 0,
524 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
525 24, 24, 43, 43, 43, 0, 43, 43, 0, 0,
526 43, 0, 43, 43, 43, 0, 0, 0, 0, 43,
527 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
529 0, 0, 0, 43, 43, 46, 46, 46, 0, 46,
530 46, 0, 0, 46, 0, 46, 46, 46, 0, 0,
531 0, 0, 46, 0, 0, 0, 0, 0, 0, 0,
532 0, 0, 0, 0, 0, 0, 46, 46, 70, 70,
533 70, 0, 70, 70, 0, 0, 70, 0, 70, 70,
534 70, 0, 0, 0, 0, 70, 0, 0, 0, 0,
535 0, 0, 0, 0, 0, 0, 0, 0, 0, 70,
536 70, 98, 98, 98, 99, 99, 99, 100, 100, 100,
537 101, 101, 101, 102, 102, 104, 104, 104, 105, 105,
538 106, 106, 106, 107, 107, 107, 108, 108, 108, 109,
540 109, 109, 110, 110, 110, 111, 111, 111, 112, 112,
541 112, 97, 97, 97, 97, 97, 97, 97, 97, 97,
542 97, 97, 97, 97, 97, 97, 97, 97, 97, 97,
543 97, 97, 97, 97, 97, 97, 97, 97, 97, 97,
544 97, 97, 97, 97, 97, 97, 97, 97, 97
548static yyconst flex_int32_t yy_rule_can_match_eol[23] =
5501, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1,
556#define REJECT reject_used_but_not_detected
557#define yymore() yymore_used_but_not_detected
559#define YY_RESTORE_YY_MORE_OFFSET
560#line 1 "_jsgf_scanner.l"
598#line 39 "_jsgf_scanner.l"
601#include "jsgf_parser.h"
606#line 607 "jsgf_scanner.c"
613#ifndef YY_NO_UNISTD_H
622#define YY_EXTRA_TYPE void *
630 YY_EXTRA_TYPE yyextra_r;
633 FILE *yyin_r, *yyout_r;
643 int yy_did_buffer_switch_on_eof;
644 int yy_start_stack_ptr;
645 int yy_start_stack_depth;
647 yy_state_type yy_last_accepting_state;
648 char* yy_last_accepting_cpos;
661static int yy_init_globals (yyscan_t yyscanner );
665 # define yylval yyg->yylval_r
667int yylex_init (yyscan_t* scanner);
669int yylex_init_extra (YY_EXTRA_TYPE user_defined,yyscan_t* scanner);
674int yylex_destroy (yyscan_t yyscanner );
676int yyget_debug (yyscan_t yyscanner );
678void yyset_debug (
int debug_flag ,yyscan_t yyscanner );
680YY_EXTRA_TYPE yyget_extra (yyscan_t yyscanner );
682void yyset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
684FILE *yyget_in (yyscan_t yyscanner );
686void yyset_in (FILE * in_str ,yyscan_t yyscanner );
688FILE *yyget_out (yyscan_t yyscanner );
690void yyset_out (FILE * out_str ,yyscan_t yyscanner );
692int yyget_leng (yyscan_t yyscanner );
694char *yyget_text (yyscan_t yyscanner );
696int yyget_lineno (yyscan_t yyscanner );
698void yyset_lineno (
int line_number ,yyscan_t yyscanner );
700YYSTYPE * yyget_lval (yyscan_t yyscanner );
702void yyset_lval (
YYSTYPE * yylval_param ,yyscan_t yyscanner );
708#ifndef YY_SKIP_YYWRAP
710extern "C" int yywrap (yyscan_t yyscanner );
712extern int yywrap (yyscan_t yyscanner );
716 static void yyunput (
int c,
char *buf_ptr ,yyscan_t yyscanner);
719static void yy_flex_strncpy (
char *,yyconst
char *,
int ,yyscan_t yyscanner);
723static int yy_flex_strlen (yyconst
char * ,yyscan_t yyscanner);
729static int yyinput (yyscan_t yyscanner );
731static int input (yyscan_t yyscanner );
737#ifndef YY_READ_BUF_SIZE
738#define YY_READ_BUF_SIZE 8192
746#define ECHO do { if (fwrite( yytext, yyleng, 1, yyout )) {} } while (0)
753#define YY_INPUT(buf,result,max_size) \
754 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
758 for ( n = 0; n < max_size && \
759 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
762 buf[n++] = (char) c; \
763 if ( c == EOF && ferror( yyin ) ) \
764 YY_FATAL_ERROR( "input in flex scanner failed" ); \
770 while ( (result = fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
772 if( errno != EINTR) \
774 YY_FATAL_ERROR( "input in flex scanner failed" ); \
790#define yyterminate() return YY_NULL
794#ifndef YY_START_STACK_INCR
795#define YY_START_STACK_INCR 25
799#ifndef YY_FATAL_ERROR
800#define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
809#define YY_DECL_IS_OURS 1
812 (
YYSTYPE * yylval_param ,yyscan_t yyscanner);
814#define YY_DECL int yylex \
815 (YYSTYPE * yylval_param , yyscan_t yyscanner)
821#ifndef YY_USER_ACTION
822#define YY_USER_ACTION
827#define YY_BREAK break;
830#define YY_RULE_SETUP \
837 register yy_state_type yy_current_state;
838 register char *yy_cp, *yy_bp;
842#line 59 "_jsgf_scanner.l"
845#line 846 "jsgf_scanner.c"
847 yylval = yylval_param;
857 if ( ! yyg->yy_start )
866 if ( ! YY_CURRENT_BUFFER ) {
867 yyensure_buffer_stack (yyscanner);
868 YY_CURRENT_BUFFER_LVALUE =
869 yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
872 yy_load_buffer_state(yyscanner );
877 yy_cp = yyg->yy_c_buf_p;
880 *yy_cp = yyg->yy_hold_char;
887 yy_current_state = yyg->yy_start;
891 register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
892 if ( yy_accept[yy_current_state] )
894 yyg->yy_last_accepting_state = yy_current_state;
895 yyg->yy_last_accepting_cpos = yy_cp;
897 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
899 yy_current_state = (int) yy_def[yy_current_state];
900 if ( yy_current_state >= 98 )
901 yy_c = yy_meta[(
unsigned int) yy_c];
903 yy_current_state = yy_nxt[yy_base[yy_current_state] + (
unsigned int) yy_c];
906 while ( yy_base[yy_current_state] != 312 );
909 yy_act = yy_accept[yy_current_state];
912 yy_cp = yyg->yy_last_accepting_cpos;
913 yy_current_state = yyg->yy_last_accepting_state;
914 yy_act = yy_accept[yy_current_state];
919 if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
922 for ( yyl = 0; yyl < yyleng; ++yyl )
923 if ( yytext[yyl] ==
'\n' )
937 *yy_cp = yyg->yy_hold_char;
938 yy_cp = yyg->yy_last_accepting_cpos;
939 yy_current_state = yyg->yy_last_accepting_state;
945#line 61 "_jsgf_scanner.l"
951#line 62 "_jsgf_scanner.l"
956#line 63 "_jsgf_scanner.l"
961#line 64 "_jsgf_scanner.l"
966#line 65 "_jsgf_scanner.l"
972#line 67 "_jsgf_scanner.l"
977#line 68 "_jsgf_scanner.l"
978{ BEGIN(DECLCOMMENT); }
982#line 69 "_jsgf_scanner.l"
987#line 70 "_jsgf_scanner.l"
992#line 72 "_jsgf_scanner.l"
993{BEGIN(DECL);
return HEADER;}
997#line 73 "_jsgf_scanner.l"
998{BEGIN(DECL);
return GRAMMAR;}
1002#line 74 "_jsgf_scanner.l"
1003{BEGIN(DECL);
return IMPORT;}
1007#line 75 "_jsgf_scanner.l"
1008{BEGIN(DECL);
return PUBLIC;}
1013#line 77 "_jsgf_scanner.l"
1014{ BEGIN(DECL); yylval->name = strdup(yytext);
return RULENAME; }
1019#line 78 "_jsgf_scanner.l"
1020{ yylval->name = strdup(yytext);
return RULENAME; }
1025#line 80 "_jsgf_scanner.l"
1026{ yylval->name = strdup(yytext);
return TAG; }
1030#line 81 "_jsgf_scanner.l"
1031{ yylval->name = strdup(yytext);
return TOKEN; }
1035#line 82 "_jsgf_scanner.l"
1036{ BEGIN(INITIAL);
return yytext[0]; }
1041#line 83 "_jsgf_scanner.l"
1042{ yylval->name = strdup(yytext);
return TOKEN; }
1046#line 84 "_jsgf_scanner.l"
1047{ yylval->weight =
atof_c(yytext+1);
return WEIGHT; }
1051#line 85 "_jsgf_scanner.l"
1056#line 87 "_jsgf_scanner.l"
1059#line 1060 "jsgf_scanner.c"
1060case YY_STATE_EOF(INITIAL):
1061case YY_STATE_EOF(COMMENT):
1062case YY_STATE_EOF(DECL):
1063case YY_STATE_EOF(DECLCOMMENT):
1066 case YY_END_OF_BUFFER:
1069 int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
1072 *yy_cp = yyg->yy_hold_char;
1073 YY_RESTORE_YY_MORE_OFFSET
1075 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1086 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1087 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1088 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1098 if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
1100 yy_state_type yy_next_state;
1102 yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
1104 yy_current_state = yy_get_previous_state( yyscanner );
1115 yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
1117 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1119 if ( yy_next_state )
1122 yy_cp = ++yyg->yy_c_buf_p;
1123 yy_current_state = yy_next_state;
1129 yy_cp = yyg->yy_c_buf_p;
1130 goto yy_find_action;
1134 else switch ( yy_get_next_buffer( yyscanner ) )
1136 case EOB_ACT_END_OF_FILE:
1138 yyg->yy_did_buffer_switch_on_eof = 0;
1140 if ( yywrap(yyscanner ) )
1151 yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
1153 yy_act = YY_STATE_EOF(YY_START);
1159 if ( ! yyg->yy_did_buffer_switch_on_eof )
1165 case EOB_ACT_CONTINUE_SCAN:
1167 yyg->yytext_ptr + yy_amount_of_matched_text;
1169 yy_current_state = yy_get_previous_state( yyscanner );
1171 yy_cp = yyg->yy_c_buf_p;
1172 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1175 case EOB_ACT_LAST_MATCH:
1177 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
1179 yy_current_state = yy_get_previous_state( yyscanner );
1181 yy_cp = yyg->yy_c_buf_p;
1182 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1183 goto yy_find_action;
1190 "fatal flex scanner internal error--no action found" );
1202static int yy_get_next_buffer (yyscan_t yyscanner)
1205 register char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1206 register char *source = yyg->yytext_ptr;
1207 register int number_to_move, i;
1210 if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
1212 "fatal flex scanner internal error--end of buffer missed" );
1214 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1216 if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
1221 return EOB_ACT_END_OF_FILE;
1229 return EOB_ACT_LAST_MATCH;
1236 number_to_move = (int) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
1238 for ( i = 0; i < number_to_move; ++i )
1239 *(dest++) = *(source++);
1241 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1245 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
1250 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1252 while ( num_to_read <= 0 )
1258 int yy_c_buf_p_offset =
1259 (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
1261 if ( b->yy_is_our_buffer )
1263 int new_size = b->yy_buf_size * 2;
1265 if ( new_size <= 0 )
1266 b->yy_buf_size += b->yy_buf_size / 8;
1268 b->yy_buf_size *= 2;
1270 b->yy_ch_buf = (
char *)
1272 yyrealloc((
void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner );
1278 if ( ! b->yy_ch_buf )
1280 "fatal error - scanner input buffer overflow" );
1282 yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1284 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1289 if ( num_to_read > YY_READ_BUF_SIZE )
1290 num_to_read = YY_READ_BUF_SIZE;
1293 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1294 yyg->yy_n_chars, (
size_t) num_to_read );
1296 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1299 if ( yyg->yy_n_chars == 0 )
1301 if ( number_to_move == YY_MORE_ADJ )
1303 ret_val = EOB_ACT_END_OF_FILE;
1304 yyrestart(yyin ,yyscanner);
1309 ret_val = EOB_ACT_LAST_MATCH;
1310 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1311 YY_BUFFER_EOF_PENDING;
1316 ret_val = EOB_ACT_CONTINUE_SCAN;
1318 if ((yy_size_t) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1320 yy_size_t new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
1321 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (
char *) yyrealloc((
void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ,yyscanner );
1322 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1323 YY_FATAL_ERROR(
"out of dynamic memory in yy_get_next_buffer()" );
1326 yyg->yy_n_chars += number_to_move;
1327 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1328 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1330 yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1337 static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
1339 register yy_state_type yy_current_state;
1340 register char *yy_cp;
1343 yy_current_state = yyg->yy_start;
1345 for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
1347 register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1348 if ( yy_accept[yy_current_state] )
1350 yyg->yy_last_accepting_state = yy_current_state;
1351 yyg->yy_last_accepting_cpos = yy_cp;
1353 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1355 yy_current_state = (int) yy_def[yy_current_state];
1356 if ( yy_current_state >= 98 )
1357 yy_c = yy_meta[(
unsigned int) yy_c];
1359 yy_current_state = yy_nxt[yy_base[yy_current_state] + (
unsigned int) yy_c];
1362 return yy_current_state;
1370 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner)
1372 register int yy_is_jam;
1374 register char *yy_cp = yyg->yy_c_buf_p;
1376 register YY_CHAR yy_c = 1;
1377 if ( yy_accept[yy_current_state] )
1379 yyg->yy_last_accepting_state = yy_current_state;
1380 yyg->yy_last_accepting_cpos = yy_cp;
1382 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1384 yy_current_state = (int) yy_def[yy_current_state];
1385 if ( yy_current_state >= 98 )
1386 yy_c = yy_meta[(
unsigned int) yy_c];
1388 yy_current_state = yy_nxt[yy_base[yy_current_state] + (
unsigned int) yy_c];
1389 yy_is_jam = (yy_current_state == 97);
1391 return yy_is_jam ? 0 : yy_current_state;
1394 static void yyunput (
int c,
register char * yy_bp , yyscan_t yyscanner)
1396 register char *yy_cp;
1399 yy_cp = yyg->yy_c_buf_p;
1402 *yy_cp = yyg->yy_hold_char;
1404 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1407 register int number_to_move = yyg->yy_n_chars + 2;
1408 register char *dest = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[
1409 YY_CURRENT_BUFFER_LVALUE->yy_buf_size + 2];
1410 register char *source =
1411 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move];
1413 while ( source > YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1414 *--dest = *--source;
1416 yy_cp += (int) (dest - source);
1417 yy_bp += (int) (dest - source);
1418 YY_CURRENT_BUFFER_LVALUE->yy_n_chars =
1419 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_buf_size;
1421 if ( yy_cp < YY_CURRENT_BUFFER_LVALUE->yy_ch_buf + 2 )
1422 YY_FATAL_ERROR(
"flex scanner push-back overflow" );
1425 *--yy_cp = (char) c;
1431 yyg->yytext_ptr = yy_bp;
1432 yyg->yy_hold_char = *yy_cp;
1433 yyg->yy_c_buf_p = yy_cp;
1438 static int yyinput (yyscan_t yyscanner)
1440 static int input (yyscan_t yyscanner)
1447 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1449 if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1455 if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
1457 *yyg->yy_c_buf_p =
'\0';
1461 int offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
1464 switch ( yy_get_next_buffer( yyscanner ) )
1466 case EOB_ACT_LAST_MATCH:
1478 yyrestart(yyin ,yyscanner);
1482 case EOB_ACT_END_OF_FILE:
1484 if ( yywrap(yyscanner ) )
1487 if ( ! yyg->yy_did_buffer_switch_on_eof )
1490 return yyinput(yyscanner);
1492 return input(yyscanner);
1496 case EOB_ACT_CONTINUE_SCAN:
1497 yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
1503 c = *(
unsigned char *) yyg->yy_c_buf_p;
1504 *yyg->yy_c_buf_p =
'\0';
1505 yyg->yy_hold_char = *++yyg->yy_c_buf_p;
1523 void yyrestart (FILE * input_file , yyscan_t yyscanner)
1527 if ( ! YY_CURRENT_BUFFER ){
1528 yyensure_buffer_stack (yyscanner);
1529 YY_CURRENT_BUFFER_LVALUE =
1530 yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
1533 yy_init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner);
1534 yy_load_buffer_state(yyscanner );
1541 void yy_switch_to_buffer (
YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
1550 yyensure_buffer_stack (yyscanner);
1551 if ( YY_CURRENT_BUFFER == new_buffer )
1554 if ( YY_CURRENT_BUFFER )
1557 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1558 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
1559 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1562 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1563 yy_load_buffer_state(yyscanner );
1570 yyg->yy_did_buffer_switch_on_eof = 1;
1573static void yy_load_buffer_state (yyscan_t yyscanner)
1576 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1577 yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1578 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1579 yyg->yy_hold_char = *yyg->yy_c_buf_p;
1588 YY_BUFFER_STATE yy_create_buffer (FILE * file,
int size , yyscan_t yyscanner)
1594 YY_FATAL_ERROR(
"out of dynamic memory in yy_create_buffer()" );
1596 b->yy_buf_size = size;
1601 b->yy_ch_buf = (
char *)
yyalloc(b->yy_buf_size + 2 ,yyscanner );
1602 if ( ! b->yy_ch_buf )
1603 YY_FATAL_ERROR(
"out of dynamic memory in yy_create_buffer()" );
1605 b->yy_is_our_buffer = 1;
1607 yy_init_buffer(b,file ,yyscanner);
1623 if ( b == YY_CURRENT_BUFFER )
1626 if ( b->yy_is_our_buffer )
1627 yyfree((
void *) b->yy_ch_buf ,yyscanner );
1629 yyfree((
void *) b ,yyscanner );
1633extern int isatty (
int );
1640 static void yy_init_buffer (
YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner)
1646 yy_flush_buffer(b ,yyscanner);
1648 b->yy_input_file = file;
1649 b->yy_fill_buffer = 1;
1655 if (b != YY_CURRENT_BUFFER){
1660 b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
1681 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1682 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1684 b->yy_buf_pos = &b->yy_ch_buf[0];
1687 b->yy_buffer_status = YY_BUFFER_NEW;
1689 if ( b == YY_CURRENT_BUFFER )
1690 yy_load_buffer_state(yyscanner );
1699void yypush_buffer_state (
YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
1702 if (new_buffer == NULL)
1705 yyensure_buffer_stack(yyscanner);
1708 if ( YY_CURRENT_BUFFER )
1711 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1712 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
1713 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1717 if (YY_CURRENT_BUFFER)
1719 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1722 yy_load_buffer_state(yyscanner );
1723 yyg->yy_did_buffer_switch_on_eof = 1;
1730void yypop_buffer_state (yyscan_t yyscanner)
1733 if (!YY_CURRENT_BUFFER)
1736 yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner);
1737 YY_CURRENT_BUFFER_LVALUE = NULL;
1741 if (YY_CURRENT_BUFFER) {
1742 yy_load_buffer_state(yyscanner );
1743 yyg->yy_did_buffer_switch_on_eof = 1;
1750static void yyensure_buffer_stack (yyscan_t yyscanner)
1766 YY_FATAL_ERROR(
"out of dynamic memory in yyensure_buffer_stack()" );
1786 YY_FATAL_ERROR(
"out of dynamic memory in yyensure_buffer_stack()" );
1800YY_BUFFER_STATE yy_scan_buffer (
char * base, yy_size_t size , yyscan_t yyscanner)
1805 base[size-2] != YY_END_OF_BUFFER_CHAR ||
1806 base[size-1] != YY_END_OF_BUFFER_CHAR )
1812 YY_FATAL_ERROR(
"out of dynamic memory in yy_scan_buffer()" );
1814 b->yy_buf_size = size - 2;
1815 b->yy_buf_pos = b->yy_ch_buf = base;
1816 b->yy_is_our_buffer = 0;
1817 b->yy_input_file = 0;
1818 b->yy_n_chars = b->yy_buf_size;
1819 b->yy_is_interactive = 0;
1821 b->yy_fill_buffer = 0;
1822 b->yy_buffer_status = YY_BUFFER_NEW;
1824 yy_switch_to_buffer(b ,yyscanner );
1837YY_BUFFER_STATE yy_scan_string (yyconst
char * yystr , yyscan_t yyscanner)
1840 return yy_scan_bytes(yystr,strlen(yystr) ,yyscanner);
1850YY_BUFFER_STATE yy_scan_bytes (yyconst
char * yybytes,
int _yybytes_len , yyscan_t yyscanner)
1858 n = _yybytes_len + 2;
1859 buf = (
char *)
yyalloc(n ,yyscanner );
1861 YY_FATAL_ERROR(
"out of dynamic memory in yy_scan_bytes()" );
1863 for ( i = 0; i < _yybytes_len; ++i )
1864 buf[i] = yybytes[i];
1866 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1868 b = yy_scan_buffer(buf,n ,yyscanner);
1870 YY_FATAL_ERROR(
"bad buffer in yy_scan_bytes()" );
1875 b->yy_is_our_buffer = 1;
1880#ifndef YY_EXIT_FAILURE
1881#define YY_EXIT_FAILURE 2
1884static void yy_fatal_error (yyconst
char* msg , yyscan_t yyscanner)
1886 (void) fprintf( stderr,
"%s\n", msg );
1887 exit( YY_EXIT_FAILURE );
1897 int yyless_macro_arg = (n); \
1898 YY_LESS_LINENO(yyless_macro_arg);\
1899 yytext[yyleng] = yyg->yy_hold_char; \
1900 yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
1901 yyg->yy_hold_char = *yyg->yy_c_buf_p; \
1902 *yyg->yy_c_buf_p = '\0'; \
1903 yyleng = yyless_macro_arg; \
1912YY_EXTRA_TYPE yyget_extra (yyscan_t yyscanner)
1921int yyget_lineno (yyscan_t yyscanner)
1925 if (! YY_CURRENT_BUFFER)
1934int yyget_column (yyscan_t yyscanner)
1938 if (! YY_CURRENT_BUFFER)
1947FILE *yyget_in (yyscan_t yyscanner)
1956FILE *yyget_out (yyscan_t yyscanner)
1965int yyget_leng (yyscan_t yyscanner)
1975char *yyget_text (yyscan_t yyscanner)
1985void yyset_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner)
1988 yyextra = user_defined ;
1995void yyset_lineno (
int line_number , yyscan_t yyscanner)
2000 if (! YY_CURRENT_BUFFER )
2001 yy_fatal_error(
"yyset_lineno called with no buffer" , yyscanner);
2003 yylineno = line_number;
2010void yyset_column (
int column_no , yyscan_t yyscanner)
2015 if (! YY_CURRENT_BUFFER )
2016 yy_fatal_error(
"yyset_column called with no buffer" , yyscanner);
2018 yycolumn = column_no;
2027void yyset_in (FILE * in_str , yyscan_t yyscanner)
2033void yyset_out (FILE * out_str , yyscan_t yyscanner)
2039int yyget_debug (yyscan_t yyscanner)
2042 return yy_flex_debug;
2045void yyset_debug (
int bdebug , yyscan_t yyscanner)
2048 yy_flex_debug = bdebug ;
2053YYSTYPE * yyget_lval (yyscan_t yyscanner)
2059void yyset_lval (
YYSTYPE * yylval_param , yyscan_t yyscanner)
2062 yylval = yylval_param;
2072int yylex_init(yyscan_t* ptr_yy_globals)
2075 if (ptr_yy_globals == NULL){
2080 *ptr_yy_globals = (yyscan_t)
yyalloc (
sizeof(
struct yyguts_t ), NULL );
2082 if (*ptr_yy_globals == NULL){
2088 memset(*ptr_yy_globals,0x00,
sizeof(
struct yyguts_t));
2090 return yy_init_globals ( *ptr_yy_globals );
2101int yylex_init_extra(YY_EXTRA_TYPE yy_user_defined,yyscan_t* ptr_yy_globals )
2106 yyset_extra (yy_user_defined, &dummy_yyguts);
2108 if (ptr_yy_globals == NULL){
2113 *ptr_yy_globals = (yyscan_t)
yyalloc (
sizeof(
struct yyguts_t ), &dummy_yyguts );
2115 if (*ptr_yy_globals == NULL){
2122 memset(*ptr_yy_globals,0x00,
sizeof(
struct yyguts_t));
2124 yyset_extra (yy_user_defined, *ptr_yy_globals);
2126 return yy_init_globals ( *ptr_yy_globals );
2129static int yy_init_globals (yyscan_t yyscanner)
2139 yyg->yy_c_buf_p = (
char *) 0;
2143 yyg->yy_start_stack_ptr = 0;
2144 yyg->yy_start_stack_depth = 0;
2145 yyg->yy_start_stack = NULL;
2163int yylex_destroy (yyscan_t yyscanner)
2168 while(YY_CURRENT_BUFFER){
2169 yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner );
2170 YY_CURRENT_BUFFER_LVALUE = NULL;
2171 yypop_buffer_state(yyscanner);
2179 yyfree(yyg->yy_start_stack ,yyscanner );
2180 yyg->yy_start_stack = NULL;
2184 yy_init_globals( yyscanner);
2187 yyfree ( yyscanner , yyscanner );
2197static void yy_flex_strncpy (
char* s1, yyconst
char * s2,
int n , yyscan_t yyscanner)
2200 for ( i = 0; i < n; ++i )
2205#ifdef YY_NEED_STRLEN
2206static int yy_flex_strlen (yyconst
char * s , yyscan_t yyscanner)
2209 for ( n = 0; s[n]; ++n )
2216void *
yyalloc (yy_size_t size , yyscan_t yyscanner)
2218 return (
void *) malloc( size );
2221void *yyrealloc (
void * ptr, yy_size_t size , yyscan_t yyscanner)
2230 return (
void *) realloc( (
char *) ptr, size );
2233void yyfree (
void * ptr , yyscan_t yyscanner)
2235 free( (
char *) ptr );
2238#define YYTABLES_NAME "yytables"
2240#line 87 "_jsgf_scanner.l"
Internal definitions for JSGF grammar compiler.
SPHINXBASE_EXPORT double atof_c(char const *str)
Locale independent version of atof().
int yy_bs_column
The column count.
int yy_bs_lineno
The line count.
size_t yy_buffer_stack_max
capacity of stack.
YY_BUFFER_STATE * yy_buffer_stack
Stack as an array.
size_t yy_buffer_stack_top
index of top of stack.