52#define YYBISON_VERSION "3.8.2"
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)
90void 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
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
185int yyparse (
void* yyscanner,
jsgf_t *jsgf);
192 YYSYMBOL_YYEMPTY = -2,
194 YYSYMBOL_YYerror = 1,
195 YYSYMBOL_YYUNDEF = 2,
197 YYSYMBOL_GRAMMAR = 4,
201 YYSYMBOL_RULENAME = 8,
203 YYSYMBOL_WEIGHT = 10,
213 YYSYMBOL_YYACCEPT = 20,
214 YYSYMBOL_grammar = 21,
215 YYSYMBOL_header = 22,
216 YYSYMBOL_jsgf_header = 23,
217 YYSYMBOL_grammar_header = 24,
218 YYSYMBOL_import_header = 25,
219 YYSYMBOL_import_statement = 26,
220 YYSYMBOL_rule_list = 27,
222 YYSYMBOL_alternate_list = 29,
223 YYSYMBOL_rule_expansion = 30,
224 YYSYMBOL_tagged_rule_item = 31,
225 YYSYMBOL_rule_item = 32,
226 YYSYMBOL_rule_group = 33,
227 YYSYMBOL_rule_optional = 34,
228 YYSYMBOL_rule_atom = 35
230typedef enum yysymbol_kind_t yysymbol_kind_t;
243#ifndef __PTRDIFF_MAX__
245# if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
256#ifdef __INT_LEAST8_MAX__
257typedef __INT_LEAST8_TYPE__ yytype_int8;
258#elif defined YY_STDINT_H
259typedef int_least8_t yytype_int8;
261typedef signed char yytype_int8;
264#ifdef __INT_LEAST16_MAX__
265typedef __INT_LEAST16_TYPE__ yytype_int16;
266#elif defined YY_STDINT_H
267typedef int_least16_t yytype_int16;
269typedef short yytype_int16;
278# undef UINT_LEAST8_MAX
279# undef UINT_LEAST16_MAX
280# define UINT_LEAST8_MAX 255
281# define UINT_LEAST16_MAX 65535
284#if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
285typedef __UINT_LEAST8_TYPE__ yytype_uint8;
286#elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
287 && UINT_LEAST8_MAX <= INT_MAX)
288typedef uint_least8_t yytype_uint8;
289#elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
290typedef unsigned char yytype_uint8;
292typedef short yytype_uint8;
295#if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
296typedef __UINT_LEAST16_TYPE__ yytype_uint16;
297#elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
298 && UINT_LEAST16_MAX <= INT_MAX)
299typedef uint_least16_t yytype_uint16;
300#elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
301typedef unsigned short yytype_uint16;
303typedef int yytype_uint16;
307# if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
308# define YYPTRDIFF_T __PTRDIFF_TYPE__
309# define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
310# elif defined PTRDIFF_MAX
314# define YYPTRDIFF_T ptrdiff_t
315# define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
317# define YYPTRDIFF_T long
318# define YYPTRDIFF_MAXIMUM LONG_MAX
324# define YYSIZE_T __SIZE_TYPE__
326# define YYSIZE_T size_t
327# elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
329# define YYSIZE_T size_t
331# define YYSIZE_T unsigned
335#define YYSIZE_MAXIMUM \
336 YY_CAST (YYPTRDIFF_T, \
337 (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \
338 ? YYPTRDIFF_MAXIMUM \
339 : YY_CAST (YYSIZE_T, -1)))
341#define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
345typedef yytype_int8 yy_state_t;
348typedef int yy_state_fast_t;
351# if defined YYENABLE_NLS && YYENABLE_NLS
354# define YY_(Msgid) dgettext ("bison-runtime", Msgid)
358# define YY_(Msgid) Msgid
363#ifndef YY_ATTRIBUTE_PURE
364# if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
365# define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
367# define YY_ATTRIBUTE_PURE
371#ifndef YY_ATTRIBUTE_UNUSED
372# if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
373# define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
375# define YY_ATTRIBUTE_UNUSED
380#if ! defined lint || defined __GNUC__
381# define YY_USE(E) ((void) (E))
387#if defined __GNUC__ && ! defined __ICC && 406 <= __GNUC__ * 100 + __GNUC_MINOR__
388# if __GNUC__ * 100 + __GNUC_MINOR__ < 407
389# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
390 _Pragma ("GCC diagnostic push") \
391 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"")
393# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
394 _Pragma ("GCC diagnostic push") \
395 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \
396 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
398# define YY_IGNORE_MAYBE_UNINITIALIZED_END \
399 _Pragma ("GCC diagnostic pop")
401# define YY_INITIAL_VALUE(Value) Value
403#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
404# define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
405# define YY_IGNORE_MAYBE_UNINITIALIZED_END
407#ifndef YY_INITIAL_VALUE
408# define YY_INITIAL_VALUE(Value)
411#if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
412# define YY_IGNORE_USELESS_CAST_BEGIN \
413 _Pragma ("GCC diagnostic push") \
414 _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
415# define YY_IGNORE_USELESS_CAST_END \
416 _Pragma ("GCC diagnostic pop")
418#ifndef YY_IGNORE_USELESS_CAST_BEGIN
419# define YY_IGNORE_USELESS_CAST_BEGIN
420# define YY_IGNORE_USELESS_CAST_END
424#define YY_ASSERT(E) ((void) (0 && (E)))
426#if !defined yyoverflow
430# ifdef YYSTACK_USE_ALLOCA
431# if YYSTACK_USE_ALLOCA
433# define YYSTACK_ALLOC __builtin_alloca
434# elif defined __BUILTIN_VA_ARG_INCR
437# define YYSTACK_ALLOC __alloca
438# elif defined _MSC_VER
440# define alloca _alloca
442# define YYSTACK_ALLOC alloca
443# if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
447# define EXIT_SUCCESS 0
456# define YYSTACK_FREE(Ptr) do { ; } while (0)
457# ifndef YYSTACK_ALLOC_MAXIMUM
462# define YYSTACK_ALLOC_MAXIMUM 4032
465# define YYSTACK_ALLOC YYMALLOC
466# define YYSTACK_FREE YYFREE
467# ifndef YYSTACK_ALLOC_MAXIMUM
468# define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
470# if (defined __cplusplus && ! defined EXIT_SUCCESS \
471 && ! ((defined YYMALLOC || defined malloc) \
472 && (defined YYFREE || defined free)))
475# define EXIT_SUCCESS 0
479# define YYMALLOC malloc
480# if ! defined malloc && ! defined EXIT_SUCCESS
481void *malloc (YYSIZE_T);
486# if ! defined free && ! defined EXIT_SUCCESS
493#if (! defined yyoverflow \
494 && (! defined __cplusplus \
495 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
500 yy_state_t yyss_alloc;
505# define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
509# define YYSTACK_BYTES(N) \
510 ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \
511 + YYSTACK_GAP_MAXIMUM)
513# define YYCOPY_NEEDED 1
520# define YYSTACK_RELOCATE(Stack_alloc, Stack) \
523 YYPTRDIFF_T yynewbytes; \
524 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
525 Stack = &yyptr->Stack_alloc; \
526 yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
527 yyptr += yynewbytes / YYSIZEOF (*yyptr); \
533#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
537# if defined __GNUC__ && 1 < __GNUC__
538# define YYCOPY(Dst, Src, Count) \
539 __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
541# define YYCOPY(Dst, Src, Count) \
545 for (yyi = 0; yyi < (Count); yyi++) \
546 (Dst)[yyi] = (Src)[yyi]; \
573#define YYTRANSLATE(YYX) \
574 (0 <= (YYX) && (YYX) <= YYMAXUTOK \
575 ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \
580static const yytype_int8 yytranslate[] =
582 0, 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 14, 15, 18, 19, 2, 2, 2, 2, 2, 2,
587 2, 2, 2, 2, 2, 2, 2, 2, 2, 11,
588 2, 12, 2, 2, 2, 2, 2, 2, 2, 2,
589 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
590 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
591 2, 16, 2, 17, 2, 2, 2, 2, 2, 2,
592 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
593 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
594 2, 2, 2, 2, 13, 2, 2, 2, 2, 2,
595 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
596 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
597 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
598 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
599 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
600 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
601 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
602 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
603 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
604 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
605 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
606 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
607 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
613static const yytype_uint8 yyrline[] =
615 0, 82, 82, 83, 84, 87, 90, 91, 92, 93,
616 97, 100, 101, 104, 107, 108, 111, 112, 115, 116,
617 121, 123, 127, 128, 132, 133, 136, 139, 142, 143,
623#define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State])
628static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED;
632static const char *
const yytname[] =
634 "\"end of file\"",
"error",
"\"invalid token\"",
"HEADER",
"GRAMMAR",
635 "IMPORT",
"PUBLIC",
"TOKEN",
"RULENAME",
"TAG",
"WEIGHT",
"';'",
"'='",
636 "'|'",
"'('",
"')'",
"'['",
"']'",
"'*'",
"'+'",
"$accept",
"grammar",
637 "header",
"jsgf_header",
"grammar_header",
"import_header",
638 "import_statement",
"rule_list",
"rule",
"alternate_list",
639 "rule_expansion",
"tagged_rule_item",
"rule_item",
"rule_group",
640 "rule_optional",
"rule_atom", YY_NULLPTR
644yysymbol_name (yysymbol_kind_t yysymbol)
646 return yytname[yysymbol];
650#define YYPACT_NINF (-37)
652#define yypact_value_is_default(Yyn) \
653 ((Yyn) == YYPACT_NINF)
655#define YYTABLE_NINF (-1)
657#define yytable_value_is_error(Yyn) \
662static const yytype_int8 yypact[] =
664 -1, -2, 36, 22, 35, 8, -37, -37, 32, 33,
665 30, 22, -37, 17, -37, 37, -37, 13, -37, 34,
666 31, -4, -37, 17, -37, 38, 39, -37, -37, -4,
667 -37, -37, 0, -4, -4, 18, -4, 42, -37, -37,
668 -37, 19, -37, -37, 21, 19, 20, 9, -37, -4,
669 42, -37, -37, -37, -37, -37, -37, -4
675static const yytype_int8 yydefact[] =
677 0, 0, 0, 2, 0, 0, 6, 1, 0, 0,
678 0, 0, 11, 3, 14, 0, 5, 0, 7, 0,
679 0, 0, 12, 4, 15, 0, 0, 8, 13, 0,
680 28, 29, 0, 0, 0, 0, 18, 20, 22, 30,
681 31, 24, 10, 9, 0, 25, 0, 0, 16, 0,
682 21, 23, 32, 33, 17, 26, 27, 19
686static const yytype_int8 yypgoto[] =
688 -37, -37, -37, -37, -37, -37, 41, 43, -12, -16,
689 -3, -36, -37, -37, -37, 15
693static const yytype_int8 yydefgoto[] =
695 0, 2, 3, 4, 16, 11, 12, 13, 14, 35,
696 36, 37, 38, 39, 40, 41
702static const yytype_int8 yytable[] =
704 50, 24, 1, 30, 31, 5, 32, 30, 31, 6,
705 33, 24, 34, 44, 33, 17, 34, 46, 47, 18,
706 26, 50, 49, 9, 27, 10, 56, 8, 9, 48,
707 10, 49, 54, 49, 49, 55, 7, 52, 53, 15,
708 19, 20, 21, 29, 25, 28, 57, 45, 0, 42,
712static const yytype_int8 yycheck[] =
714 36, 13, 3, 7, 8, 7, 10, 7, 8, 11,
715 14, 23, 16, 29, 14, 7, 16, 33, 34, 11,
716 7, 57, 13, 6, 11, 8, 17, 5, 6, 11,
717 8, 13, 11, 13, 13, 15, 0, 18, 19, 4,
718 8, 8, 12, 12, 7, 11, 49, 32, -1, 11,
724static const yytype_int8 yystos[] =
726 0, 3, 21, 22, 23, 7, 11, 0, 5, 6,
727 8, 25, 26, 27, 28, 4, 24, 7, 11, 8,
728 8, 12, 26, 27, 28, 7, 7, 11, 11, 12,
729 7, 8, 10, 14, 16, 29, 30, 31, 32, 33,
730 34, 35, 11, 11, 29, 35, 29, 29, 11, 13,
731 31, 9, 18, 19, 11, 15, 17, 30
735static const yytype_int8 yyr1[] =
737 0, 20, 21, 21, 21, 22, 23, 23, 23, 23,
738 24, 25, 25, 26, 27, 27, 28, 28, 29, 29,
739 30, 30, 31, 31, 32, 32, 33, 34, 35, 35,
744static const yytype_int8 yyr2[] =
746 0, 2, 1, 2, 3, 2, 2, 3, 4, 5,
747 3, 1, 2, 3, 1, 2, 4, 5, 1, 3,
748 1, 2, 1, 2, 1, 2, 3, 3, 1, 1,
753enum { YYENOMEM = -2 };
755#define yyerrok (yyerrstatus = 0)
756#define yyclearin (yychar = YYEMPTY)
758#define YYACCEPT goto yyacceptlab
759#define YYABORT goto yyabortlab
760#define YYERROR goto yyerrorlab
761#define YYNOMEM goto yyexhaustedlab
764#define YYRECOVERING() (!!yyerrstatus)
766#define YYBACKUP(Token, Value) \
768 if (yychar == YYEMPTY) \
772 YYPOPSTACK (yylen); \
778 yyerror (yyscanner, jsgf, YY_("syntax error: cannot back up")); \
785#define YYERRCODE YYUNDEF
793# define YYFPRINTF fprintf
796# define YYDPRINTF(Args) \
805# define YY_SYMBOL_PRINT(Title, Kind, Value, Location) \
809 YYFPRINTF (stderr, "%s ", Title); \
810 yy_symbol_print (stderr, \
811 Kind, Value, yyscanner, jsgf); \
812 YYFPRINTF (stderr, "\n"); \
822yy_symbol_value_print (FILE *yyo,
823 yysymbol_kind_t yykind,
YYSTYPE const *
const yyvaluep,
void* yyscanner,
jsgf_t *jsgf)
825 FILE *yyoutput = yyo;
831 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
833 YY_IGNORE_MAYBE_UNINITIALIZED_END
842yy_symbol_print (FILE *yyo,
843 yysymbol_kind_t yykind,
YYSTYPE const *
const yyvaluep,
void* yyscanner,
jsgf_t *jsgf)
845 YYFPRINTF (yyo,
"%s %s (",
846 yykind < YYNTOKENS ?
"token" :
"nterm", yysymbol_name (yykind));
848 yy_symbol_value_print (yyo, yykind, yyvaluep, yyscanner, jsgf);
849 YYFPRINTF (yyo,
")");
858yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
860 YYFPRINTF (stderr,
"Stack now");
861 for (; yybottom <= yytop; yybottom++)
863 int yybot = *yybottom;
864 YYFPRINTF (stderr,
" %d", yybot);
866 YYFPRINTF (stderr,
"\n");
869# define YY_STACK_PRINT(Bottom, Top) \
872 yy_stack_print ((Bottom), (Top)); \
881yy_reduce_print (yy_state_t *yyssp,
YYSTYPE *yyvsp,
882 int yyrule,
void* yyscanner,
jsgf_t *jsgf)
884 int yylno = yyrline[yyrule];
885 int yynrhs = yyr2[yyrule];
887 YYFPRINTF (stderr,
"Reducing stack by rule %d (line %d):\n",
890 for (yyi = 0; yyi < yynrhs; yyi++)
892 YYFPRINTF (stderr,
" $%d = ", yyi + 1);
893 yy_symbol_print (stderr,
894 YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]),
895 &yyvsp[(yyi + 1) - (yynrhs)], yyscanner, jsgf);
896 YYFPRINTF (stderr,
"\n");
900# define YY_REDUCE_PRINT(Rule) \
903 yy_reduce_print (yyssp, yyvsp, Rule, yyscanner, jsgf); \
910# define YYDPRINTF(Args) ((void) 0)
911# define YY_SYMBOL_PRINT(Title, Kind, Value, Location)
912# define YY_STACK_PRINT(Bottom, Top)
913# define YY_REDUCE_PRINT(Rule)
919# define YYINITDEPTH 200
930# define YYMAXDEPTH 10000
943yydestruct (
const char *yymsg,
944 yysymbol_kind_t yykind,
YYSTYPE *yyvaluep,
void* yyscanner,
jsgf_t *jsgf)
951 YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp);
953 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
955 YY_IGNORE_MAYBE_UNINITIALIZED_END
968yyparse (
void* yyscanner,
jsgf_t *jsgf)
977YY_INITIAL_VALUE (
static YYSTYPE yyval_default;)
978YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
983 yy_state_fast_t yystate = 0;
991 YYPTRDIFF_T yystacksize = YYINITDEPTH;
994 yy_state_t yyssa[YYINITDEPTH];
995 yy_state_t *yyss = yyssa;
996 yy_state_t *yyssp = yyss;
1007 yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY;
1014#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1020 YYDPRINTF ((stderr,
"Starting parse\n"));
1040 YYDPRINTF ((stderr,
"Entering state %d\n", yystate));
1041 YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
1042 YY_IGNORE_USELESS_CAST_BEGIN
1043 *yyssp = YY_CAST (yy_state_t, yystate);
1044 YY_IGNORE_USELESS_CAST_END
1045 YY_STACK_PRINT (yyss, yyssp);
1047 if (yyss + yystacksize - 1 <= yyssp)
1048#if !defined yyoverflow && !defined YYSTACK_RELOCATE
1053 YYPTRDIFF_T yysize = yyssp - yyss + 1;
1055# if defined yyoverflow
1060 yy_state_t *yyss1 = yyss;
1067 yyoverflow (YY_(
"memory exhausted"),
1068 &yyss1, yysize * YYSIZEOF (*yyssp),
1069 &yyvs1, yysize * YYSIZEOF (*yyvsp),
1076 if (YYMAXDEPTH <= yystacksize)
1079 if (YYMAXDEPTH < yystacksize)
1080 yystacksize = YYMAXDEPTH;
1083 yy_state_t *yyss1 = yyss;
1086 YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
1089 YYSTACK_RELOCATE (yyss_alloc, yyss);
1090 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1091# undef YYSTACK_RELOCATE
1093 YYSTACK_FREE (yyss1);
1097 yyssp = yyss + yysize - 1;
1098 yyvsp = yyvs + yysize - 1;
1100 YY_IGNORE_USELESS_CAST_BEGIN
1101 YYDPRINTF ((stderr,
"Stack size increased to %ld\n",
1102 YY_CAST (
long, yystacksize)));
1103 YY_IGNORE_USELESS_CAST_END
1105 if (yyss + yystacksize - 1 <= yyssp)
1111 if (yystate == YYFINAL)
1125 yyn = yypact[yystate];
1126 if (yypact_value_is_default (yyn))
1132 if (yychar == YYEMPTY)
1134 YYDPRINTF ((stderr,
"Reading a token\n"));
1135 yychar = yylex (&yylval, yyscanner);
1138 if (yychar <= YYEOF)
1141 yytoken = YYSYMBOL_YYEOF;
1142 YYDPRINTF ((stderr,
"Now at end of input.\n"));
1144 else if (yychar == YYerror)
1151 yytoken = YYSYMBOL_YYerror;
1156 yytoken = YYTRANSLATE (yychar);
1157 YY_SYMBOL_PRINT (
"Next token is", yytoken, &yylval, &yylloc);
1163 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1168 if (yytable_value_is_error (yyn))
1180 YY_SYMBOL_PRINT (
"Shifting", yytoken, &yylval, &yylloc);
1182 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1184 YY_IGNORE_MAYBE_UNINITIALIZED_END
1195 yyn = yydefact[yystate];
1216 yyval = yyvsp[1-yylen];
1219 YY_REDUCE_PRINT (yyn);
1223#line 87 "jsgf_parser.y"
1224 { jsgf->
name = (yyvsp[0].name); }
1225#line 1226 "jsgf_parser.c"
1229#line 91 "jsgf_parser.y"
1230 { jsgf->
version = (yyvsp[-1].name); }
1231#line 1232 "jsgf_parser.c"
1235#line 92 "jsgf_parser.y"
1236 { jsgf->
version = (yyvsp[-2].name); jsgf->
charset = (yyvsp[-1].name); }
1237#line 1238 "jsgf_parser.c"
1241#line 93 "jsgf_parser.y"
1242 { jsgf->
version = (yyvsp[-3].name); jsgf->
charset = (yyvsp[-2].name);
1243 jsgf->
locale = (yyvsp[-1].name); }
1244#line 1245 "jsgf_parser.c"
1248#line 97 "jsgf_parser.y"
1249 { (yyval.name) = (yyvsp[-1].name); }
1250#line 1251 "jsgf_parser.c"
1254#line 104 "jsgf_parser.y"
1255 { jsgf_import_rule(jsgf, (yyvsp[-1].name));
ckd_free((yyvsp[-1].name)); }
1256#line 1257 "jsgf_parser.c"
1260#line 111 "jsgf_parser.y"
1261 { jsgf_define_rule(jsgf, (yyvsp[-3].name), (yyvsp[-1].rhs), 0);
ckd_free((yyvsp[-3].name)); }
1262#line 1263 "jsgf_parser.c"
1266#line 112 "jsgf_parser.y"
1267 { jsgf_define_rule(jsgf, (yyvsp[-3].name), (yyvsp[-1].rhs), 1);
ckd_free((yyvsp[-3].name)); }
1268#line 1269 "jsgf_parser.c"
1272#line 115 "jsgf_parser.y"
1273 { (yyval.rhs) = (yyvsp[0].rhs); (yyval.rhs)->atoms =
glist_reverse((yyval.rhs)->atoms); }
1274#line 1275 "jsgf_parser.c"
1278#line 116 "jsgf_parser.y"
1279 { (yyval.rhs) = (yyvsp[0].rhs);
1281 (yyval.rhs)->alt = (yyvsp[-2].rhs); }
1282#line 1283 "jsgf_parser.c"
1286#line 121 "jsgf_parser.y"
1287 { (yyval.rhs) =
ckd_calloc(1,
sizeof(*(yyval.rhs)));
1288 (yyval.rhs)->atoms =
glist_add_ptr((yyval.rhs)->atoms, (yyvsp[0].atom)); }
1289#line 1290 "jsgf_parser.c"
1293#line 123 "jsgf_parser.y"
1294 { (yyval.rhs) = (yyvsp[-1].rhs);
1295 (yyval.rhs)->atoms =
glist_add_ptr((yyval.rhs)->atoms, (yyvsp[0].atom)); }
1296#line 1297 "jsgf_parser.c"
1300#line 128 "jsgf_parser.y"
1301 { (yyval.atom) = (yyvsp[-1].atom);
1302 (yyval.atom)->tags =
glist_add_ptr((yyval.atom)->tags, (yyvsp[0].name)); }
1303#line 1304 "jsgf_parser.c"
1307#line 133 "jsgf_parser.y"
1308 { (yyval.atom) = (yyvsp[0].atom); (yyval.atom)->weight = (yyvsp[-1].weight); }
1309#line 1310 "jsgf_parser.c"
1313#line 136 "jsgf_parser.y"
1314 { (yyval.rule) = jsgf_define_rule(jsgf, NULL, (yyvsp[-1].rhs), 0); }
1315#line 1316 "jsgf_parser.c"
1319#line 139 "jsgf_parser.y"
1320 { (yyval.rule) = jsgf_optional_new(jsgf, (yyvsp[-1].rhs)); }
1321#line 1322 "jsgf_parser.c"
1325#line 142 "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 143 "jsgf_parser.y"
1332 { (yyval.atom) = jsgf_atom_new((yyvsp[0].name), 1.0);
ckd_free((yyvsp[0].name)); }
1333#line 1334 "jsgf_parser.c"
1337#line 144 "jsgf_parser.y"
1338 { (yyval.atom) = jsgf_atom_new((yyvsp[0].rule)->name, 1.0); }
1339#line 1340 "jsgf_parser.c"
1343#line 145 "jsgf_parser.y"
1344 { (yyval.atom) = jsgf_atom_new((yyvsp[0].rule)->name, 1.0); }
1345#line 1346 "jsgf_parser.c"
1349#line 146 "jsgf_parser.y"
1350 { (yyval.atom) = jsgf_kleene_new(jsgf, (yyvsp[-1].atom), 0); }
1351#line 1352 "jsgf_parser.c"
1355#line 147 "jsgf_parser.y"
1356 { (yyval.atom) = jsgf_kleene_new(jsgf, (yyvsp[-1].atom), 1); }
1357#line 1358 "jsgf_parser.c"
1361#line 1362 "jsgf_parser.c"
1376 YY_SYMBOL_PRINT (
"-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc);
1387 const int yylhs = yyr1[yyn] - YYNTOKENS;
1388 const int yyi = yypgoto[yylhs] + *yyssp;
1389 yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
1391 : yydefgoto[yylhs]);
1403 yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar);
1408 yyerror (yyscanner, jsgf, YY_(
"syntax error"));
1411 if (yyerrstatus == 3)
1416 if (yychar <= YYEOF)
1419 if (yychar == YYEOF)
1424 yydestruct (
"Error: discarding",
1425 yytoken, &yylval, yyscanner, jsgf);
1449 YY_STACK_PRINT (yyss, yyssp);
1463 yyn = yypact[yystate];
1464 if (!yypact_value_is_default (yyn))
1466 yyn += YYSYMBOL_YYerror;
1467 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror)
1480 yydestruct (
"Error: popping",
1481 YY_ACCESSING_SYMBOL (yystate), yyvsp, yyscanner, jsgf);
1484 YY_STACK_PRINT (yyss, yyssp);
1487 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1489 YY_IGNORE_MAYBE_UNINITIALIZED_END
1493 YY_SYMBOL_PRINT (
"Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp);
1519 yyerror (yyscanner, jsgf, YY_(
"memory exhausted"));
1528 if (yychar != YYEMPTY)
1532 yytoken = YYTRANSLATE (yychar);
1533 yydestruct (
"Cleanup: discarding lookahead",
1534 yytoken, &yylval, yyscanner, jsgf);
1539 YY_STACK_PRINT (yyss, yyssp);
1540 while (yyssp != yyss)
1542 yydestruct (
"Cleanup: popping",
1543 YY_ACCESSING_SYMBOL (+*yyssp), yyvsp, yyscanner, jsgf);
1548 YYSTACK_FREE (yyss);
1554#line 150 "jsgf_parser.y"
1558yyerror(yyscan_t lex,
jsgf_t *jsgf,
const char *s)
1560 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)