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 6
12 #define YY_FLEX_SUBMINOR_VERSION 1
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
44 typedef int8_t flex_int8_t;
45 typedef uint8_t flex_uint8_t;
46 typedef int16_t flex_int16_t;
47 typedef uint16_t flex_uint16_t;
48 typedef int32_t flex_int32_t;
49 typedef uint32_t flex_uint32_t;
51 typedef signed char flex_int8_t;
52 typedef short int flex_int16_t;
53 typedef int flex_int32_t;
54 typedef unsigned char flex_uint8_t;
55 typedef unsigned short int flex_uint16_t;
56 typedef unsigned int flex_uint32_t;
60 #define INT8_MIN (-128)
63 #define INT16_MIN (-32767-1)
66 #define INT32_MIN (-2147483647-1)
69 #define INT8_MAX (127)
72 #define INT16_MAX (32767)
75 #define INT32_MAX (2147483647)
78 #define UINT8_MAX (255U)
81 #define UINT16_MAX (65535U)
84 #define UINT32_MAX (4294967295U)
94 #if defined(__GNUC__) && __GNUC__ >= 3
95 #define yynoreturn __attribute__((__noreturn__))
108 #define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
111 #ifndef YY_TYPEDEF_YY_SCANNER_T
112 #define YY_TYPEDEF_YY_SCANNER_T
113 typedef void* yyscan_t;
118 #define yyin yyg->yyin_r
119 #define yyout yyg->yyout_r
120 #define yyextra yyg->yyextra_r
121 #define yyleng yyg->yyleng_r
122 #define yytext yyg->yytext_r
123 #define yylineno (YY_CURRENT_BUFFER_LVALUE->yy_bs_lineno)
124 #define yycolumn (YY_CURRENT_BUFFER_LVALUE->yy_bs_column)
125 #define yy_flex_debug yyg->yy_flex_debug_r
131 #define BEGIN yyg->yy_start = 1 + 2 *
137 #define YY_START ((yyg->yy_start - 1) / 2)
138 #define YYSTATE YY_START
141 #define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
144 #define YY_NEW_FILE yyrestart(yyin ,yyscanner )
146 #define YY_END_OF_BUFFER_CHAR 0
155 #define YY_BUF_SIZE 32768
157 #define YY_BUF_SIZE 16384
163 #define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
165 #ifndef YY_TYPEDEF_YY_BUFFER_STATE
166 #define YY_TYPEDEF_YY_BUFFER_STATE
170 #ifndef YY_TYPEDEF_YY_SIZE_T
171 #define YY_TYPEDEF_YY_SIZE_T
172 typedef size_t yy_size_t;
175 #define EOB_ACT_CONTINUE_SCAN 0
176 #define EOB_ACT_END_OF_FILE 1
177 #define EOB_ACT_LAST_MATCH 2
186 #define YY_LESS_LINENO(n) \
189 for ( yyl = n; yyl < yyleng; ++yyl )\
190 if ( yytext[yyl] == '\n' )\
193 #define YY_LINENO_REWIND_TO(dst) \
196 for ( p = yy_cp-1; p >= (dst); --p)\
206 int yyless_macro_arg = (n); \
207 YY_LESS_LINENO(yyless_macro_arg);\
208 *yy_cp = yyg->yy_hold_char; \
209 YY_RESTORE_YY_MORE_OFFSET \
210 yyg->yy_c_buf_p = yy_cp = yy_bp + yyless_macro_arg - YY_MORE_ADJ; \
211 YY_DO_BEFORE_ACTION; \
215 #define unput(c) yyunput( c, yyg->yytext_ptr , yyscanner )
217 #ifndef YY_STRUCT_YY_BUFFER_STATE
218 #define YY_STRUCT_YY_BUFFER_STATE
240 int yy_is_our_buffer;
247 int yy_is_interactive;
263 int yy_buffer_status;
265 #define YY_BUFFER_NEW 0
266 #define YY_BUFFER_NORMAL 1
277 #define YY_BUFFER_EOF_PENDING 2
288 #define YY_CURRENT_BUFFER ( yyg->yy_buffer_stack \
289 ? yyg->yy_buffer_stack[yyg->yy_buffer_stack_top] \
295 #define YY_CURRENT_BUFFER_LVALUE yyg->yy_buffer_stack[yyg->yy_buffer_stack_top]
297 void yyrestart (FILE *input_file ,yyscan_t yyscanner );
298 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
299 YY_BUFFER_STATE yy_create_buffer (FILE *file,
int size ,yyscan_t yyscanner );
300 void yy_delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
301 void yy_flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
302 void yypush_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
303 void yypop_buffer_state (yyscan_t yyscanner );
305 static void yyensure_buffer_stack (yyscan_t yyscanner );
306 static void yy_load_buffer_state (yyscan_t yyscanner );
307 static void yy_init_buffer (YY_BUFFER_STATE b,FILE *file ,yyscan_t yyscanner );
309 #define YY_FLUSH_BUFFER yy_flush_buffer(YY_CURRENT_BUFFER ,yyscanner)
311 YY_BUFFER_STATE yy_scan_buffer (
char *base,yy_size_t size ,yyscan_t yyscanner );
312 YY_BUFFER_STATE yy_scan_string (yyconst
char *yy_str ,yyscan_t yyscanner );
313 YY_BUFFER_STATE yy_scan_bytes (yyconst
char *bytes,
int len ,yyscan_t yyscanner );
315 void *
yyalloc (yy_size_t ,yyscan_t yyscanner );
316 void *yyrealloc (
void *,yy_size_t ,yyscan_t yyscanner );
317 void yyfree (
void * ,yyscan_t yyscanner );
319 #define yy_new_buffer yy_create_buffer
321 #define yy_set_interactive(is_interactive) \
323 if ( ! YY_CURRENT_BUFFER ){ \
324 yyensure_buffer_stack (yyscanner); \
325 YY_CURRENT_BUFFER_LVALUE = \
326 yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
328 YY_CURRENT_BUFFER_LVALUE->yy_is_interactive = is_interactive; \
331 #define yy_set_bol(at_bol) \
333 if ( ! YY_CURRENT_BUFFER ){\
334 yyensure_buffer_stack (yyscanner); \
335 YY_CURRENT_BUFFER_LVALUE = \
336 yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner); \
338 YY_CURRENT_BUFFER_LVALUE->yy_at_bol = at_bol; \
341 #define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
345 #define yywrap(yyscanner) (1)
346 #define YY_SKIP_YYWRAP
348 typedef unsigned char YY_CHAR;
350 typedef int yy_state_type;
352 #define yytext_ptr yytext_r
354 static yy_state_type yy_get_previous_state (yyscan_t yyscanner );
355 static yy_state_type yy_try_NUL_trans (yy_state_type current_state ,yyscan_t yyscanner);
356 static int yy_get_next_buffer (yyscan_t yyscanner );
357 static void yynoreturn yy_fatal_error (yyconst
char* msg ,yyscan_t yyscanner );
362 #define YY_DO_BEFORE_ACTION \
363 yyg->yytext_ptr = yy_bp; \
364 yyleng = (int) (yy_cp - yy_bp); \
365 yyg->yy_hold_char = *yy_cp; \
367 yyg->yy_c_buf_p = yy_cp;
369 #define YY_NUM_RULES 22
370 #define YY_END_OF_BUFFER 23
375 flex_int32_t yy_verify;
378 static yyconst flex_int16_t yy_accept[98] =
380 0, 0, 0, 0, 0, 0, 0, 0, 23, 22,
381 1, 22, 22, 22, 22, 22, 22, 22, 5, 1,
382 5, 17, 1, 17, 21, 21, 18, 21, 21, 9,
383 1, 9, 0, 3, 0, 0, 0, 0, 0, 0,
384 4, 17, 17, 0, 17, 17, 7, 0, 20, 0,
385 0, 0, 0, 0, 16, 8, 0, 0, 2, 14,
386 0, 0, 0, 0, 19, 0, 17, 0, 17, 17,
387 0, 0, 6, 20, 0, 15, 0, 0, 16, 0,
388 0, 0, 0, 0, 19, 0, 0, 0, 10, 0,
389 0, 0, 0, 12, 13, 11, 0
393 static yyconst YY_CHAR yy_ec[256] =
395 1, 1, 1, 1, 1, 1, 1, 1, 2, 3,
396 1, 1, 2, 1, 1, 1, 1, 1, 1, 1,
397 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
398 1, 2, 1, 4, 5, 1, 1, 1, 1, 6,
399 6, 7, 6, 1, 8, 9, 10, 11, 11, 11,
400 11, 11, 11, 11, 11, 11, 11, 1, 12, 13,
401 6, 14, 1, 1, 1, 1, 1, 1, 1, 15,
402 16, 1, 1, 17, 1, 1, 1, 1, 1, 1,
403 1, 1, 18, 1, 1, 1, 1, 1, 1, 1,
404 6, 19, 6, 1, 1, 1, 20, 21, 22, 1,
406 23, 1, 24, 1, 25, 1, 1, 26, 27, 1,
407 28, 29, 1, 30, 1, 31, 32, 1, 1, 1,
408 1, 1, 33, 6, 34, 1, 1, 1, 1, 1,
409 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
410 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
411 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
412 1, 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, 35, 1, 1, 1,
415 36, 1, 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, 37, 1,
421 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
425 static yyconst YY_CHAR yy_meta[38] =
427 1, 2, 2, 1, 1, 2, 2, 1, 1, 2,
428 1, 2, 3, 3, 1, 1, 1, 1, 1, 1,
429 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
433 static yyconst flex_uint16_t yy_base[113] =
435 0, 36, 4, 12, 72, 105, 14, 20, 135, 312,
436 312, 117, 2, 0, 103, 105, 99, 95, 312, 312,
437 119, 0, 312, 138, 312, 21, 312, 0, 1, 312,
438 312, 118, 109, 312, 123, 111, 104, 94, 101, 85,
439 312, 0, 171, 14, 0, 204, 312, 109, 113, 41,
440 106, 96, 21, 23, 312, 312, 88, 98, 312, 312,
441 73, 71, 70, 89, 312, 44, 0, 39, 0, 237,
442 43, 90, 312, 312, 57, 312, 37, 69, 43, 77,
443 64, 57, 58, 64, 76, 94, 79, 59, 312, 39,
444 14, 14, 4, 312, 312, 312, 312, 271, 274, 277,
446 280, 283, 0, 285, 288, 290, 293, 296, 299, 302,
450 static yyconst flex_int16_t yy_def[113] =
452 98, 98, 99, 99, 100, 100, 101, 101, 97, 97,
453 97, 97, 97, 102, 97, 97, 97, 97, 97, 97,
454 97, 103, 97, 104, 97, 97, 97, 105, 106, 97,
455 97, 97, 97, 97, 107, 102, 97, 97, 97, 97,
456 97, 103, 104, 108, 103, 109, 97, 97, 110, 97,
457 97, 105, 106, 111, 97, 97, 97, 107, 97, 97,
458 97, 97, 97, 97, 97, 112, 43, 108, 43, 109,
459 97, 110, 97, 97, 97, 97, 106, 111, 106, 97,
460 97, 97, 97, 97, 108, 112, 97, 97, 97, 97,
461 97, 97, 97, 97, 97, 97, 0, 97, 97, 97,
463 97, 97, 97, 97, 97, 97, 97, 97, 97, 97,
467 static yyconst flex_uint16_t yy_nxt[350] =
469 42, 11, 11, 97, 12, 20, 11, 97, 34, 13,
470 21, 35, 14, 20, 11, 31, 11, 65, 21, 54,
471 32, 31, 11, 15, 16, 53, 32, 47, 17, 48,
472 49, 50, 66, 96, 55, 95, 18, 11, 11, 54,
473 12, 78, 65, 51, 94, 13, 44, 85, 14, 48,
474 74, 50, 74, 87, 55, 54, 79, 66, 93, 15,
475 16, 54, 86, 51, 17, 51, 74, 88, 74, 88,
476 55, 53, 18, 23, 11, 24, 55, 25, 25, 65,
477 33, 26, 92, 27, 28, 25, 91, 78, 74, 87,
478 90, 89, 73, 84, 66, 83, 44, 85, 82, 81,
480 59, 51, 79, 80, 29, 25, 23, 11, 24, 76,
481 25, 25, 86, 75, 26, 73, 27, 28, 25, 71,
482 64, 63, 62, 61, 60, 59, 57, 56, 41, 40,
483 39, 38, 37, 33, 97, 97, 97, 29, 25, 44,
484 44, 45, 97, 44, 44, 97, 97, 44, 97, 44,
485 44, 44, 97, 97, 97, 97, 46, 97, 97, 97,
486 97, 97, 97, 97, 97, 97, 97, 97, 97, 97,
487 44, 44, 44, 44, 45, 97, 44, 44, 97, 97,
488 44, 97, 44, 44, 44, 97, 97, 97, 97, 46,
489 97, 97, 97, 97, 97, 97, 97, 97, 97, 97,
491 97, 97, 97, 44, 44, 68, 44, 69, 97, 68,
492 68, 97, 97, 68, 97, 68, 68, 68, 97, 97,
493 97, 97, 70, 97, 97, 97, 97, 97, 97, 97,
494 97, 97, 97, 97, 97, 97, 68, 68, 68, 44,
495 69, 97, 68, 68, 97, 97, 68, 97, 68, 68,
496 68, 97, 97, 97, 97, 70, 97, 97, 97, 97,
497 97, 97, 97, 97, 97, 97, 97, 97, 97, 68,
498 68, 10, 10, 10, 19, 19, 19, 22, 22, 22,
499 30, 30, 30, 36, 36, 43, 43, 43, 52, 52,
500 53, 53, 53, 58, 58, 58, 44, 44, 44, 67,
502 67, 67, 72, 72, 72, 77, 77, 77, 68, 68,
503 68, 9, 97, 97, 97, 97, 97, 97, 97, 97,
504 97, 97, 97, 97, 97, 97, 97, 97, 97, 97,
505 97, 97, 97, 97, 97, 97, 97, 97, 97, 97,
506 97, 97, 97, 97, 97, 97, 97, 97, 97
509 static yyconst flex_int16_t yy_chk[350] =
511 103, 1, 1, 0, 1, 3, 3, 0, 13, 1,
512 3, 13, 1, 4, 4, 7, 7, 44, 4, 29,
513 7, 8, 8, 1, 1, 54, 8, 26, 1, 26,
514 26, 26, 44, 93, 29, 92, 1, 2, 2, 53,
515 2, 54, 68, 26, 91, 2, 66, 66, 2, 50,
516 50, 50, 71, 71, 53, 77, 54, 68, 90, 2,
517 2, 79, 66, 50, 2, 71, 75, 75, 88, 88,
518 77, 78, 2, 5, 5, 5, 79, 5, 5, 85,
519 84, 5, 83, 5, 5, 5, 82, 78, 87, 87,
520 81, 80, 72, 64, 85, 63, 86, 86, 62, 61,
522 58, 87, 78, 57, 5, 5, 6, 6, 6, 52,
523 6, 6, 86, 51, 6, 49, 6, 6, 6, 48,
524 40, 39, 38, 37, 36, 35, 33, 32, 21, 18,
525 17, 16, 15, 12, 9, 0, 0, 6, 6, 24,
526 24, 24, 0, 24, 24, 0, 0, 24, 0, 24,
527 24, 24, 0, 0, 0, 0, 24, 0, 0, 0,
528 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
529 24, 24, 43, 43, 43, 0, 43, 43, 0, 0,
530 43, 0, 43, 43, 43, 0, 0, 0, 0, 43,
531 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
533 0, 0, 0, 43, 43, 46, 46, 46, 0, 46,
534 46, 0, 0, 46, 0, 46, 46, 46, 0, 0,
535 0, 0, 46, 0, 0, 0, 0, 0, 0, 0,
536 0, 0, 0, 0, 0, 0, 46, 46, 70, 70,
537 70, 0, 70, 70, 0, 0, 70, 0, 70, 70,
538 70, 0, 0, 0, 0, 70, 0, 0, 0, 0,
539 0, 0, 0, 0, 0, 0, 0, 0, 0, 70,
540 70, 98, 98, 98, 99, 99, 99, 100, 100, 100,
541 101, 101, 101, 102, 102, 104, 104, 104, 105, 105,
542 106, 106, 106, 107, 107, 107, 108, 108, 108, 109,
544 109, 109, 110, 110, 110, 111, 111, 111, 112, 112,
545 112, 97, 97, 97, 97, 97, 97, 97, 97, 97,
546 97, 97, 97, 97, 97, 97, 97, 97, 97, 97,
547 97, 97, 97, 97, 97, 97, 97, 97, 97, 97,
548 97, 97, 97, 97, 97, 97, 97, 97, 97
552 static yyconst flex_int32_t yy_rule_can_match_eol[23] =
554 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 1,
560 #define REJECT reject_used_but_not_detected
561 #define yymore() yymore_used_but_not_detected
562 #define YY_MORE_ADJ 0
563 #define YY_RESTORE_YY_MORE_OFFSET
564 #line 1 "_jsgf_scanner.l"
602 #line 39 "_jsgf_scanner.l"
605 #include "jsgf_parser.h"
607 #define YY_NO_UNISTD_H 1
611 #line 612 "jsgf_scanner.c"
616 #define DECLCOMMENT 3
618 #ifndef YY_EXTRA_TYPE
619 #define YY_EXTRA_TYPE void *
627 YY_EXTRA_TYPE yyextra_r;
630 FILE *yyin_r, *yyout_r;
640 int yy_did_buffer_switch_on_eof;
641 int yy_start_stack_ptr;
642 int yy_start_stack_depth;
644 yy_state_type yy_last_accepting_state;
645 char* yy_last_accepting_cpos;
658 static int yy_init_globals (yyscan_t yyscanner );
662 # define yylval yyg->yylval_r
664 int yylex_init (yyscan_t* scanner);
666 int yylex_init_extra (YY_EXTRA_TYPE user_defined,yyscan_t* scanner);
671 int yylex_destroy (yyscan_t yyscanner );
673 int yyget_debug (yyscan_t yyscanner );
675 void yyset_debug (
int debug_flag ,yyscan_t yyscanner );
677 YY_EXTRA_TYPE yyget_extra (yyscan_t yyscanner );
679 void yyset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
681 FILE *yyget_in (yyscan_t yyscanner );
683 void yyset_in (FILE * _in_str ,yyscan_t yyscanner );
685 FILE *yyget_out (yyscan_t yyscanner );
687 void yyset_out (FILE * _out_str ,yyscan_t yyscanner );
689 int yyget_leng (yyscan_t yyscanner );
691 char *yyget_text (yyscan_t yyscanner );
693 int yyget_lineno (yyscan_t yyscanner );
695 void yyset_lineno (
int _line_number ,yyscan_t yyscanner );
697 int yyget_column (yyscan_t yyscanner );
699 void yyset_column (
int _column_no ,yyscan_t yyscanner );
701 YYSTYPE * yyget_lval (yyscan_t yyscanner );
703 void yyset_lval (
YYSTYPE * yylval_param ,yyscan_t yyscanner );
709 #ifndef YY_SKIP_YYWRAP
711 extern "C" int yywrap (yyscan_t yyscanner );
713 extern int yywrap (yyscan_t yyscanner );
722 static void yy_flex_strncpy (
char *,yyconst
char *,
int ,yyscan_t yyscanner);
725 #ifdef YY_NEED_STRLEN
726 static int yy_flex_strlen (yyconst
char * ,yyscan_t yyscanner);
732 static int yyinput (yyscan_t yyscanner );
734 static int input (yyscan_t yyscanner );
740 #ifndef YY_READ_BUF_SIZE
743 #define YY_READ_BUF_SIZE 16384
745 #define YY_READ_BUF_SIZE 8192
754 #define ECHO do { if (fwrite( yytext, (size_t) yyleng, 1, yyout )) {} } while (0)
761 #define YY_INPUT(buf,result,max_size) \
762 if ( YY_CURRENT_BUFFER_LVALUE->yy_is_interactive ) \
766 for ( n = 0; n < max_size && \
767 (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
770 buf[n++] = (char) c; \
771 if ( c == EOF && ferror( yyin ) ) \
772 YY_FATAL_ERROR( "input in flex scanner failed" ); \
778 while ( (result = (int) fread(buf, 1, max_size, yyin))==0 && ferror(yyin)) \
780 if( errno != EINTR) \
782 YY_FATAL_ERROR( "input in flex scanner failed" ); \
798 #define yyterminate() return YY_NULL
802 #ifndef YY_START_STACK_INCR
803 #define YY_START_STACK_INCR 25
807 #ifndef YY_FATAL_ERROR
808 #define YY_FATAL_ERROR(msg) yy_fatal_error( msg , yyscanner)
817 #define YY_DECL_IS_OURS 1
820 (
YYSTYPE * yylval_param ,yyscan_t yyscanner);
822 #define YY_DECL int yylex \
823 (YYSTYPE * yylval_param , yyscan_t yyscanner)
829 #ifndef YY_USER_ACTION
830 #define YY_USER_ACTION
835 #define YY_BREAK break;
838 #define YY_RULE_SETUP \
845 yy_state_type yy_current_state;
850 yylval = yylval_param;
860 if ( ! yyg->yy_start )
869 if ( ! YY_CURRENT_BUFFER ) {
870 yyensure_buffer_stack (yyscanner);
871 YY_CURRENT_BUFFER_LVALUE =
872 yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
875 yy_load_buffer_state(yyscanner );
879 #line 59 "_jsgf_scanner.l"
882 #line 883 "jsgf_scanner.c"
886 yy_cp = yyg->yy_c_buf_p;
889 *yy_cp = yyg->yy_hold_char;
896 yy_current_state = yyg->yy_start;
900 YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)] ;
901 if ( yy_accept[yy_current_state] )
903 yyg->yy_last_accepting_state = yy_current_state;
904 yyg->yy_last_accepting_cpos = yy_cp;
906 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
908 yy_current_state = (int) yy_def[yy_current_state];
909 if ( yy_current_state >= 98 )
910 yy_c = yy_meta[(
unsigned int) yy_c];
912 yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c];
915 while ( yy_current_state != 97 );
916 yy_cp = yyg->yy_last_accepting_cpos;
917 yy_current_state = yyg->yy_last_accepting_state;
920 yy_act = yy_accept[yy_current_state];
924 if ( yy_act != YY_END_OF_BUFFER && yy_rule_can_match_eol[yy_act] )
927 for ( yyl = 0; yyl < yyleng; ++yyl )
928 if ( yytext[yyl] ==
'\n' )
942 *yy_cp = yyg->yy_hold_char;
943 yy_cp = yyg->yy_last_accepting_cpos;
944 yy_current_state = yyg->yy_last_accepting_state;
950 #line 61 "_jsgf_scanner.l"
956 #line 62 "_jsgf_scanner.l"
961 #line 63 "_jsgf_scanner.l"
966 #line 64 "_jsgf_scanner.l"
971 #line 65 "_jsgf_scanner.l"
977 #line 67 "_jsgf_scanner.l"
982 #line 68 "_jsgf_scanner.l"
983 { BEGIN(DECLCOMMENT); }
987 #line 69 "_jsgf_scanner.l"
992 #line 70 "_jsgf_scanner.l"
997 #line 72 "_jsgf_scanner.l"
998 {BEGIN(DECL);
return HEADER;}
1002 #line 73 "_jsgf_scanner.l"
1003 {BEGIN(DECL);
return GRAMMAR;}
1007 #line 74 "_jsgf_scanner.l"
1008 {BEGIN(DECL);
return IMPORT;}
1012 #line 75 "_jsgf_scanner.l"
1013 {BEGIN(DECL);
return PUBLIC;}
1018 #line 77 "_jsgf_scanner.l"
1019 { BEGIN(DECL); yylval->name = strdup(yytext);
return RULENAME; }
1024 #line 78 "_jsgf_scanner.l"
1025 { yylval->name = strdup(yytext);
return RULENAME; }
1030 #line 80 "_jsgf_scanner.l"
1031 { yylval->name = strdup(yytext);
return TAG; }
1035 #line 81 "_jsgf_scanner.l"
1036 { yylval->name = strdup(yytext);
return TOKEN; }
1040 #line 82 "_jsgf_scanner.l"
1041 { BEGIN(INITIAL);
return yytext[0]; }
1046 #line 83 "_jsgf_scanner.l"
1047 { yylval->name = strdup(yytext);
return TOKEN; }
1051 #line 84 "_jsgf_scanner.l"
1052 { yylval->weight =
atof_c(yytext+1);
return WEIGHT; }
1056 #line 85 "_jsgf_scanner.l"
1061 #line 87 "_jsgf_scanner.l"
1064 #line 1065 "jsgf_scanner.c"
1065 case YY_STATE_EOF(INITIAL):
1066 case YY_STATE_EOF(COMMENT):
1067 case YY_STATE_EOF(DECL):
1068 case YY_STATE_EOF(DECLCOMMENT):
1071 case YY_END_OF_BUFFER:
1074 int yy_amount_of_matched_text = (int) (yy_cp - yyg->yytext_ptr) - 1;
1077 *yy_cp = yyg->yy_hold_char;
1078 YY_RESTORE_YY_MORE_OFFSET
1080 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_NEW )
1091 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1092 YY_CURRENT_BUFFER_LVALUE->yy_input_file = yyin;
1093 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status = YY_BUFFER_NORMAL;
1103 if ( yyg->yy_c_buf_p <= &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
1105 yy_state_type yy_next_state;
1107 yyg->yy_c_buf_p = yyg->yytext_ptr + yy_amount_of_matched_text;
1109 yy_current_state = yy_get_previous_state( yyscanner );
1120 yy_next_state = yy_try_NUL_trans( yy_current_state , yyscanner);
1122 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1124 if ( yy_next_state )
1127 yy_cp = ++yyg->yy_c_buf_p;
1128 yy_current_state = yy_next_state;
1134 yy_cp = yyg->yy_last_accepting_cpos;
1135 yy_current_state = yyg->yy_last_accepting_state;
1136 goto yy_find_action;
1140 else switch ( yy_get_next_buffer( yyscanner ) )
1142 case EOB_ACT_END_OF_FILE:
1144 yyg->yy_did_buffer_switch_on_eof = 0;
1146 if ( yywrap(yyscanner ) )
1157 yyg->yy_c_buf_p = yyg->yytext_ptr + YY_MORE_ADJ;
1159 yy_act = YY_STATE_EOF(YY_START);
1165 if ( ! yyg->yy_did_buffer_switch_on_eof )
1171 case EOB_ACT_CONTINUE_SCAN:
1173 yyg->yytext_ptr + yy_amount_of_matched_text;
1175 yy_current_state = yy_get_previous_state( yyscanner );
1177 yy_cp = yyg->yy_c_buf_p;
1178 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1181 case EOB_ACT_LAST_MATCH:
1183 &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars];
1185 yy_current_state = yy_get_previous_state( yyscanner );
1187 yy_cp = yyg->yy_c_buf_p;
1188 yy_bp = yyg->yytext_ptr + YY_MORE_ADJ;
1189 goto yy_find_action;
1196 "fatal flex scanner internal error--no action found" );
1209 static int yy_get_next_buffer (yyscan_t yyscanner)
1212 char *dest = YY_CURRENT_BUFFER_LVALUE->yy_ch_buf;
1213 char *source = yyg->yytext_ptr;
1214 yy_size_t number_to_move, i;
1217 if ( yyg->yy_c_buf_p > &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] )
1219 "fatal flex scanner internal error--end of buffer missed" );
1221 if ( YY_CURRENT_BUFFER_LVALUE->yy_fill_buffer == 0 )
1223 if ( yyg->yy_c_buf_p - yyg->yytext_ptr - YY_MORE_ADJ == 1 )
1228 return EOB_ACT_END_OF_FILE;
1236 return EOB_ACT_LAST_MATCH;
1243 number_to_move = (yy_size_t) (yyg->yy_c_buf_p - yyg->yytext_ptr) - 1;
1245 for ( i = 0; i < number_to_move; ++i )
1246 *(dest++) = *(source++);
1248 if ( YY_CURRENT_BUFFER_LVALUE->yy_buffer_status == YY_BUFFER_EOF_PENDING )
1252 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars = 0;
1257 YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
1259 while ( num_to_read <= 0 )
1263 YY_BUFFER_STATE b = YY_CURRENT_BUFFER_LVALUE;
1265 int yy_c_buf_p_offset =
1266 (int) (yyg->yy_c_buf_p - b->yy_ch_buf);
1268 if ( b->yy_is_our_buffer )
1270 int new_size = b->yy_buf_size * 2;
1272 if ( new_size <= 0 )
1273 b->yy_buf_size += b->yy_buf_size / 8;
1275 b->yy_buf_size *= 2;
1277 b->yy_ch_buf = (
char *)
1279 yyrealloc((
void *) b->yy_ch_buf,b->yy_buf_size + 2 ,yyscanner );
1283 b->yy_ch_buf = NULL;
1285 if ( ! b->yy_ch_buf )
1287 "fatal error - scanner input buffer overflow" );
1289 yyg->yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
1291 num_to_read = YY_CURRENT_BUFFER_LVALUE->yy_buf_size -
1296 if ( num_to_read > YY_READ_BUF_SIZE )
1297 num_to_read = YY_READ_BUF_SIZE;
1300 YY_INPUT( (&YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[number_to_move]),
1301 yyg->yy_n_chars, num_to_read );
1303 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1306 if ( yyg->yy_n_chars == 0 )
1308 if ( number_to_move == YY_MORE_ADJ )
1310 ret_val = EOB_ACT_END_OF_FILE;
1311 yyrestart(yyin ,yyscanner);
1316 ret_val = EOB_ACT_LAST_MATCH;
1317 YY_CURRENT_BUFFER_LVALUE->yy_buffer_status =
1318 YY_BUFFER_EOF_PENDING;
1323 ret_val = EOB_ACT_CONTINUE_SCAN;
1325 if ((
int) (yyg->yy_n_chars + number_to_move) > YY_CURRENT_BUFFER_LVALUE->yy_buf_size) {
1327 int new_size = yyg->yy_n_chars + number_to_move + (yyg->yy_n_chars >> 1);
1328 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf = (
char *) yyrealloc((
void *) YY_CURRENT_BUFFER_LVALUE->yy_ch_buf,new_size ,yyscanner );
1329 if ( ! YY_CURRENT_BUFFER_LVALUE->yy_ch_buf )
1330 YY_FATAL_ERROR(
"out of dynamic memory in yy_get_next_buffer()" );
1333 yyg->yy_n_chars += number_to_move;
1334 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] = YY_END_OF_BUFFER_CHAR;
1335 YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
1337 yyg->yytext_ptr = &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[0];
1344 static yy_state_type yy_get_previous_state (yyscan_t yyscanner)
1346 yy_state_type yy_current_state;
1350 yy_current_state = yyg->yy_start;
1352 for ( yy_cp = yyg->yytext_ptr + YY_MORE_ADJ; yy_cp < yyg->yy_c_buf_p; ++yy_cp )
1354 YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
1355 if ( yy_accept[yy_current_state] )
1357 yyg->yy_last_accepting_state = yy_current_state;
1358 yyg->yy_last_accepting_cpos = yy_cp;
1360 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1362 yy_current_state = (int) yy_def[yy_current_state];
1363 if ( yy_current_state >= 98 )
1364 yy_c = yy_meta[(
unsigned int) yy_c];
1366 yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c];
1369 return yy_current_state;
1377 static yy_state_type yy_try_NUL_trans (yy_state_type yy_current_state , yyscan_t yyscanner)
1381 char *yy_cp = yyg->yy_c_buf_p;
1384 if ( yy_accept[yy_current_state] )
1386 yyg->yy_last_accepting_state = yy_current_state;
1387 yyg->yy_last_accepting_cpos = yy_cp;
1389 while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
1391 yy_current_state = (int) yy_def[yy_current_state];
1392 if ( yy_current_state >= 98 )
1393 yy_c = yy_meta[(
unsigned int) yy_c];
1395 yy_current_state = yy_nxt[yy_base[yy_current_state] + (flex_int16_t) yy_c];
1396 yy_is_jam = (yy_current_state == 97);
1399 return yy_is_jam ? 0 : yy_current_state;
1408 static int yyinput (yyscan_t yyscanner)
1410 static int input (yyscan_t yyscanner)
1417 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1419 if ( *yyg->yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
1425 if ( yyg->yy_c_buf_p < &YY_CURRENT_BUFFER_LVALUE->yy_ch_buf[yyg->yy_n_chars] )
1427 *yyg->yy_c_buf_p =
'\0';
1431 int offset = yyg->yy_c_buf_p - yyg->yytext_ptr;
1434 switch ( yy_get_next_buffer( yyscanner ) )
1436 case EOB_ACT_LAST_MATCH:
1448 yyrestart(yyin ,yyscanner);
1452 case EOB_ACT_END_OF_FILE:
1454 if ( yywrap(yyscanner ) )
1457 if ( ! yyg->yy_did_buffer_switch_on_eof )
1460 return yyinput(yyscanner);
1462 return input(yyscanner);
1466 case EOB_ACT_CONTINUE_SCAN:
1467 yyg->yy_c_buf_p = yyg->yytext_ptr + offset;
1473 c = *(
unsigned char *) yyg->yy_c_buf_p;
1474 *yyg->yy_c_buf_p =
'\0';
1475 yyg->yy_hold_char = *++yyg->yy_c_buf_p;
1493 void yyrestart (FILE * input_file , yyscan_t yyscanner)
1497 if ( ! YY_CURRENT_BUFFER ){
1498 yyensure_buffer_stack (yyscanner);
1499 YY_CURRENT_BUFFER_LVALUE =
1500 yy_create_buffer(yyin,YY_BUF_SIZE ,yyscanner);
1503 yy_init_buffer(YY_CURRENT_BUFFER,input_file ,yyscanner);
1504 yy_load_buffer_state(yyscanner );
1511 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
1520 yyensure_buffer_stack (yyscanner);
1521 if ( YY_CURRENT_BUFFER == new_buffer )
1524 if ( YY_CURRENT_BUFFER )
1527 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1528 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
1529 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1532 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1533 yy_load_buffer_state(yyscanner );
1540 yyg->yy_did_buffer_switch_on_eof = 1;
1543 static void yy_load_buffer_state (yyscan_t yyscanner)
1546 yyg->yy_n_chars = YY_CURRENT_BUFFER_LVALUE->yy_n_chars;
1547 yyg->yytext_ptr = yyg->yy_c_buf_p = YY_CURRENT_BUFFER_LVALUE->yy_buf_pos;
1548 yyin = YY_CURRENT_BUFFER_LVALUE->yy_input_file;
1549 yyg->yy_hold_char = *yyg->yy_c_buf_p;
1558 YY_BUFFER_STATE yy_create_buffer (FILE * file,
int size , yyscan_t yyscanner)
1564 YY_FATAL_ERROR(
"out of dynamic memory in yy_create_buffer()" );
1566 b->yy_buf_size = (yy_size_t)size;
1571 b->yy_ch_buf = (
char *)
yyalloc(b->yy_buf_size + 2 ,yyscanner );
1572 if ( ! b->yy_ch_buf )
1573 YY_FATAL_ERROR(
"out of dynamic memory in yy_create_buffer()" );
1575 b->yy_is_our_buffer = 1;
1577 yy_init_buffer(b,file ,yyscanner);
1586 void yy_delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
1593 if ( b == YY_CURRENT_BUFFER )
1594 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1596 if ( b->yy_is_our_buffer )
1597 yyfree((
void *) b->yy_ch_buf ,yyscanner );
1599 yyfree((
void *) b ,yyscanner );
1606 static void yy_init_buffer (YY_BUFFER_STATE b, FILE * file , yyscan_t yyscanner)
1612 yy_flush_buffer(b ,yyscanner);
1614 b->yy_input_file = file;
1615 b->yy_fill_buffer = 1;
1621 if (b != YY_CURRENT_BUFFER){
1626 b->yy_is_interactive = 0;
1635 void yy_flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
1647 b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
1648 b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
1650 b->yy_buf_pos = &b->yy_ch_buf[0];
1653 b->yy_buffer_status = YY_BUFFER_NEW;
1655 if ( b == YY_CURRENT_BUFFER )
1656 yy_load_buffer_state(yyscanner );
1665 void yypush_buffer_state (YY_BUFFER_STATE new_buffer , yyscan_t yyscanner)
1668 if (new_buffer == NULL)
1671 yyensure_buffer_stack(yyscanner);
1674 if ( YY_CURRENT_BUFFER )
1677 *yyg->yy_c_buf_p = yyg->yy_hold_char;
1678 YY_CURRENT_BUFFER_LVALUE->yy_buf_pos = yyg->yy_c_buf_p;
1679 YY_CURRENT_BUFFER_LVALUE->yy_n_chars = yyg->yy_n_chars;
1683 if (YY_CURRENT_BUFFER)
1685 YY_CURRENT_BUFFER_LVALUE = new_buffer;
1688 yy_load_buffer_state(yyscanner );
1689 yyg->yy_did_buffer_switch_on_eof = 1;
1696 void yypop_buffer_state (yyscan_t yyscanner)
1699 if (!YY_CURRENT_BUFFER)
1702 yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner);
1703 YY_CURRENT_BUFFER_LVALUE = NULL;
1707 if (YY_CURRENT_BUFFER) {
1708 yy_load_buffer_state(yyscanner );
1709 yyg->yy_did_buffer_switch_on_eof = 1;
1716 static void yyensure_buffer_stack (yyscan_t yyscanner)
1732 YY_FATAL_ERROR(
"out of dynamic memory in yyensure_buffer_stack()" );
1744 yy_size_t grow_size = 8 ;
1752 YY_FATAL_ERROR(
"out of dynamic memory in yyensure_buffer_stack()" );
1766 YY_BUFFER_STATE yy_scan_buffer (
char * base, yy_size_t size , yyscan_t yyscanner)
1771 base[size-2] != YY_END_OF_BUFFER_CHAR ||
1772 base[size-1] != YY_END_OF_BUFFER_CHAR )
1778 YY_FATAL_ERROR(
"out of dynamic memory in yy_scan_buffer()" );
1780 b->yy_buf_size = size - 2;
1781 b->yy_buf_pos = b->yy_ch_buf = base;
1782 b->yy_is_our_buffer = 0;
1783 b->yy_input_file = NULL;
1784 b->yy_n_chars = b->yy_buf_size;
1785 b->yy_is_interactive = 0;
1787 b->yy_fill_buffer = 0;
1788 b->yy_buffer_status = YY_BUFFER_NEW;
1790 yy_switch_to_buffer(b ,yyscanner );
1803 YY_BUFFER_STATE yy_scan_string (yyconst
char * yystr , yyscan_t yyscanner)
1806 return yy_scan_bytes(yystr,(
int) strlen(yystr) ,yyscanner);
1816 YY_BUFFER_STATE yy_scan_bytes (yyconst
char * yybytes,
int _yybytes_len , yyscan_t yyscanner)
1824 n = (yy_size_t) _yybytes_len + 2;
1825 buf = (
char *)
yyalloc(n ,yyscanner );
1827 YY_FATAL_ERROR(
"out of dynamic memory in yy_scan_bytes()" );
1829 for ( i = 0; i < _yybytes_len; ++i )
1830 buf[i] = yybytes[i];
1832 buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
1834 b = yy_scan_buffer(buf,n ,yyscanner);
1836 YY_FATAL_ERROR(
"bad buffer in yy_scan_bytes()" );
1841 b->yy_is_our_buffer = 1;
1846 #ifndef YY_EXIT_FAILURE
1847 #define YY_EXIT_FAILURE 2
1850 static void yynoreturn yy_fatal_error (yyconst
char* msg , yyscan_t yyscanner)
1854 (void) fprintf( stderr,
"%s\n", msg );
1855 exit( YY_EXIT_FAILURE );
1865 int yyless_macro_arg = (n); \
1866 YY_LESS_LINENO(yyless_macro_arg);\
1867 yytext[yyleng] = yyg->yy_hold_char; \
1868 yyg->yy_c_buf_p = yytext + yyless_macro_arg; \
1869 yyg->yy_hold_char = *yyg->yy_c_buf_p; \
1870 *yyg->yy_c_buf_p = '\0'; \
1871 yyleng = yyless_macro_arg; \
1880 YY_EXTRA_TYPE yyget_extra (yyscan_t yyscanner)
1889 int yyget_lineno (yyscan_t yyscanner)
1893 if (! YY_CURRENT_BUFFER)
1902 int yyget_column (yyscan_t yyscanner)
1906 if (! YY_CURRENT_BUFFER)
1915 FILE *yyget_in (yyscan_t yyscanner)
1924 FILE *yyget_out (yyscan_t yyscanner)
1933 int yyget_leng (yyscan_t yyscanner)
1943 char *yyget_text (yyscan_t yyscanner)
1953 void yyset_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner)
1956 yyextra = user_defined ;
1963 void yyset_lineno (
int _line_number , yyscan_t yyscanner)
1968 if (! YY_CURRENT_BUFFER )
1969 YY_FATAL_ERROR(
"yyset_lineno called with no buffer" );
1971 yylineno = _line_number;
1978 void yyset_column (
int _column_no , yyscan_t yyscanner)
1983 if (! YY_CURRENT_BUFFER )
1984 YY_FATAL_ERROR(
"yyset_column called with no buffer" );
1986 yycolumn = _column_no;
1995 void yyset_in (FILE * _in_str , yyscan_t yyscanner)
2001 void yyset_out (FILE * _out_str , yyscan_t yyscanner)
2007 int yyget_debug (yyscan_t yyscanner)
2010 return yy_flex_debug;
2013 void yyset_debug (
int _bdebug , yyscan_t yyscanner)
2016 yy_flex_debug = _bdebug ;
2021 YYSTYPE * yyget_lval (yyscan_t yyscanner)
2027 void yyset_lval (
YYSTYPE * yylval_param , yyscan_t yyscanner)
2030 yylval = yylval_param;
2040 int yylex_init(yyscan_t* ptr_yy_globals)
2043 if (ptr_yy_globals == NULL){
2048 *ptr_yy_globals = (yyscan_t)
yyalloc (
sizeof(
struct yyguts_t ), NULL );
2050 if (*ptr_yy_globals == NULL){
2056 memset(*ptr_yy_globals,0x00,
sizeof(
struct yyguts_t));
2058 return yy_init_globals ( *ptr_yy_globals );
2069 int yylex_init_extra(YY_EXTRA_TYPE yy_user_defined,yyscan_t* ptr_yy_globals )
2074 yyset_extra (yy_user_defined, &dummy_yyguts);
2076 if (ptr_yy_globals == NULL){
2081 *ptr_yy_globals = (yyscan_t)
yyalloc (
sizeof(
struct yyguts_t ), &dummy_yyguts );
2083 if (*ptr_yy_globals == NULL){
2090 memset(*ptr_yy_globals,0x00,
sizeof(
struct yyguts_t));
2092 yyset_extra (yy_user_defined, *ptr_yy_globals);
2094 return yy_init_globals ( *ptr_yy_globals );
2097 static int yy_init_globals (yyscan_t yyscanner)
2107 yyg->yy_c_buf_p = NULL;
2111 yyg->yy_start_stack_ptr = 0;
2112 yyg->yy_start_stack_depth = 0;
2113 yyg->yy_start_stack = NULL;
2131 int yylex_destroy (yyscan_t yyscanner)
2136 while(YY_CURRENT_BUFFER){
2137 yy_delete_buffer(YY_CURRENT_BUFFER ,yyscanner );
2138 YY_CURRENT_BUFFER_LVALUE = NULL;
2139 yypop_buffer_state(yyscanner);
2147 yyfree(yyg->yy_start_stack ,yyscanner );
2148 yyg->yy_start_stack = NULL;
2152 yy_init_globals( yyscanner);
2155 yyfree ( yyscanner , yyscanner );
2165 static void yy_flex_strncpy (
char* s1, yyconst
char * s2,
int n , yyscan_t yyscanner)
2171 for ( i = 0; i < n; ++i )
2176 #ifdef YY_NEED_STRLEN
2177 static int yy_flex_strlen (yyconst
char * s , yyscan_t yyscanner)
2180 for ( n = 0; s[n]; ++n )
2187 void *
yyalloc (yy_size_t size , yyscan_t yyscanner)
2191 return malloc(size);
2194 void *yyrealloc (
void * ptr, yy_size_t size , yyscan_t yyscanner)
2206 return realloc(ptr, size);
2209 void yyfree (
void * ptr , yyscan_t yyscanner)
2213 free( (
char *) ptr );
2216 #define YYTABLES_NAME "yytables"
2218 #line 87 "_jsgf_scanner.l"
Internal definitions for JSGF grammar compiler.
size_t yy_buffer_stack_top
index of top of stack.
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.
SPHINXBASE_EXPORT double atof_c(char const *str)
Locale independent version of atof().
int yy_bs_column
The column count.