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
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;
61 #define INT8_MIN (-128)
64 #define INT16_MIN (-32767-1)
67 #define INT32_MIN (-2147483647-1)
70 #define INT8_MAX (127)
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)
98 #if defined (__STDC__)
106 #define yyconst const
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
124 typedef 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
210 typedef 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]
293 void yyrestart (FILE *input_file ,yyscan_t yyscanner );
294 void yy_switch_to_buffer (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
295 YY_BUFFER_STATE yy_create_buffer (FILE *file,
int size ,yyscan_t yyscanner );
296 void yy_delete_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
297 void yy_flush_buffer (YY_BUFFER_STATE b ,yyscan_t yyscanner );
298 void yypush_buffer_state (YY_BUFFER_STATE new_buffer ,yyscan_t yyscanner );
299 void yypop_buffer_state (yyscan_t yyscanner );
301 static void yyensure_buffer_stack (yyscan_t yyscanner );
302 static void yy_load_buffer_state (yyscan_t yyscanner );
303 static 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)
307 YY_BUFFER_STATE yy_scan_buffer (
char *base,yy_size_t size ,yyscan_t yyscanner );
308 YY_BUFFER_STATE yy_scan_string (yyconst
char *yy_str ,yyscan_t yyscanner );
309 YY_BUFFER_STATE yy_scan_bytes (yyconst
char *bytes,
int len ,yyscan_t yyscanner );
311 void *
yyalloc (yy_size_t ,yyscan_t yyscanner );
312 void *yyrealloc (
void *,yy_size_t ,yyscan_t yyscanner );
313 void 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
344 typedef unsigned char YY_CHAR;
346 typedef int yy_state_type;
348 #define yytext_ptr yytext_r
350 static yy_state_type yy_get_previous_state (yyscan_t yyscanner );
351 static yy_state_type yy_try_NUL_trans (yy_state_type current_state ,yyscan_t yyscanner);
352 static int yy_get_next_buffer (yyscan_t yyscanner );
353 static 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;
374 static 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
389 static 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,
421 static 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,
429 static 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,
446 static 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,
463 static 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
505 static 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
548 static yyconst flex_int32_t yy_rule_can_match_eol[23] =
550 1, 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
558 #define YY_MORE_ADJ 0
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"
611 #define DECLCOMMENT 3
613 #ifndef YY_NO_UNISTD_H
621 #ifndef YY_EXTRA_TYPE
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;
661 static int yy_init_globals (yyscan_t yyscanner );
665 # define yylval yyg->yylval_r
667 int yylex_init (yyscan_t* scanner);
669 int yylex_init_extra (YY_EXTRA_TYPE user_defined,yyscan_t* scanner);
674 int yylex_destroy (yyscan_t yyscanner );
676 int yyget_debug (yyscan_t yyscanner );
678 void yyset_debug (
int debug_flag ,yyscan_t yyscanner );
680 YY_EXTRA_TYPE yyget_extra (yyscan_t yyscanner );
682 void yyset_extra (YY_EXTRA_TYPE user_defined ,yyscan_t yyscanner );
684 FILE *yyget_in (yyscan_t yyscanner );
686 void yyset_in (FILE * in_str ,yyscan_t yyscanner );
688 FILE *yyget_out (yyscan_t yyscanner );
690 void yyset_out (FILE * out_str ,yyscan_t yyscanner );
692 int yyget_leng (yyscan_t yyscanner );
694 char *yyget_text (yyscan_t yyscanner );
696 int yyget_lineno (yyscan_t yyscanner );
698 void yyset_lineno (
int line_number ,yyscan_t yyscanner );
700 YYSTYPE * yyget_lval (yyscan_t yyscanner );
702 void yyset_lval (
YYSTYPE * yylval_param ,yyscan_t yyscanner );
708 #ifndef YY_SKIP_YYWRAP
710 extern "C" int yywrap (yyscan_t yyscanner );
712 extern int yywrap (yyscan_t yyscanner );
716 static void yyunput (
int c,
char *buf_ptr ,yyscan_t yyscanner);
719 static void yy_flex_strncpy (
char *,yyconst
char *,
int ,yyscan_t yyscanner);
722 #ifdef YY_NEED_STRLEN
723 static int yy_flex_strlen (yyconst
char * ,yyscan_t yyscanner);
729 static int yyinput (yyscan_t yyscanner );
731 static 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"
1060 case YY_STATE_EOF(INITIAL):
1061 case YY_STATE_EOF(COMMENT):
1062 case YY_STATE_EOF(DECL):
1063 case 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" );
1202 static 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 )
1256 YY_BUFFER_STATE b = YY_CURRENT_BUFFER;
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;
1573 static 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);
1616 void yy_delete_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
1623 if ( b == YY_CURRENT_BUFFER )
1624 YY_CURRENT_BUFFER_LVALUE = (YY_BUFFER_STATE) 0;
1626 if ( b->yy_is_our_buffer )
1627 yyfree((
void *) b->yy_ch_buf ,yyscanner );
1629 yyfree((
void *) b ,yyscanner );
1633 extern 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;
1669 void yy_flush_buffer (YY_BUFFER_STATE b , yyscan_t yyscanner)
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 );
1699 void 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;
1730 void 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;
1750 static 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()" );
1800 YY_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 );
1837 YY_BUFFER_STATE yy_scan_string (yyconst
char * yystr , yyscan_t yyscanner)
1840 return yy_scan_bytes(yystr,strlen(yystr) ,yyscanner);
1850 YY_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
1884 static 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; \
1912 YY_EXTRA_TYPE yyget_extra (yyscan_t yyscanner)
1921 int yyget_lineno (yyscan_t yyscanner)
1925 if (! YY_CURRENT_BUFFER)
1934 int yyget_column (yyscan_t yyscanner)
1938 if (! YY_CURRENT_BUFFER)
1947 FILE *yyget_in (yyscan_t yyscanner)
1956 FILE *yyget_out (yyscan_t yyscanner)
1965 int yyget_leng (yyscan_t yyscanner)
1975 char *yyget_text (yyscan_t yyscanner)
1985 void yyset_extra (YY_EXTRA_TYPE user_defined , yyscan_t yyscanner)
1988 yyextra = user_defined ;
1995 void 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;
2010 void 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;
2027 void yyset_in (FILE * in_str , yyscan_t yyscanner)
2033 void yyset_out (FILE * out_str , yyscan_t yyscanner)
2039 int yyget_debug (yyscan_t yyscanner)
2042 return yy_flex_debug;
2045 void yyset_debug (
int bdebug , yyscan_t yyscanner)
2048 yy_flex_debug = bdebug ;
2053 YYSTYPE * yyget_lval (yyscan_t yyscanner)
2059 void yyset_lval (
YYSTYPE * yylval_param , yyscan_t yyscanner)
2062 yylval = yylval_param;
2072 int 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 );
2101 int 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 );
2129 static 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;
2163 int 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 );
2197 static 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
2206 static int yy_flex_strlen (yyconst
char * s , yyscan_t yyscanner)
2209 for ( n = 0; s[n]; ++n )
2216 void *
yyalloc (yy_size_t size , yyscan_t yyscanner)
2218 return (
void *) malloc( size );
2221 void *yyrealloc (
void * ptr, yy_size_t size , yyscan_t yyscanner)
2230 return (
void *) realloc( (
char *) ptr, size );
2233 void 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.
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.