52 #define YYBISON_VERSION "3.7.4"
55 #define YYSKELETON_NAME "yacc.c"
70 #line 37 "jsgf_parser.y"
72 #define YYERROR_VERBOSE
82 #include "jsgf_parser.h"
83 #include "jsgf_scanner.h"
87 #pragma warning(disable: 4273)
90 void yyerror(yyscan_t lex,
jsgf_t *jsgf,
const char *s);
93 #line 94 "jsgf_parser.c"
97 # define YY_CAST(Type, Val) static_cast<Type> (Val)
98 # define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
100 # define YY_CAST(Type, Val) ((Type) (Val))
101 # define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
105 # if defined __cplusplus
106 # if 201103L <= __cplusplus
107 # define YY_NULLPTR nullptr
109 # define YY_NULLPTR 0
112 # define YY_NULLPTR ((void*)0)
118 #ifndef YY_YY_JSGF_PARSER_H_INCLUDED
119 # define YY_YY_JSGF_PARSER_H_INCLUDED
146 typedef enum yytokentype yytoken_kind_t;
163 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
166 #line 65 "jsgf_parser.y"
174 #line 175 "jsgf_parser.c"
178 # define YYSTYPE_IS_TRIVIAL 1
179 # define YYSTYPE_IS_DECLARED 1
184 int yyparse (
void* yyscanner,
jsgf_t *jsgf);
190 YYSYMBOL_YYEMPTY = -2,
192 YYSYMBOL_YYerror = 1,
193 YYSYMBOL_YYUNDEF = 2,
195 YYSYMBOL_GRAMMAR = 4,
199 YYSYMBOL_RULENAME = 8,
201 YYSYMBOL_WEIGHT = 10,
211 YYSYMBOL_YYACCEPT = 20,
212 YYSYMBOL_grammar = 21,
213 YYSYMBOL_header = 22,
214 YYSYMBOL_jsgf_header = 23,
215 YYSYMBOL_grammar_header = 24,
216 YYSYMBOL_import_header = 25,
217 YYSYMBOL_import_statement = 26,
218 YYSYMBOL_rule_list = 27,
220 YYSYMBOL_alternate_list = 29,
221 YYSYMBOL_rule_expansion = 30,
222 YYSYMBOL_tagged_rule_item = 31,
223 YYSYMBOL_rule_item = 32,
224 YYSYMBOL_rule_group = 33,
225 YYSYMBOL_rule_optional = 34,
226 YYSYMBOL_rule_atom = 35
228 typedef enum yysymbol_kind_t yysymbol_kind_t;
241 #ifndef __PTRDIFF_MAX__
243 # if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
254 #ifdef __INT_LEAST8_MAX__
255 typedef __INT_LEAST8_TYPE__ yytype_int8;
256 #elif defined YY_STDINT_H
257 typedef int_least8_t yytype_int8;
259 typedef signed char yytype_int8;
262 #ifdef __INT_LEAST16_MAX__
263 typedef __INT_LEAST16_TYPE__ yytype_int16;
264 #elif defined YY_STDINT_H
265 typedef int_least16_t yytype_int16;
267 typedef short yytype_int16;
270 #if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
271 typedef __UINT_LEAST8_TYPE__ yytype_uint8;
272 #elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
273 && UINT_LEAST8_MAX <= INT_MAX)
274 typedef uint_least8_t yytype_uint8;
275 #elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
276 typedef unsigned char yytype_uint8;
278 typedef short yytype_uint8;
281 #if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
282 typedef __UINT_LEAST16_TYPE__ yytype_uint16;
283 #elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
284 && UINT_LEAST16_MAX <= INT_MAX)
285 typedef uint_least16_t yytype_uint16;
286 #elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
287 typedef unsigned short yytype_uint16;
289 typedef int yytype_uint16;
293 # if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
294 # define YYPTRDIFF_T __PTRDIFF_TYPE__
295 # define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
296 # elif defined PTRDIFF_MAX
300 # define YYPTRDIFF_T ptrdiff_t
301 # define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
303 # define YYPTRDIFF_T long
304 # define YYPTRDIFF_MAXIMUM LONG_MAX
309 # ifdef __SIZE_TYPE__
310 # define YYSIZE_T __SIZE_TYPE__
311 # elif defined size_t
312 # define YYSIZE_T size_t
313 # elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
315 # define YYSIZE_T size_t
317 # define YYSIZE_T unsigned
321 #define YYSIZE_MAXIMUM \
322 YY_CAST (YYPTRDIFF_T, \
323 (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \
324 ? YYPTRDIFF_MAXIMUM \
325 : YY_CAST (YYSIZE_T, -1)))
327 #define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
331 typedef yytype_int8 yy_state_t;
334 typedef int yy_state_fast_t;
337 # if defined YYENABLE_NLS && YYENABLE_NLS
339 # include <libintl.h>
340 # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
344 # define YY_(Msgid) Msgid
349 #ifndef YY_ATTRIBUTE_PURE
350 # if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
351 # define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
353 # define YY_ATTRIBUTE_PURE
357 #ifndef YY_ATTRIBUTE_UNUSED
358 # if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
359 # define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
361 # define YY_ATTRIBUTE_UNUSED
366 #if ! defined lint || defined __GNUC__
367 # define YYUSE(E) ((void) (E))
372 #if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
374 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
375 _Pragma ("GCC diagnostic push") \
376 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \
377 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
378 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
379 _Pragma ("GCC diagnostic pop")
381 # define YY_INITIAL_VALUE(Value) Value
383 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
384 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
385 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
387 #ifndef YY_INITIAL_VALUE
388 # define YY_INITIAL_VALUE(Value)
391 #if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
392 # define YY_IGNORE_USELESS_CAST_BEGIN \
393 _Pragma ("GCC diagnostic push") \
394 _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
395 # define YY_IGNORE_USELESS_CAST_END \
396 _Pragma ("GCC diagnostic pop")
398 #ifndef YY_IGNORE_USELESS_CAST_BEGIN
399 # define YY_IGNORE_USELESS_CAST_BEGIN
400 # define YY_IGNORE_USELESS_CAST_END
404 #define YY_ASSERT(E) ((void) (0 && (E)))
406 #if !defined yyoverflow
410 # ifdef YYSTACK_USE_ALLOCA
411 # if YYSTACK_USE_ALLOCA
413 # define YYSTACK_ALLOC __builtin_alloca
414 # elif defined __BUILTIN_VA_ARG_INCR
417 # define YYSTACK_ALLOC __alloca
418 # elif defined _MSC_VER
420 # define alloca _alloca
422 # define YYSTACK_ALLOC alloca
423 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
426 # ifndef EXIT_SUCCESS
427 # define EXIT_SUCCESS 0
434 # ifdef YYSTACK_ALLOC
436 # define YYSTACK_FREE(Ptr) do { ; } while (0)
437 # ifndef YYSTACK_ALLOC_MAXIMUM
442 # define YYSTACK_ALLOC_MAXIMUM 4032
445 # define YYSTACK_ALLOC YYMALLOC
446 # define YYSTACK_FREE YYFREE
447 # ifndef YYSTACK_ALLOC_MAXIMUM
448 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
450 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
451 && ! ((defined YYMALLOC || defined malloc) \
452 && (defined YYFREE || defined free)))
454 # ifndef EXIT_SUCCESS
455 # define EXIT_SUCCESS 0
459 # define YYMALLOC malloc
460 # if ! defined malloc && ! defined EXIT_SUCCESS
461 void *malloc (YYSIZE_T);
466 # if ! defined free && ! defined EXIT_SUCCESS
473 #if (! defined yyoverflow \
474 && (! defined __cplusplus \
475 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
480 yy_state_t yyss_alloc;
485 # define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
489 # define YYSTACK_BYTES(N) \
490 ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \
491 + YYSTACK_GAP_MAXIMUM)
493 # define YYCOPY_NEEDED 1
500 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
503 YYPTRDIFF_T yynewbytes; \
504 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
505 Stack = &yyptr->Stack_alloc; \
506 yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
507 yyptr += yynewbytes / YYSIZEOF (*yyptr); \
513 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
517 # if defined __GNUC__ && 1 < __GNUC__
518 # define YYCOPY(Dst, Src, Count) \
519 __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
521 # define YYCOPY(Dst, Src, Count) \
525 for (yyi = 0; yyi < (Count); yyi++) \
526 (Dst)[yyi] = (Src)[yyi]; \
548 #define YYMAXUTOK 265
553 #define YYTRANSLATE(YYX) \
554 (0 <= (YYX) && (YYX) <= YYMAXUTOK \
555 ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \
560 static const yytype_int8 yytranslate[] =
562 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
563 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
564 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
565 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
566 14, 15, 18, 19, 2, 2, 2, 2, 2, 2,
567 2, 2, 2, 2, 2, 2, 2, 2, 2, 11,
568 2, 12, 2, 2, 2, 2, 2, 2, 2, 2,
569 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
570 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
571 2, 16, 2, 17, 2, 2, 2, 2, 2, 2,
572 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
573 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
574 2, 2, 2, 2, 13, 2, 2, 2, 2, 2,
575 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
576 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
577 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
578 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
579 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
580 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
581 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
582 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
583 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
584 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
585 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
586 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
587 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
593 static const yytype_uint8 yyrline[] =
595 0, 82, 82, 83, 84, 87, 90, 91, 92, 93,
596 97, 100, 101, 104, 107, 108, 111, 112, 115, 116,
597 121, 123, 127, 128, 132, 133, 136, 139, 142, 143,
603 #define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State])
608 static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED;
612 static const char *
const yytname[] =
614 "\"end of file\"",
"error",
"\"invalid token\"",
"HEADER",
"GRAMMAR",
615 "IMPORT",
"PUBLIC",
"TOKEN",
"RULENAME",
"TAG",
"WEIGHT",
"';'",
"'='",
616 "'|'",
"'('",
"')'",
"'['",
"']'",
"'*'",
"'+'",
"$accept",
"grammar",
617 "header",
"jsgf_header",
"grammar_header",
"import_header",
618 "import_statement",
"rule_list",
"rule",
"alternate_list",
619 "rule_expansion",
"tagged_rule_item",
"rule_item",
"rule_group",
620 "rule_optional",
"rule_atom", YY_NULLPTR
624 yysymbol_name (yysymbol_kind_t yysymbol)
626 return yytname[yysymbol];
633 static const yytype_int16 yytoknum[] =
635 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
636 265, 59, 61, 124, 40, 41, 91, 93, 42, 43
640 #define YYPACT_NINF (-37)
642 #define yypact_value_is_default(Yyn) \
643 ((Yyn) == YYPACT_NINF)
645 #define YYTABLE_NINF (-1)
647 #define yytable_value_is_error(Yyn) \
652 static const yytype_int8 yypact[] =
654 -1, -2, 36, 22, 35, 8, -37, -37, 32, 33,
655 30, 22, -37, 17, -37, 37, -37, 13, -37, 34,
656 31, -4, -37, 17, -37, 38, 39, -37, -37, -4,
657 -37, -37, 0, -4, -4, 18, -4, 42, -37, -37,
658 -37, 19, -37, -37, 21, 19, 20, 9, -37, -4,
659 42, -37, -37, -37, -37, -37, -37, -4
665 static const yytype_int8 yydefact[] =
667 0, 0, 0, 2, 0, 0, 6, 1, 0, 0,
668 0, 0, 11, 3, 14, 0, 5, 0, 7, 0,
669 0, 0, 12, 4, 15, 0, 0, 8, 13, 0,
670 28, 29, 0, 0, 0, 0, 18, 20, 22, 30,
671 31, 24, 10, 9, 0, 25, 0, 0, 16, 0,
672 21, 23, 32, 33, 17, 26, 27, 19
676 static const yytype_int8 yypgoto[] =
678 -37, -37, -37, -37, -37, -37, 41, 43, -12, -16,
679 -3, -36, -37, -37, -37, 15
683 static const yytype_int8 yydefgoto[] =
685 -1, 2, 3, 4, 16, 11, 12, 13, 14, 35,
686 36, 37, 38, 39, 40, 41
692 static const yytype_int8 yytable[] =
694 50, 24, 1, 30, 31, 5, 32, 30, 31, 6,
695 33, 24, 34, 44, 33, 17, 34, 46, 47, 18,
696 26, 50, 49, 9, 27, 10, 56, 8, 9, 48,
697 10, 49, 54, 49, 49, 55, 7, 52, 53, 15,
698 19, 20, 21, 29, 25, 28, 57, 45, 0, 42,
702 static const yytype_int8 yycheck[] =
704 36, 13, 3, 7, 8, 7, 10, 7, 8, 11,
705 14, 23, 16, 29, 14, 7, 16, 33, 34, 11,
706 7, 57, 13, 6, 11, 8, 17, 5, 6, 11,
707 8, 13, 11, 13, 13, 15, 0, 18, 19, 4,
708 8, 8, 12, 12, 7, 11, 49, 32, -1, 11,
714 static const yytype_int8 yystos[] =
716 0, 3, 21, 22, 23, 7, 11, 0, 5, 6,
717 8, 25, 26, 27, 28, 4, 24, 7, 11, 8,
718 8, 12, 26, 27, 28, 7, 7, 11, 11, 12,
719 7, 8, 10, 14, 16, 29, 30, 31, 32, 33,
720 34, 35, 11, 11, 29, 35, 29, 29, 11, 13,
721 31, 9, 18, 19, 11, 15, 17, 30
725 static const yytype_int8 yyr1[] =
727 0, 20, 21, 21, 21, 22, 23, 23, 23, 23,
728 24, 25, 25, 26, 27, 27, 28, 28, 29, 29,
729 30, 30, 31, 31, 32, 32, 33, 34, 35, 35,
734 static const yytype_int8 yyr2[] =
736 0, 2, 1, 2, 3, 2, 2, 3, 4, 5,
737 3, 1, 2, 3, 1, 2, 4, 5, 1, 3,
738 1, 2, 1, 2, 1, 2, 3, 3, 1, 1,
743 enum { YYENOMEM = -2 };
745 #define yyerrok (yyerrstatus = 0)
746 #define yyclearin (yychar = YYEMPTY)
748 #define YYACCEPT goto yyacceptlab
749 #define YYABORT goto yyabortlab
750 #define YYERROR goto yyerrorlab
753 #define YYRECOVERING() (!!yyerrstatus)
755 #define YYBACKUP(Token, Value) \
757 if (yychar == YYEMPTY) \
761 YYPOPSTACK (yylen); \
767 yyerror (yyscanner, jsgf, YY_("syntax error: cannot back up")); \
774 #define YYERRCODE YYUNDEF
782 # define YYFPRINTF fprintf
785 # define YYDPRINTF(Args) \
792 # ifndef YY_LOCATION_PRINT
793 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
797 # define YY_SYMBOL_PRINT(Title, Kind, Value, Location) \
801 YYFPRINTF (stderr, "%s ", Title); \
802 yy_symbol_print (stderr, \
803 Kind, Value, yyscanner, jsgf); \
804 YYFPRINTF (stderr, "\n"); \
814 yy_symbol_value_print (FILE *yyo,
815 yysymbol_kind_t yykind,
YYSTYPE const *
const yyvaluep,
void* yyscanner,
jsgf_t *jsgf)
817 FILE *yyoutput = yyo;
824 if (yykind < YYNTOKENS)
825 YYPRINT (yyo, yytoknum[yykind], *yyvaluep);
827 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
829 YY_IGNORE_MAYBE_UNINITIALIZED_END
838 yy_symbol_print (FILE *yyo,
839 yysymbol_kind_t yykind,
YYSTYPE const *
const yyvaluep,
void* yyscanner,
jsgf_t *jsgf)
841 YYFPRINTF (yyo,
"%s %s (",
842 yykind < YYNTOKENS ?
"token" :
"nterm", yysymbol_name (yykind));
844 yy_symbol_value_print (yyo, yykind, yyvaluep, yyscanner, jsgf);
845 YYFPRINTF (yyo,
")");
854 yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
856 YYFPRINTF (stderr,
"Stack now");
857 for (; yybottom <= yytop; yybottom++)
859 int yybot = *yybottom;
860 YYFPRINTF (stderr,
" %d", yybot);
862 YYFPRINTF (stderr,
"\n");
865 # define YY_STACK_PRINT(Bottom, Top) \
868 yy_stack_print ((Bottom), (Top)); \
877 yy_reduce_print (yy_state_t *yyssp,
YYSTYPE *yyvsp,
878 int yyrule,
void* yyscanner,
jsgf_t *jsgf)
880 int yylno = yyrline[yyrule];
881 int yynrhs = yyr2[yyrule];
883 YYFPRINTF (stderr,
"Reducing stack by rule %d (line %d):\n",
886 for (yyi = 0; yyi < yynrhs; yyi++)
888 YYFPRINTF (stderr,
" $%d = ", yyi + 1);
889 yy_symbol_print (stderr,
890 YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]),
891 &yyvsp[(yyi + 1) - (yynrhs)], yyscanner, jsgf);
892 YYFPRINTF (stderr,
"\n");
896 # define YY_REDUCE_PRINT(Rule) \
899 yy_reduce_print (yyssp, yyvsp, Rule, yyscanner, jsgf); \
906 # define YYDPRINTF(Args) ((void) 0)
907 # define YY_SYMBOL_PRINT(Title, Kind, Value, Location)
908 # define YY_STACK_PRINT(Bottom, Top)
909 # define YY_REDUCE_PRINT(Rule)
915 # define YYINITDEPTH 200
926 # define YYMAXDEPTH 10000
939 yydestruct (
const char *yymsg,
940 yysymbol_kind_t yykind,
YYSTYPE *yyvaluep,
void* yyscanner,
jsgf_t *jsgf)
947 YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp);
949 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
951 YY_IGNORE_MAYBE_UNINITIALIZED_END
964 yyparse (
void* yyscanner,
jsgf_t *jsgf)
973 YY_INITIAL_VALUE (
static YYSTYPE yyval_default;)
974 YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
979 yy_state_fast_t yystate = 0;
987 YYPTRDIFF_T yystacksize = YYINITDEPTH;
990 yy_state_t yyssa[YYINITDEPTH];
991 yy_state_t *yyss = yyssa;
992 yy_state_t *yyssp = yyss;
1003 yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY;
1010 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1016 YYDPRINTF ((stderr,
"Starting parse\n"));
1035 YYDPRINTF ((stderr,
"Entering state %d\n", yystate));
1036 YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
1037 YY_IGNORE_USELESS_CAST_BEGIN
1038 *yyssp = YY_CAST (yy_state_t, yystate);
1039 YY_IGNORE_USELESS_CAST_END
1040 YY_STACK_PRINT (yyss, yyssp);
1042 if (yyss + yystacksize - 1 <= yyssp)
1043 #if !defined yyoverflow && !defined YYSTACK_RELOCATE
1044 goto yyexhaustedlab;
1048 YYPTRDIFF_T yysize = yyssp - yyss + 1;
1050 # if defined yyoverflow
1055 yy_state_t *yyss1 = yyss;
1062 yyoverflow (YY_(
"memory exhausted"),
1063 &yyss1, yysize * YYSIZEOF (*yyssp),
1064 &yyvs1, yysize * YYSIZEOF (*yyvsp),
1071 if (YYMAXDEPTH <= yystacksize)
1072 goto yyexhaustedlab;
1074 if (YYMAXDEPTH < yystacksize)
1075 yystacksize = YYMAXDEPTH;
1078 yy_state_t *yyss1 = yyss;
1081 YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
1083 goto yyexhaustedlab;
1084 YYSTACK_RELOCATE (yyss_alloc, yyss);
1085 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1086 # undef YYSTACK_RELOCATE
1088 YYSTACK_FREE (yyss1);
1092 yyssp = yyss + yysize - 1;
1093 yyvsp = yyvs + yysize - 1;
1095 YY_IGNORE_USELESS_CAST_BEGIN
1096 YYDPRINTF ((stderr,
"Stack size increased to %ld\n",
1097 YY_CAST (
long, yystacksize)));
1098 YY_IGNORE_USELESS_CAST_END
1100 if (yyss + yystacksize - 1 <= yyssp)
1105 if (yystate == YYFINAL)
1119 yyn = yypact[yystate];
1120 if (yypact_value_is_default (yyn))
1126 if (yychar == YYEMPTY)
1128 YYDPRINTF ((stderr,
"Reading a token\n"));
1129 yychar = yylex (&yylval, yyscanner);
1132 if (yychar <= YYEOF)
1135 yytoken = YYSYMBOL_YYEOF;
1136 YYDPRINTF ((stderr,
"Now at end of input.\n"));
1138 else if (yychar == YYerror)
1145 yytoken = YYSYMBOL_YYerror;
1150 yytoken = YYTRANSLATE (yychar);
1151 YY_SYMBOL_PRINT (
"Next token is", yytoken, &yylval, &yylloc);
1157 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1162 if (yytable_value_is_error (yyn))
1174 YY_SYMBOL_PRINT (
"Shifting", yytoken, &yylval, &yylloc);
1176 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1178 YY_IGNORE_MAYBE_UNINITIALIZED_END
1189 yyn = yydefact[yystate];
1210 yyval = yyvsp[1-yylen];
1213 YY_REDUCE_PRINT (yyn);
1217 #line 87 "jsgf_parser.y"
1218 { jsgf->
name = (yyvsp[0].name); }
1219 #line 1220 "jsgf_parser.c"
1223 #line 91 "jsgf_parser.y"
1224 { jsgf->
version = (yyvsp[-1].name); }
1225 #line 1226 "jsgf_parser.c"
1229 #line 92 "jsgf_parser.y"
1230 { jsgf->
version = (yyvsp[-2].name); jsgf->
charset = (yyvsp[-1].name); }
1231 #line 1232 "jsgf_parser.c"
1235 #line 93 "jsgf_parser.y"
1236 { jsgf->
version = (yyvsp[-3].name); jsgf->
charset = (yyvsp[-2].name);
1237 jsgf->
locale = (yyvsp[-1].name); }
1238 #line 1239 "jsgf_parser.c"
1242 #line 97 "jsgf_parser.y"
1243 { (yyval.name) = (yyvsp[-1].name); }
1244 #line 1245 "jsgf_parser.c"
1248 #line 104 "jsgf_parser.y"
1249 { jsgf_import_rule(jsgf, (yyvsp[-1].name));
ckd_free((yyvsp[-1].name)); }
1250 #line 1251 "jsgf_parser.c"
1254 #line 111 "jsgf_parser.y"
1255 { jsgf_define_rule(jsgf, (yyvsp[-3].name), (yyvsp[-1].rhs), 0);
ckd_free((yyvsp[-3].name)); }
1256 #line 1257 "jsgf_parser.c"
1260 #line 112 "jsgf_parser.y"
1261 { jsgf_define_rule(jsgf, (yyvsp[-3].name), (yyvsp[-1].rhs), 1);
ckd_free((yyvsp[-3].name)); }
1262 #line 1263 "jsgf_parser.c"
1266 #line 115 "jsgf_parser.y"
1267 { (yyval.rhs) = (yyvsp[0].rhs); (yyval.rhs)->atoms =
glist_reverse((yyval.rhs)->atoms); }
1268 #line 1269 "jsgf_parser.c"
1272 #line 116 "jsgf_parser.y"
1273 { (yyval.rhs) = (yyvsp[0].rhs);
1275 (yyval.rhs)->alt = (yyvsp[-2].rhs); }
1276 #line 1277 "jsgf_parser.c"
1280 #line 121 "jsgf_parser.y"
1281 { (yyval.rhs) =
ckd_calloc(1,
sizeof(*(yyval.rhs)));
1282 (yyval.rhs)->atoms =
glist_add_ptr((yyval.rhs)->atoms, (yyvsp[0].atom)); }
1283 #line 1284 "jsgf_parser.c"
1287 #line 123 "jsgf_parser.y"
1288 { (yyval.rhs) = (yyvsp[-1].rhs);
1289 (yyval.rhs)->atoms =
glist_add_ptr((yyval.rhs)->atoms, (yyvsp[0].atom)); }
1290 #line 1291 "jsgf_parser.c"
1294 #line 128 "jsgf_parser.y"
1295 { (yyval.atom) = (yyvsp[-1].atom);
1296 (yyval.atom)->tags =
glist_add_ptr((yyval.atom)->tags, (yyvsp[0].name)); }
1297 #line 1298 "jsgf_parser.c"
1301 #line 133 "jsgf_parser.y"
1302 { (yyval.atom) = (yyvsp[0].atom); (yyval.atom)->weight = (yyvsp[-1].weight); }
1303 #line 1304 "jsgf_parser.c"
1307 #line 136 "jsgf_parser.y"
1308 { (yyval.rule) = jsgf_define_rule(jsgf, NULL, (yyvsp[-1].rhs), 0); }
1309 #line 1310 "jsgf_parser.c"
1313 #line 139 "jsgf_parser.y"
1314 { (yyval.rule) = jsgf_optional_new(jsgf, (yyvsp[-1].rhs)); }
1315 #line 1316 "jsgf_parser.c"
1319 #line 142 "jsgf_parser.y"
1320 { (yyval.atom) = jsgf_atom_new((yyvsp[0].name), 1.0);
ckd_free((yyvsp[0].name)); }
1321 #line 1322 "jsgf_parser.c"
1325 #line 143 "jsgf_parser.y"
1326 { (yyval.atom) = jsgf_atom_new((yyvsp[0].name), 1.0);
ckd_free((yyvsp[0].name)); }
1327 #line 1328 "jsgf_parser.c"
1331 #line 144 "jsgf_parser.y"
1332 { (yyval.atom) = jsgf_atom_new((yyvsp[0].rule)->name, 1.0); }
1333 #line 1334 "jsgf_parser.c"
1337 #line 145 "jsgf_parser.y"
1338 { (yyval.atom) = jsgf_atom_new((yyvsp[0].rule)->name, 1.0); }
1339 #line 1340 "jsgf_parser.c"
1343 #line 146 "jsgf_parser.y"
1344 { (yyval.atom) = jsgf_kleene_new(jsgf, (yyvsp[-1].atom), 0); }
1345 #line 1346 "jsgf_parser.c"
1349 #line 147 "jsgf_parser.y"
1350 { (yyval.atom) = jsgf_kleene_new(jsgf, (yyvsp[-1].atom), 1); }
1351 #line 1352 "jsgf_parser.c"
1355 #line 1356 "jsgf_parser.c"
1370 YY_SYMBOL_PRINT (
"-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc);
1381 const int yylhs = yyr1[yyn] - YYNTOKENS;
1382 const int yyi = yypgoto[yylhs] + *yyssp;
1383 yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
1385 : yydefgoto[yylhs]);
1397 yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar);
1402 yyerror (yyscanner, jsgf, YY_(
"syntax error"));
1405 if (yyerrstatus == 3)
1410 if (yychar <= YYEOF)
1413 if (yychar == YYEOF)
1418 yydestruct (
"Error: discarding",
1419 yytoken, &yylval, yyscanner, jsgf);
1442 YY_STACK_PRINT (yyss, yyssp);
1456 yyn = yypact[yystate];
1457 if (!yypact_value_is_default (yyn))
1459 yyn += YYSYMBOL_YYerror;
1460 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror)
1473 yydestruct (
"Error: popping",
1474 YY_ACCESSING_SYMBOL (yystate), yyvsp, yyscanner, jsgf);
1477 YY_STACK_PRINT (yyss, yyssp);
1480 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1482 YY_IGNORE_MAYBE_UNINITIALIZED_END
1486 YY_SYMBOL_PRINT (
"Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp);
1508 #if !defined yyoverflow
1513 yyerror (yyscanner, jsgf, YY_(
"memory exhausted"));
1523 if (yychar != YYEMPTY)
1527 yytoken = YYTRANSLATE (yychar);
1528 yydestruct (
"Cleanup: discarding lookahead",
1529 yytoken, &yylval, yyscanner, jsgf);
1534 YY_STACK_PRINT (yyss, yyssp);
1535 while (yyssp != yyss)
1537 yydestruct (
"Cleanup: popping",
1538 YY_ACCESSING_SYMBOL (+*yyssp), yyvsp, yyscanner, jsgf);
1543 YYSTACK_FREE (yyss);
1549 #line 150 "jsgf_parser.y"
1553 yyerror(yyscan_t lex,
jsgf_t *jsgf,
const char *s)
1555 E_ERROR(
"%s at line %d current token '%s'\n", s, yyget_lineno(lex), yyget_text(lex));
Sphinx's memory allocation/deallocation routines.
SPHINXBASE_EXPORT void ckd_free(void *ptr)
Test and free a 1-D array.
#define ckd_calloc(n, sz)
Macros to simplify the use of above functions.
Implementation of logging routines.
#define E_ERROR(...)
Print error message to error log.
SPHINXBASE_EXPORT glist_t glist_reverse(glist_t g)
Reverse the order of the given glist.
SPHINXBASE_EXPORT glist_t glist_add_ptr(glist_t g, void *ptr)
Create and prepend a new list node, with the given user-defined data, at the HEAD of the given generi...
Hash table implementation.
Internal definitions for JSGF grammar compiler.
char * locale
JSGF locale (default C)
char * charset
JSGF charset (default UTF-8)
char * version
JSGF version (from header)