52 #define YYBISON_VERSION "3.7.6"
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;
276 # undef UINT_LEAST8_MAX
277 # undef UINT_LEAST16_MAX
278 # define UINT_LEAST8_MAX 255
279 # define UINT_LEAST16_MAX 65535
282 #if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
283 typedef __UINT_LEAST8_TYPE__ yytype_uint8;
284 #elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
285 && UINT_LEAST8_MAX <= INT_MAX)
286 typedef uint_least8_t yytype_uint8;
287 #elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
288 typedef unsigned char yytype_uint8;
290 typedef short yytype_uint8;
293 #if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
294 typedef __UINT_LEAST16_TYPE__ yytype_uint16;
295 #elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
296 && UINT_LEAST16_MAX <= INT_MAX)
297 typedef uint_least16_t yytype_uint16;
298 #elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
299 typedef unsigned short yytype_uint16;
301 typedef int yytype_uint16;
305 # if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
306 # define YYPTRDIFF_T __PTRDIFF_TYPE__
307 # define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
308 # elif defined PTRDIFF_MAX
312 # define YYPTRDIFF_T ptrdiff_t
313 # define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
315 # define YYPTRDIFF_T long
316 # define YYPTRDIFF_MAXIMUM LONG_MAX
321 # ifdef __SIZE_TYPE__
322 # define YYSIZE_T __SIZE_TYPE__
323 # elif defined size_t
324 # define YYSIZE_T size_t
325 # elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
327 # define YYSIZE_T size_t
329 # define YYSIZE_T unsigned
333 #define YYSIZE_MAXIMUM \
334 YY_CAST (YYPTRDIFF_T, \
335 (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \
336 ? YYPTRDIFF_MAXIMUM \
337 : YY_CAST (YYSIZE_T, -1)))
339 #define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
343 typedef yytype_int8 yy_state_t;
346 typedef int yy_state_fast_t;
349 # if defined YYENABLE_NLS && YYENABLE_NLS
351 # include <libintl.h>
352 # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
356 # define YY_(Msgid) Msgid
361 #ifndef YY_ATTRIBUTE_PURE
362 # if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
363 # define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
365 # define YY_ATTRIBUTE_PURE
369 #ifndef YY_ATTRIBUTE_UNUSED
370 # if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
371 # define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
373 # define YY_ATTRIBUTE_UNUSED
378 #if ! defined lint || defined __GNUC__
379 # define YY_USE(E) ((void) (E))
384 #if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
386 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
387 _Pragma ("GCC diagnostic push") \
388 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \
389 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
390 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
391 _Pragma ("GCC diagnostic pop")
393 # define YY_INITIAL_VALUE(Value) Value
395 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
396 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
397 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
399 #ifndef YY_INITIAL_VALUE
400 # define YY_INITIAL_VALUE(Value)
403 #if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
404 # define YY_IGNORE_USELESS_CAST_BEGIN \
405 _Pragma ("GCC diagnostic push") \
406 _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
407 # define YY_IGNORE_USELESS_CAST_END \
408 _Pragma ("GCC diagnostic pop")
410 #ifndef YY_IGNORE_USELESS_CAST_BEGIN
411 # define YY_IGNORE_USELESS_CAST_BEGIN
412 # define YY_IGNORE_USELESS_CAST_END
416 #define YY_ASSERT(E) ((void) (0 && (E)))
418 #if !defined yyoverflow
422 # ifdef YYSTACK_USE_ALLOCA
423 # if YYSTACK_USE_ALLOCA
425 # define YYSTACK_ALLOC __builtin_alloca
426 # elif defined __BUILTIN_VA_ARG_INCR
429 # define YYSTACK_ALLOC __alloca
430 # elif defined _MSC_VER
432 # define alloca _alloca
434 # define YYSTACK_ALLOC alloca
435 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
438 # ifndef EXIT_SUCCESS
439 # define EXIT_SUCCESS 0
446 # ifdef YYSTACK_ALLOC
448 # define YYSTACK_FREE(Ptr) do { ; } while (0)
449 # ifndef YYSTACK_ALLOC_MAXIMUM
454 # define YYSTACK_ALLOC_MAXIMUM 4032
457 # define YYSTACK_ALLOC YYMALLOC
458 # define YYSTACK_FREE YYFREE
459 # ifndef YYSTACK_ALLOC_MAXIMUM
460 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
462 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
463 && ! ((defined YYMALLOC || defined malloc) \
464 && (defined YYFREE || defined free)))
466 # ifndef EXIT_SUCCESS
467 # define EXIT_SUCCESS 0
471 # define YYMALLOC malloc
472 # if ! defined malloc && ! defined EXIT_SUCCESS
473 void *malloc (YYSIZE_T);
478 # if ! defined free && ! defined EXIT_SUCCESS
485 #if (! defined yyoverflow \
486 && (! defined __cplusplus \
487 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
492 yy_state_t yyss_alloc;
497 # define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
501 # define YYSTACK_BYTES(N) \
502 ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \
503 + YYSTACK_GAP_MAXIMUM)
505 # define YYCOPY_NEEDED 1
512 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
515 YYPTRDIFF_T yynewbytes; \
516 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
517 Stack = &yyptr->Stack_alloc; \
518 yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
519 yyptr += yynewbytes / YYSIZEOF (*yyptr); \
525 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
529 # if defined __GNUC__ && 1 < __GNUC__
530 # define YYCOPY(Dst, Src, Count) \
531 __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
533 # define YYCOPY(Dst, Src, Count) \
537 for (yyi = 0; yyi < (Count); yyi++) \
538 (Dst)[yyi] = (Src)[yyi]; \
560 #define YYMAXUTOK 265
565 #define YYTRANSLATE(YYX) \
566 (0 <= (YYX) && (YYX) <= YYMAXUTOK \
567 ? YY_CAST (yysymbol_kind_t, yytranslate[YYX]) \
572 static const yytype_int8 yytranslate[] =
574 0, 2, 2, 2, 2, 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 14, 15, 18, 19, 2, 2, 2, 2, 2, 2,
579 2, 2, 2, 2, 2, 2, 2, 2, 2, 11,
580 2, 12, 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, 16, 2, 17, 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, 13, 2, 2, 2, 2, 2,
587 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
588 2, 2, 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, 2, 2, 2, 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, 2, 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, 1, 2, 3, 4,
605 static const yytype_uint8 yyrline[] =
607 0, 82, 82, 83, 84, 87, 90, 91, 92, 93,
608 97, 100, 101, 104, 107, 108, 111, 112, 115, 116,
609 121, 123, 127, 128, 132, 133, 136, 139, 142, 143,
615 #define YY_ACCESSING_SYMBOL(State) YY_CAST (yysymbol_kind_t, yystos[State])
620 static const char *yysymbol_name (yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED;
624 static const char *
const yytname[] =
626 "\"end of file\"",
"error",
"\"invalid token\"",
"HEADER",
"GRAMMAR",
627 "IMPORT",
"PUBLIC",
"TOKEN",
"RULENAME",
"TAG",
"WEIGHT",
"';'",
"'='",
628 "'|'",
"'('",
"')'",
"'['",
"']'",
"'*'",
"'+'",
"$accept",
"grammar",
629 "header",
"jsgf_header",
"grammar_header",
"import_header",
630 "import_statement",
"rule_list",
"rule",
"alternate_list",
631 "rule_expansion",
"tagged_rule_item",
"rule_item",
"rule_group",
632 "rule_optional",
"rule_atom", YY_NULLPTR
636 yysymbol_name (yysymbol_kind_t yysymbol)
638 return yytname[yysymbol];
645 static const yytype_int16 yytoknum[] =
647 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
648 265, 59, 61, 124, 40, 41, 91, 93, 42, 43
652 #define YYPACT_NINF (-37)
654 #define yypact_value_is_default(Yyn) \
655 ((Yyn) == YYPACT_NINF)
657 #define YYTABLE_NINF (-1)
659 #define yytable_value_is_error(Yyn) \
664 static const yytype_int8 yypact[] =
666 -1, -2, 36, 22, 35, 8, -37, -37, 32, 33,
667 30, 22, -37, 17, -37, 37, -37, 13, -37, 34,
668 31, -4, -37, 17, -37, 38, 39, -37, -37, -4,
669 -37, -37, 0, -4, -4, 18, -4, 42, -37, -37,
670 -37, 19, -37, -37, 21, 19, 20, 9, -37, -4,
671 42, -37, -37, -37, -37, -37, -37, -4
677 static const yytype_int8 yydefact[] =
679 0, 0, 0, 2, 0, 0, 6, 1, 0, 0,
680 0, 0, 11, 3, 14, 0, 5, 0, 7, 0,
681 0, 0, 12, 4, 15, 0, 0, 8, 13, 0,
682 28, 29, 0, 0, 0, 0, 18, 20, 22, 30,
683 31, 24, 10, 9, 0, 25, 0, 0, 16, 0,
684 21, 23, 32, 33, 17, 26, 27, 19
688 static const yytype_int8 yypgoto[] =
690 -37, -37, -37, -37, -37, -37, 41, 43, -12, -16,
691 -3, -36, -37, -37, -37, 15
695 static const yytype_int8 yydefgoto[] =
697 0, 2, 3, 4, 16, 11, 12, 13, 14, 35,
698 36, 37, 38, 39, 40, 41
704 static const yytype_int8 yytable[] =
706 50, 24, 1, 30, 31, 5, 32, 30, 31, 6,
707 33, 24, 34, 44, 33, 17, 34, 46, 47, 18,
708 26, 50, 49, 9, 27, 10, 56, 8, 9, 48,
709 10, 49, 54, 49, 49, 55, 7, 52, 53, 15,
710 19, 20, 21, 29, 25, 28, 57, 45, 0, 42,
714 static const yytype_int8 yycheck[] =
716 36, 13, 3, 7, 8, 7, 10, 7, 8, 11,
717 14, 23, 16, 29, 14, 7, 16, 33, 34, 11,
718 7, 57, 13, 6, 11, 8, 17, 5, 6, 11,
719 8, 13, 11, 13, 13, 15, 0, 18, 19, 4,
720 8, 8, 12, 12, 7, 11, 49, 32, -1, 11,
726 static const yytype_int8 yystos[] =
728 0, 3, 21, 22, 23, 7, 11, 0, 5, 6,
729 8, 25, 26, 27, 28, 4, 24, 7, 11, 8,
730 8, 12, 26, 27, 28, 7, 7, 11, 11, 12,
731 7, 8, 10, 14, 16, 29, 30, 31, 32, 33,
732 34, 35, 11, 11, 29, 35, 29, 29, 11, 13,
733 31, 9, 18, 19, 11, 15, 17, 30
737 static const yytype_int8 yyr1[] =
739 0, 20, 21, 21, 21, 22, 23, 23, 23, 23,
740 24, 25, 25, 26, 27, 27, 28, 28, 29, 29,
741 30, 30, 31, 31, 32, 32, 33, 34, 35, 35,
746 static const yytype_int8 yyr2[] =
748 0, 2, 1, 2, 3, 2, 2, 3, 4, 5,
749 3, 1, 2, 3, 1, 2, 4, 5, 1, 3,
750 1, 2, 1, 2, 1, 2, 3, 3, 1, 1,
755 enum { YYENOMEM = -2 };
757 #define yyerrok (yyerrstatus = 0)
758 #define yyclearin (yychar = YYEMPTY)
760 #define YYACCEPT goto yyacceptlab
761 #define YYABORT goto yyabortlab
762 #define YYERROR goto yyerrorlab
765 #define YYRECOVERING() (!!yyerrstatus)
767 #define YYBACKUP(Token, Value) \
769 if (yychar == YYEMPTY) \
773 YYPOPSTACK (yylen); \
779 yyerror (yyscanner, jsgf, YY_("syntax error: cannot back up")); \
786 #define YYERRCODE YYUNDEF
794 # define YYFPRINTF fprintf
797 # define YYDPRINTF(Args) \
804 # ifndef YY_LOCATION_PRINT
805 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
809 # define YY_SYMBOL_PRINT(Title, Kind, Value, Location) \
813 YYFPRINTF (stderr, "%s ", Title); \
814 yy_symbol_print (stderr, \
815 Kind, Value, yyscanner, jsgf); \
816 YYFPRINTF (stderr, "\n"); \
826 yy_symbol_value_print (FILE *yyo,
827 yysymbol_kind_t yykind,
YYSTYPE const *
const yyvaluep,
void* yyscanner,
jsgf_t *jsgf)
829 FILE *yyoutput = yyo;
836 if (yykind < YYNTOKENS)
837 YYPRINT (yyo, yytoknum[yykind], *yyvaluep);
839 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
841 YY_IGNORE_MAYBE_UNINITIALIZED_END
850 yy_symbol_print (FILE *yyo,
851 yysymbol_kind_t yykind,
YYSTYPE const *
const yyvaluep,
void* yyscanner,
jsgf_t *jsgf)
853 YYFPRINTF (yyo,
"%s %s (",
854 yykind < YYNTOKENS ?
"token" :
"nterm", yysymbol_name (yykind));
856 yy_symbol_value_print (yyo, yykind, yyvaluep, yyscanner, jsgf);
857 YYFPRINTF (yyo,
")");
866 yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
868 YYFPRINTF (stderr,
"Stack now");
869 for (; yybottom <= yytop; yybottom++)
871 int yybot = *yybottom;
872 YYFPRINTF (stderr,
" %d", yybot);
874 YYFPRINTF (stderr,
"\n");
877 # define YY_STACK_PRINT(Bottom, Top) \
880 yy_stack_print ((Bottom), (Top)); \
889 yy_reduce_print (yy_state_t *yyssp,
YYSTYPE *yyvsp,
890 int yyrule,
void* yyscanner,
jsgf_t *jsgf)
892 int yylno = yyrline[yyrule];
893 int yynrhs = yyr2[yyrule];
895 YYFPRINTF (stderr,
"Reducing stack by rule %d (line %d):\n",
898 for (yyi = 0; yyi < yynrhs; yyi++)
900 YYFPRINTF (stderr,
" $%d = ", yyi + 1);
901 yy_symbol_print (stderr,
902 YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]),
903 &yyvsp[(yyi + 1) - (yynrhs)], yyscanner, jsgf);
904 YYFPRINTF (stderr,
"\n");
908 # define YY_REDUCE_PRINT(Rule) \
911 yy_reduce_print (yyssp, yyvsp, Rule, yyscanner, jsgf); \
918 # define YYDPRINTF(Args) ((void) 0)
919 # define YY_SYMBOL_PRINT(Title, Kind, Value, Location)
920 # define YY_STACK_PRINT(Bottom, Top)
921 # define YY_REDUCE_PRINT(Rule)
927 # define YYINITDEPTH 200
938 # define YYMAXDEPTH 10000
951 yydestruct (
const char *yymsg,
952 yysymbol_kind_t yykind,
YYSTYPE *yyvaluep,
void* yyscanner,
jsgf_t *jsgf)
959 YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp);
961 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
963 YY_IGNORE_MAYBE_UNINITIALIZED_END
976 yyparse (
void* yyscanner,
jsgf_t *jsgf)
985 YY_INITIAL_VALUE (
static YYSTYPE yyval_default;)
986 YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
991 yy_state_fast_t yystate = 0;
999 YYPTRDIFF_T yystacksize = YYINITDEPTH;
1002 yy_state_t yyssa[YYINITDEPTH];
1003 yy_state_t *yyss = yyssa;
1004 yy_state_t *yyssp = yyss;
1015 yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY;
1022 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1028 YYDPRINTF ((stderr,
"Starting parse\n"));
1047 YYDPRINTF ((stderr,
"Entering state %d\n", yystate));
1048 YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
1049 YY_IGNORE_USELESS_CAST_BEGIN
1050 *yyssp = YY_CAST (yy_state_t, yystate);
1051 YY_IGNORE_USELESS_CAST_END
1052 YY_STACK_PRINT (yyss, yyssp);
1054 if (yyss + yystacksize - 1 <= yyssp)
1055 #if !defined yyoverflow && !defined YYSTACK_RELOCATE
1056 goto yyexhaustedlab;
1060 YYPTRDIFF_T yysize = yyssp - yyss + 1;
1062 # if defined yyoverflow
1067 yy_state_t *yyss1 = yyss;
1074 yyoverflow (YY_(
"memory exhausted"),
1075 &yyss1, yysize * YYSIZEOF (*yyssp),
1076 &yyvs1, yysize * YYSIZEOF (*yyvsp),
1083 if (YYMAXDEPTH <= yystacksize)
1084 goto yyexhaustedlab;
1086 if (YYMAXDEPTH < yystacksize)
1087 yystacksize = YYMAXDEPTH;
1090 yy_state_t *yyss1 = yyss;
1093 YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
1095 goto yyexhaustedlab;
1096 YYSTACK_RELOCATE (yyss_alloc, yyss);
1097 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1098 # undef YYSTACK_RELOCATE
1100 YYSTACK_FREE (yyss1);
1104 yyssp = yyss + yysize - 1;
1105 yyvsp = yyvs + yysize - 1;
1107 YY_IGNORE_USELESS_CAST_BEGIN
1108 YYDPRINTF ((stderr,
"Stack size increased to %ld\n",
1109 YY_CAST (
long, yystacksize)));
1110 YY_IGNORE_USELESS_CAST_END
1112 if (yyss + yystacksize - 1 <= yyssp)
1117 if (yystate == YYFINAL)
1131 yyn = yypact[yystate];
1132 if (yypact_value_is_default (yyn))
1138 if (yychar == YYEMPTY)
1140 YYDPRINTF ((stderr,
"Reading a token\n"));
1141 yychar = yylex (&yylval, yyscanner);
1144 if (yychar <= YYEOF)
1147 yytoken = YYSYMBOL_YYEOF;
1148 YYDPRINTF ((stderr,
"Now at end of input.\n"));
1150 else if (yychar == YYerror)
1157 yytoken = YYSYMBOL_YYerror;
1162 yytoken = YYTRANSLATE (yychar);
1163 YY_SYMBOL_PRINT (
"Next token is", yytoken, &yylval, &yylloc);
1169 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1174 if (yytable_value_is_error (yyn))
1186 YY_SYMBOL_PRINT (
"Shifting", yytoken, &yylval, &yylloc);
1188 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1190 YY_IGNORE_MAYBE_UNINITIALIZED_END
1201 yyn = yydefact[yystate];
1222 yyval = yyvsp[1-yylen];
1225 YY_REDUCE_PRINT (yyn);
1229 #line 87 "jsgf_parser.y"
1230 { jsgf->
name = (yyvsp[0].name); }
1231 #line 1232 "jsgf_parser.c"
1235 #line 91 "jsgf_parser.y"
1236 { jsgf->
version = (yyvsp[-1].name); }
1237 #line 1238 "jsgf_parser.c"
1241 #line 92 "jsgf_parser.y"
1242 { jsgf->
version = (yyvsp[-2].name); jsgf->
charset = (yyvsp[-1].name); }
1243 #line 1244 "jsgf_parser.c"
1247 #line 93 "jsgf_parser.y"
1248 { jsgf->
version = (yyvsp[-3].name); jsgf->
charset = (yyvsp[-2].name);
1249 jsgf->
locale = (yyvsp[-1].name); }
1250 #line 1251 "jsgf_parser.c"
1254 #line 97 "jsgf_parser.y"
1255 { (yyval.name) = (yyvsp[-1].name); }
1256 #line 1257 "jsgf_parser.c"
1260 #line 104 "jsgf_parser.y"
1261 { jsgf_import_rule(jsgf, (yyvsp[-1].name));
ckd_free((yyvsp[-1].name)); }
1262 #line 1263 "jsgf_parser.c"
1266 #line 111 "jsgf_parser.y"
1267 { jsgf_define_rule(jsgf, (yyvsp[-3].name), (yyvsp[-1].rhs), 0);
ckd_free((yyvsp[-3].name)); }
1268 #line 1269 "jsgf_parser.c"
1272 #line 112 "jsgf_parser.y"
1273 { jsgf_define_rule(jsgf, (yyvsp[-3].name), (yyvsp[-1].rhs), 1);
ckd_free((yyvsp[-3].name)); }
1274 #line 1275 "jsgf_parser.c"
1278 #line 115 "jsgf_parser.y"
1279 { (yyval.rhs) = (yyvsp[0].rhs); (yyval.rhs)->atoms =
glist_reverse((yyval.rhs)->atoms); }
1280 #line 1281 "jsgf_parser.c"
1284 #line 116 "jsgf_parser.y"
1285 { (yyval.rhs) = (yyvsp[0].rhs);
1287 (yyval.rhs)->alt = (yyvsp[-2].rhs); }
1288 #line 1289 "jsgf_parser.c"
1292 #line 121 "jsgf_parser.y"
1293 { (yyval.rhs) =
ckd_calloc(1,
sizeof(*(yyval.rhs)));
1294 (yyval.rhs)->atoms =
glist_add_ptr((yyval.rhs)->atoms, (yyvsp[0].atom)); }
1295 #line 1296 "jsgf_parser.c"
1299 #line 123 "jsgf_parser.y"
1300 { (yyval.rhs) = (yyvsp[-1].rhs);
1301 (yyval.rhs)->atoms =
glist_add_ptr((yyval.rhs)->atoms, (yyvsp[0].atom)); }
1302 #line 1303 "jsgf_parser.c"
1306 #line 128 "jsgf_parser.y"
1307 { (yyval.atom) = (yyvsp[-1].atom);
1308 (yyval.atom)->tags =
glist_add_ptr((yyval.atom)->tags, (yyvsp[0].name)); }
1309 #line 1310 "jsgf_parser.c"
1313 #line 133 "jsgf_parser.y"
1314 { (yyval.atom) = (yyvsp[0].atom); (yyval.atom)->weight = (yyvsp[-1].weight); }
1315 #line 1316 "jsgf_parser.c"
1319 #line 136 "jsgf_parser.y"
1320 { (yyval.rule) = jsgf_define_rule(jsgf, NULL, (yyvsp[-1].rhs), 0); }
1321 #line 1322 "jsgf_parser.c"
1325 #line 139 "jsgf_parser.y"
1326 { (yyval.rule) = jsgf_optional_new(jsgf, (yyvsp[-1].rhs)); }
1327 #line 1328 "jsgf_parser.c"
1331 #line 142 "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 143 "jsgf_parser.y"
1338 { (yyval.atom) = jsgf_atom_new((yyvsp[0].name), 1.0);
ckd_free((yyvsp[0].name)); }
1339 #line 1340 "jsgf_parser.c"
1343 #line 144 "jsgf_parser.y"
1344 { (yyval.atom) = jsgf_atom_new((yyvsp[0].rule)->name, 1.0); }
1345 #line 1346 "jsgf_parser.c"
1349 #line 145 "jsgf_parser.y"
1350 { (yyval.atom) = jsgf_atom_new((yyvsp[0].rule)->name, 1.0); }
1351 #line 1352 "jsgf_parser.c"
1355 #line 146 "jsgf_parser.y"
1356 { (yyval.atom) = jsgf_kleene_new(jsgf, (yyvsp[-1].atom), 0); }
1357 #line 1358 "jsgf_parser.c"
1361 #line 147 "jsgf_parser.y"
1362 { (yyval.atom) = jsgf_kleene_new(jsgf, (yyvsp[-1].atom), 1); }
1363 #line 1364 "jsgf_parser.c"
1367 #line 1368 "jsgf_parser.c"
1382 YY_SYMBOL_PRINT (
"-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc);
1393 const int yylhs = yyr1[yyn] - YYNTOKENS;
1394 const int yyi = yypgoto[yylhs] + *yyssp;
1395 yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
1397 : yydefgoto[yylhs]);
1409 yytoken = yychar == YYEMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE (yychar);
1414 yyerror (yyscanner, jsgf, YY_(
"syntax error"));
1417 if (yyerrstatus == 3)
1422 if (yychar <= YYEOF)
1425 if (yychar == YYEOF)
1430 yydestruct (
"Error: discarding",
1431 yytoken, &yylval, yyscanner, jsgf);
1454 YY_STACK_PRINT (yyss, yyssp);
1468 yyn = yypact[yystate];
1469 if (!yypact_value_is_default (yyn))
1471 yyn += YYSYMBOL_YYerror;
1472 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror)
1485 yydestruct (
"Error: popping",
1486 YY_ACCESSING_SYMBOL (yystate), yyvsp, yyscanner, jsgf);
1489 YY_STACK_PRINT (yyss, yyssp);
1492 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1494 YY_IGNORE_MAYBE_UNINITIALIZED_END
1498 YY_SYMBOL_PRINT (
"Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp);
1520 #if !defined yyoverflow
1525 yyerror (yyscanner, jsgf, YY_(
"memory exhausted"));
1535 if (yychar != YYEMPTY)
1539 yytoken = YYTRANSLATE (yychar);
1540 yydestruct (
"Cleanup: discarding lookahead",
1541 yytoken, &yylval, yyscanner, jsgf);
1546 YY_STACK_PRINT (yyss, yyssp);
1547 while (yyssp != yyss)
1549 yydestruct (
"Cleanup: popping",
1550 YY_ACCESSING_SYMBOL (+*yyssp), yyvsp, yyscanner, jsgf);
1555 YYSTACK_FREE (yyss);
1561 #line 150 "jsgf_parser.y"
1565 yyerror(yyscan_t lex,
jsgf_t *jsgf,
const char *s)
1567 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)