51 #define YYBISON_VERSION "3.5"
54 #define YYSKELETON_NAME "yacc.c"
69 #line 37 "jsgf_parser.y"
71 #define YYERROR_VERBOSE
81 #include "jsgf_parser.h"
82 #include "jsgf_scanner.h"
86 #pragma warning(disable: 4273)
89 void yyerror(yyscan_t lex,
jsgf_t *jsgf,
const char *s);
92 #line 93 "jsgf_parser.c"
96 # define YY_CAST(Type, Val) static_cast<Type> (Val)
97 # define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type> (Val)
99 # define YY_CAST(Type, Val) ((Type) (Val))
100 # define YY_REINTERPRET_CAST(Type, Val) ((Type) (Val))
104 # if defined __cplusplus
105 # if 201103L <= __cplusplus
106 # define YY_NULLPTR nullptr
108 # define YY_NULLPTR 0
111 # define YY_NULLPTR ((void*)0)
116 #ifdef YYERROR_VERBOSE
117 # undef YYERROR_VERBOSE
118 # define YYERROR_VERBOSE 1
120 # define YYERROR_VERBOSE 0
125 #ifndef YY_YY_JSGF_PARSER_H_INCLUDED
126 # define YY_YY_JSGF_PARSER_H_INCLUDED
161 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
164 #line 65 "jsgf_parser.y"
172 #line 173 "jsgf_parser.c"
176 # define YYSTYPE_IS_TRIVIAL 1
177 # define YYSTYPE_IS_DECLARED 1
182 int yyparse (
void* yyscanner,
jsgf_t *jsgf);
196 #ifndef __PTRDIFF_MAX__
198 # if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
209 #ifdef __INT_LEAST8_MAX__
210 typedef __INT_LEAST8_TYPE__ yytype_int8;
211 #elif defined YY_STDINT_H
212 typedef int_least8_t yytype_int8;
214 typedef signed char yytype_int8;
217 #ifdef __INT_LEAST16_MAX__
218 typedef __INT_LEAST16_TYPE__ yytype_int16;
219 #elif defined YY_STDINT_H
220 typedef int_least16_t yytype_int16;
222 typedef short yytype_int16;
225 #if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
226 typedef __UINT_LEAST8_TYPE__ yytype_uint8;
227 #elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \
228 && UINT_LEAST8_MAX <= INT_MAX)
229 typedef uint_least8_t yytype_uint8;
230 #elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
231 typedef unsigned char yytype_uint8;
233 typedef short yytype_uint8;
236 #if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
237 typedef __UINT_LEAST16_TYPE__ yytype_uint16;
238 #elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H \
239 && UINT_LEAST16_MAX <= INT_MAX)
240 typedef uint_least16_t yytype_uint16;
241 #elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
242 typedef unsigned short yytype_uint16;
244 typedef int yytype_uint16;
248 # if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
249 # define YYPTRDIFF_T __PTRDIFF_TYPE__
250 # define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
251 # elif defined PTRDIFF_MAX
255 # define YYPTRDIFF_T ptrdiff_t
256 # define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
258 # define YYPTRDIFF_T long
259 # define YYPTRDIFF_MAXIMUM LONG_MAX
264 # ifdef __SIZE_TYPE__
265 # define YYSIZE_T __SIZE_TYPE__
266 # elif defined size_t
267 # define YYSIZE_T size_t
268 # elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
270 # define YYSIZE_T size_t
272 # define YYSIZE_T unsigned
276 #define YYSIZE_MAXIMUM \
277 YY_CAST (YYPTRDIFF_T, \
278 (YYPTRDIFF_MAXIMUM < YY_CAST (YYSIZE_T, -1) \
279 ? YYPTRDIFF_MAXIMUM \
280 : YY_CAST (YYSIZE_T, -1)))
282 #define YYSIZEOF(X) YY_CAST (YYPTRDIFF_T, sizeof (X))
285 typedef yytype_int8 yy_state_t;
288 typedef int yy_state_fast_t;
291 # if defined YYENABLE_NLS && YYENABLE_NLS
293 # include <libintl.h>
294 # define YY_(Msgid) dgettext ("bison-runtime", Msgid)
298 # define YY_(Msgid) Msgid
302 #ifndef YY_ATTRIBUTE_PURE
303 # if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
304 # define YY_ATTRIBUTE_PURE __attribute__ ((__pure__))
306 # define YY_ATTRIBUTE_PURE
310 #ifndef YY_ATTRIBUTE_UNUSED
311 # if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
312 # define YY_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
314 # define YY_ATTRIBUTE_UNUSED
319 #if ! defined lint || defined __GNUC__
320 # define YYUSE(E) ((void) (E))
325 #if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
327 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
328 _Pragma ("GCC diagnostic push") \
329 _Pragma ("GCC diagnostic ignored \"-Wuninitialized\"") \
330 _Pragma ("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
331 # define YY_IGNORE_MAYBE_UNINITIALIZED_END \
332 _Pragma ("GCC diagnostic pop")
334 # define YY_INITIAL_VALUE(Value) Value
336 #ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
337 # define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
338 # define YY_IGNORE_MAYBE_UNINITIALIZED_END
340 #ifndef YY_INITIAL_VALUE
341 # define YY_INITIAL_VALUE(Value)
344 #if defined __cplusplus && defined __GNUC__ && ! defined __ICC && 6 <= __GNUC__
345 # define YY_IGNORE_USELESS_CAST_BEGIN \
346 _Pragma ("GCC diagnostic push") \
347 _Pragma ("GCC diagnostic ignored \"-Wuseless-cast\"")
348 # define YY_IGNORE_USELESS_CAST_END \
349 _Pragma ("GCC diagnostic pop")
351 #ifndef YY_IGNORE_USELESS_CAST_BEGIN
352 # define YY_IGNORE_USELESS_CAST_BEGIN
353 # define YY_IGNORE_USELESS_CAST_END
357 #define YY_ASSERT(E) ((void) (0 && (E)))
359 #if ! defined yyoverflow || YYERROR_VERBOSE
363 # ifdef YYSTACK_USE_ALLOCA
364 # if YYSTACK_USE_ALLOCA
366 # define YYSTACK_ALLOC __builtin_alloca
367 # elif defined __BUILTIN_VA_ARG_INCR
370 # define YYSTACK_ALLOC __alloca
371 # elif defined _MSC_VER
373 # define alloca _alloca
375 # define YYSTACK_ALLOC alloca
376 # if ! defined _ALLOCA_H && ! defined EXIT_SUCCESS
379 # ifndef EXIT_SUCCESS
380 # define EXIT_SUCCESS 0
387 # ifdef YYSTACK_ALLOC
389 # define YYSTACK_FREE(Ptr) do { ; } while (0)
390 # ifndef YYSTACK_ALLOC_MAXIMUM
395 # define YYSTACK_ALLOC_MAXIMUM 4032
398 # define YYSTACK_ALLOC YYMALLOC
399 # define YYSTACK_FREE YYFREE
400 # ifndef YYSTACK_ALLOC_MAXIMUM
401 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
403 # if (defined __cplusplus && ! defined EXIT_SUCCESS \
404 && ! ((defined YYMALLOC || defined malloc) \
405 && (defined YYFREE || defined free)))
407 # ifndef EXIT_SUCCESS
408 # define EXIT_SUCCESS 0
412 # define YYMALLOC malloc
413 # if ! defined malloc && ! defined EXIT_SUCCESS
414 void *malloc (YYSIZE_T);
419 # if ! defined free && ! defined EXIT_SUCCESS
427 #if (! defined yyoverflow \
428 && (! defined __cplusplus \
429 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
434 yy_state_t yyss_alloc;
439 # define YYSTACK_GAP_MAXIMUM (YYSIZEOF (union yyalloc) - 1)
443 # define YYSTACK_BYTES(N) \
444 ((N) * (YYSIZEOF (yy_state_t) + YYSIZEOF (YYSTYPE)) \
445 + YYSTACK_GAP_MAXIMUM)
447 # define YYCOPY_NEEDED 1
454 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
457 YYPTRDIFF_T yynewbytes; \
458 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
459 Stack = &yyptr->Stack_alloc; \
460 yynewbytes = yystacksize * YYSIZEOF (*Stack) + YYSTACK_GAP_MAXIMUM; \
461 yyptr += yynewbytes / YYSIZEOF (*yyptr); \
467 #if defined YYCOPY_NEEDED && YYCOPY_NEEDED
471 # if defined __GNUC__ && 1 < __GNUC__
472 # define YYCOPY(Dst, Src, Count) \
473 __builtin_memcpy (Dst, Src, YY_CAST (YYSIZE_T, (Count)) * sizeof (*(Src)))
475 # define YYCOPY(Dst, Src, Count) \
479 for (yyi = 0; yyi < (Count); yyi++) \
480 (Dst)[yyi] = (Src)[yyi]; \
502 #define YYMAXUTOK 265
507 #define YYTRANSLATE(YYX) \
508 (0 <= (YYX) && (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
512 static const yytype_int8 yytranslate[] =
514 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
515 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
516 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
517 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
518 14, 15, 18, 19, 2, 2, 2, 2, 2, 2,
519 2, 2, 2, 2, 2, 2, 2, 2, 2, 11,
520 2, 12, 2, 2, 2, 2, 2, 2, 2, 2,
521 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
522 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
523 2, 16, 2, 17, 2, 2, 2, 2, 2, 2,
524 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
525 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
526 2, 2, 2, 2, 13, 2, 2, 2, 2, 2,
527 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
528 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
529 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
530 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
531 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
532 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
533 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
534 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
535 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
536 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
537 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
538 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
539 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
545 static const yytype_uint8 yyrline[] =
547 0, 82, 82, 83, 84, 87, 90, 91, 92, 93,
548 97, 100, 101, 104, 107, 108, 111, 112, 115, 116,
549 121, 123, 127, 128, 132, 133, 136, 139, 142, 143,
554 #if YYDEBUG || YYERROR_VERBOSE || 0
557 static const char *
const yytname[] =
559 "$end",
"error",
"$undefined",
"HEADER",
"GRAMMAR",
"IMPORT",
"PUBLIC",
560 "TOKEN",
"RULENAME",
"TAG",
"WEIGHT",
"';'",
"'='",
"'|'",
"'('",
"')'",
561 "'['",
"']'",
"'*'",
"'+'",
"$accept",
"grammar",
"header",
562 "jsgf_header",
"grammar_header",
"import_header",
"import_statement",
563 "rule_list",
"rule",
"alternate_list",
"rule_expansion",
564 "tagged_rule_item",
"rule_item",
"rule_group",
"rule_optional",
565 "rule_atom", YY_NULLPTR
572 static const yytype_int16 yytoknum[] =
574 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
575 265, 59, 61, 124, 40, 41, 91, 93, 42, 43
579 #define YYPACT_NINF (-37)
581 #define yypact_value_is_default(Yyn) \
582 ((Yyn) == YYPACT_NINF)
584 #define YYTABLE_NINF (-1)
586 #define yytable_value_is_error(Yyn) \
591 static const yytype_int8 yypact[] =
593 -1, -2, 36, 22, 35, 8, -37, -37, 32, 33,
594 30, 22, -37, 17, -37, 37, -37, 13, -37, 34,
595 31, -4, -37, 17, -37, 38, 39, -37, -37, -4,
596 -37, -37, 0, -4, -4, 18, -4, 42, -37, -37,
597 -37, 19, -37, -37, 21, 19, 20, 9, -37, -4,
598 42, -37, -37, -37, -37, -37, -37, -4
604 static const yytype_int8 yydefact[] =
606 0, 0, 0, 2, 0, 0, 6, 1, 0, 0,
607 0, 0, 11, 3, 14, 0, 5, 0, 7, 0,
608 0, 0, 12, 4, 15, 0, 0, 8, 13, 0,
609 28, 29, 0, 0, 0, 0, 18, 20, 22, 30,
610 31, 24, 10, 9, 0, 25, 0, 0, 16, 0,
611 21, 23, 32, 33, 17, 26, 27, 19
615 static const yytype_int8 yypgoto[] =
617 -37, -37, -37, -37, -37, -37, 41, 43, -12, -16,
618 -3, -36, -37, -37, -37, 15
622 static const yytype_int8 yydefgoto[] =
624 -1, 2, 3, 4, 16, 11, 12, 13, 14, 35,
625 36, 37, 38, 39, 40, 41
631 static const yytype_int8 yytable[] =
633 50, 24, 1, 30, 31, 5, 32, 30, 31, 6,
634 33, 24, 34, 44, 33, 17, 34, 46, 47, 18,
635 26, 50, 49, 9, 27, 10, 56, 8, 9, 48,
636 10, 49, 54, 49, 49, 55, 7, 52, 53, 15,
637 19, 20, 21, 29, 25, 28, 57, 45, 0, 42,
641 static const yytype_int8 yycheck[] =
643 36, 13, 3, 7, 8, 7, 10, 7, 8, 11,
644 14, 23, 16, 29, 14, 7, 16, 33, 34, 11,
645 7, 57, 13, 6, 11, 8, 17, 5, 6, 11,
646 8, 13, 11, 13, 13, 15, 0, 18, 19, 4,
647 8, 8, 12, 12, 7, 11, 49, 32, -1, 11,
653 static const yytype_int8 yystos[] =
655 0, 3, 21, 22, 23, 7, 11, 0, 5, 6,
656 8, 25, 26, 27, 28, 4, 24, 7, 11, 8,
657 8, 12, 26, 27, 28, 7, 7, 11, 11, 12,
658 7, 8, 10, 14, 16, 29, 30, 31, 32, 33,
659 34, 35, 11, 11, 29, 35, 29, 29, 11, 13,
660 31, 9, 18, 19, 11, 15, 17, 30
664 static const yytype_int8 yyr1[] =
666 0, 20, 21, 21, 21, 22, 23, 23, 23, 23,
667 24, 25, 25, 26, 27, 27, 28, 28, 29, 29,
668 30, 30, 31, 31, 32, 32, 33, 34, 35, 35,
673 static const yytype_int8 yyr2[] =
675 0, 2, 1, 2, 3, 2, 2, 3, 4, 5,
676 3, 1, 2, 3, 1, 2, 4, 5, 1, 3,
677 1, 2, 1, 2, 1, 2, 3, 3, 1, 1,
682 #define yyerrok (yyerrstatus = 0)
683 #define yyclearin (yychar = YYEMPTY)
687 #define YYACCEPT goto yyacceptlab
688 #define YYABORT goto yyabortlab
689 #define YYERROR goto yyerrorlab
692 #define YYRECOVERING() (!!yyerrstatus)
694 #define YYBACKUP(Token, Value) \
696 if (yychar == YYEMPTY) \
700 YYPOPSTACK (yylen); \
706 yyerror (yyscanner, jsgf, YY_("syntax error: cannot back up")); \
713 #define YYERRCODE 256
722 # define YYFPRINTF fprintf
725 # define YYDPRINTF(Args) \
732 #ifndef YY_LOCATION_PRINT
733 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
737 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
741 YYFPRINTF (stderr, "%s ", Title); \
742 yy_symbol_print (stderr, \
743 Type, Value, yyscanner, jsgf); \
744 YYFPRINTF (stderr, "\n"); \
754 yy_symbol_value_print (FILE *yyo,
int yytype,
YYSTYPE const *
const yyvaluep,
void* yyscanner,
jsgf_t *jsgf)
756 FILE *yyoutput = yyo;
763 if (yytype < YYNTOKENS)
764 YYPRINT (yyo, yytoknum[yytype], *yyvaluep);
766 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
768 YY_IGNORE_MAYBE_UNINITIALIZED_END
777 yy_symbol_print (FILE *yyo,
int yytype,
YYSTYPE const *
const yyvaluep,
void* yyscanner,
jsgf_t *jsgf)
779 YYFPRINTF (yyo,
"%s %s (",
780 yytype < YYNTOKENS ?
"token" :
"nterm", yytname[yytype]);
782 yy_symbol_value_print (yyo, yytype, yyvaluep, yyscanner, jsgf);
783 YYFPRINTF (yyo,
")");
792 yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
794 YYFPRINTF (stderr,
"Stack now");
795 for (; yybottom <= yytop; yybottom++)
797 int yybot = *yybottom;
798 YYFPRINTF (stderr,
" %d", yybot);
800 YYFPRINTF (stderr,
"\n");
803 # define YY_STACK_PRINT(Bottom, Top) \
806 yy_stack_print ((Bottom), (Top)); \
815 yy_reduce_print (yy_state_t *yyssp,
YYSTYPE *yyvsp,
int yyrule,
void* yyscanner,
jsgf_t *jsgf)
817 int yylno = yyrline[yyrule];
818 int yynrhs = yyr2[yyrule];
820 YYFPRINTF (stderr,
"Reducing stack by rule %d (line %d):\n",
823 for (yyi = 0; yyi < yynrhs; yyi++)
825 YYFPRINTF (stderr,
" $%d = ", yyi + 1);
826 yy_symbol_print (stderr,
827 yystos[yyssp[yyi + 1 - yynrhs]],
828 &yyvsp[(yyi + 1) - (yynrhs)]
830 YYFPRINTF (stderr,
"\n");
834 # define YY_REDUCE_PRINT(Rule) \
837 yy_reduce_print (yyssp, yyvsp, Rule, yyscanner, jsgf); \
844 # define YYDPRINTF(Args)
845 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
846 # define YY_STACK_PRINT(Bottom, Top)
847 # define YY_REDUCE_PRINT(Rule)
853 # define YYINITDEPTH 200
864 # define YYMAXDEPTH 10000
871 # if defined __GLIBC__ && defined _STRING_H
872 # define yystrlen(S) (YY_CAST (YYPTRDIFF_T, strlen (S)))
876 yystrlen (
const char *yystr)
879 for (yylen = 0; yystr[yylen]; yylen++)
887 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
888 # define yystpcpy stpcpy
893 yystpcpy (
char *yydest,
const char *yysrc)
896 const char *yys = yysrc;
898 while ((*yyd++ = *yys++) !=
'\0')
915 yytnamerr (
char *yyres,
const char *yystr)
920 char const *yyp = yystr;
927 goto do_not_strip_quotes;
931 goto do_not_strip_quotes;
947 do_not_strip_quotes: ;
951 return yystpcpy (yyres, yystr) - yyres;
953 return yystrlen (yystr);
966 yysyntax_error (YYPTRDIFF_T *yymsg_alloc,
char **yymsg,
967 yy_state_t *yyssp,
int yytoken)
969 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
971 const char *yyformat = YY_NULLPTR;
974 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
978 YYPTRDIFF_T yysize = 0;
1003 if (yytoken != YYEMPTY)
1005 int yyn = yypact[*yyssp];
1006 YYPTRDIFF_T yysize0 = yytnamerr (YY_NULLPTR, yytname[yytoken]);
1008 yyarg[yycount++] = yytname[yytoken];
1009 if (!yypact_value_is_default (yyn))
1014 int yyxbegin = yyn < 0 ? -yyn : 0;
1016 int yychecklim = YYLAST - yyn + 1;
1017 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
1020 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
1021 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR
1022 && !yytable_value_is_error (yytable[yyx + yyn]))
1024 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
1030 yyarg[yycount++] = yytname[yyx];
1033 = yysize + yytnamerr (YY_NULLPTR, yytname[yyx]);
1034 if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
1045 # define YYCASE_(N, S) \
1050 YYCASE_(0, YY_(
"syntax error"));
1051 YYCASE_(1, YY_(
"syntax error, unexpected %s"));
1052 YYCASE_(2, YY_(
"syntax error, unexpected %s, expecting %s"));
1053 YYCASE_(3, YY_(
"syntax error, unexpected %s, expecting %s or %s"));
1054 YYCASE_(4, YY_(
"syntax error, unexpected %s, expecting %s or %s or %s"));
1055 YYCASE_(5, YY_(
"syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1062 YYPTRDIFF_T yysize1 = yysize + (yystrlen (yyformat) - 2 * yycount) + 1;
1063 if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
1069 if (*yymsg_alloc < yysize)
1071 *yymsg_alloc = 2 * yysize;
1072 if (! (yysize <= *yymsg_alloc
1073 && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1074 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1084 while ((*yyp = *yyformat) !=
'\0')
1085 if (*yyp ==
'%' && yyformat[1] ==
's' && yyi < yycount)
1087 yyp += yytnamerr (yyp, yyarg[yyi++]);
1105 yydestruct (
const char *yymsg,
int yytype,
YYSTYPE *yyvaluep,
void* yyscanner,
jsgf_t *jsgf)
1112 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
1114 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1116 YY_IGNORE_MAYBE_UNINITIALIZED_END
1127 yyparse (
void* yyscanner,
jsgf_t *jsgf)
1136 YY_INITIAL_VALUE (
static YYSTYPE yyval_default;)
1137 YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
1142 yy_state_fast_t yystate;
1154 yy_state_t yyssa[YYINITDEPTH];
1163 YYPTRDIFF_T yystacksize;
1176 char *yymsg = yymsgbuf;
1177 YYPTRDIFF_T yymsg_alloc =
sizeof yymsgbuf;
1180 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1186 yyssp = yyss = yyssa;
1187 yyvsp = yyvs = yyvsa;
1188 yystacksize = YYINITDEPTH;
1190 YYDPRINTF ((stderr,
"Starting parse\n"));
1212 YYDPRINTF ((stderr,
"Entering state %d\n", yystate));
1213 YY_ASSERT (0 <= yystate && yystate < YYNSTATES);
1214 YY_IGNORE_USELESS_CAST_BEGIN
1215 *yyssp = YY_CAST (yy_state_t, yystate);
1216 YY_IGNORE_USELESS_CAST_END
1218 if (yyss + yystacksize - 1 <= yyssp)
1219 #if !defined yyoverflow && !defined YYSTACK_RELOCATE
1220 goto yyexhaustedlab;
1224 YYPTRDIFF_T yysize = yyssp - yyss + 1;
1226 # if defined yyoverflow
1231 yy_state_t *yyss1 = yyss;
1238 yyoverflow (YY_(
"memory exhausted"),
1239 &yyss1, yysize * YYSIZEOF (*yyssp),
1240 &yyvs1, yysize * YYSIZEOF (*yyvsp),
1247 if (YYMAXDEPTH <= yystacksize)
1248 goto yyexhaustedlab;
1250 if (YYMAXDEPTH < yystacksize)
1251 yystacksize = YYMAXDEPTH;
1254 yy_state_t *yyss1 = yyss;
1257 YYSTACK_ALLOC (YY_CAST (YYSIZE_T, YYSTACK_BYTES (yystacksize))));
1259 goto yyexhaustedlab;
1260 YYSTACK_RELOCATE (yyss_alloc, yyss);
1261 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1262 # undef YYSTACK_RELOCATE
1264 YYSTACK_FREE (yyss1);
1268 yyssp = yyss + yysize - 1;
1269 yyvsp = yyvs + yysize - 1;
1271 YY_IGNORE_USELESS_CAST_BEGIN
1272 YYDPRINTF ((stderr,
"Stack size increased to %ld\n",
1273 YY_CAST (
long, yystacksize)));
1274 YY_IGNORE_USELESS_CAST_END
1276 if (yyss + yystacksize - 1 <= yyssp)
1281 if (yystate == YYFINAL)
1295 yyn = yypact[yystate];
1296 if (yypact_value_is_default (yyn))
1302 if (yychar == YYEMPTY)
1304 YYDPRINTF ((stderr,
"Reading a token: "));
1305 yychar = yylex (&yylval, yyscanner);
1308 if (yychar <= YYEOF)
1310 yychar = yytoken = YYEOF;
1311 YYDPRINTF ((stderr,
"Now at end of input.\n"));
1315 yytoken = YYTRANSLATE (yychar);
1316 YY_SYMBOL_PRINT (
"Next token is", yytoken, &yylval, &yylloc);
1322 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1327 if (yytable_value_is_error (yyn))
1339 YY_SYMBOL_PRINT (
"Shifting", yytoken, &yylval, &yylloc);
1341 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1343 YY_IGNORE_MAYBE_UNINITIALIZED_END
1354 yyn = yydefact[yystate];
1375 yyval = yyvsp[1-yylen];
1378 YY_REDUCE_PRINT (yyn);
1382 #line 87 "jsgf_parser.y"
1383 { jsgf->
name = (yyvsp[0].name); }
1384 #line 1385 "jsgf_parser.c"
1388 #line 91 "jsgf_parser.y"
1389 { jsgf->
version = (yyvsp[-1].name); }
1390 #line 1391 "jsgf_parser.c"
1394 #line 92 "jsgf_parser.y"
1395 { jsgf->
version = (yyvsp[-2].name); jsgf->
charset = (yyvsp[-1].name); }
1396 #line 1397 "jsgf_parser.c"
1400 #line 93 "jsgf_parser.y"
1401 { jsgf->
version = (yyvsp[-3].name); jsgf->
charset = (yyvsp[-2].name);
1402 jsgf->
locale = (yyvsp[-1].name); }
1403 #line 1404 "jsgf_parser.c"
1407 #line 97 "jsgf_parser.y"
1408 { (yyval.name) = (yyvsp[-1].name); }
1409 #line 1410 "jsgf_parser.c"
1413 #line 104 "jsgf_parser.y"
1414 { jsgf_import_rule(jsgf, (yyvsp[-1].name));
ckd_free((yyvsp[-1].name)); }
1415 #line 1416 "jsgf_parser.c"
1419 #line 111 "jsgf_parser.y"
1420 { jsgf_define_rule(jsgf, (yyvsp[-3].name), (yyvsp[-1].rhs), 0);
ckd_free((yyvsp[-3].name)); }
1421 #line 1422 "jsgf_parser.c"
1425 #line 112 "jsgf_parser.y"
1426 { jsgf_define_rule(jsgf, (yyvsp[-3].name), (yyvsp[-1].rhs), 1);
ckd_free((yyvsp[-3].name)); }
1427 #line 1428 "jsgf_parser.c"
1431 #line 115 "jsgf_parser.y"
1432 { (yyval.rhs) = (yyvsp[0].rhs); (yyval.rhs)->atoms =
glist_reverse((yyval.rhs)->atoms); }
1433 #line 1434 "jsgf_parser.c"
1437 #line 116 "jsgf_parser.y"
1438 { (yyval.rhs) = (yyvsp[0].rhs);
1440 (yyval.rhs)->alt = (yyvsp[-2].rhs); }
1441 #line 1442 "jsgf_parser.c"
1445 #line 121 "jsgf_parser.y"
1446 { (yyval.rhs) =
ckd_calloc(1,
sizeof(*(yyval.rhs)));
1447 (yyval.rhs)->atoms =
glist_add_ptr((yyval.rhs)->atoms, (yyvsp[0].atom)); }
1448 #line 1449 "jsgf_parser.c"
1452 #line 123 "jsgf_parser.y"
1453 { (yyval.rhs) = (yyvsp[-1].rhs);
1454 (yyval.rhs)->atoms =
glist_add_ptr((yyval.rhs)->atoms, (yyvsp[0].atom)); }
1455 #line 1456 "jsgf_parser.c"
1459 #line 128 "jsgf_parser.y"
1460 { (yyval.atom) = (yyvsp[-1].atom);
1461 (yyval.atom)->tags =
glist_add_ptr((yyval.atom)->tags, (yyvsp[0].name)); }
1462 #line 1463 "jsgf_parser.c"
1466 #line 133 "jsgf_parser.y"
1467 { (yyval.atom) = (yyvsp[0].atom); (yyval.atom)->weight = (yyvsp[-1].weight); }
1468 #line 1469 "jsgf_parser.c"
1472 #line 136 "jsgf_parser.y"
1473 { (yyval.rule) = jsgf_define_rule(jsgf, NULL, (yyvsp[-1].rhs), 0); }
1474 #line 1475 "jsgf_parser.c"
1478 #line 139 "jsgf_parser.y"
1479 { (yyval.rule) = jsgf_optional_new(jsgf, (yyvsp[-1].rhs)); }
1480 #line 1481 "jsgf_parser.c"
1484 #line 142 "jsgf_parser.y"
1485 { (yyval.atom) = jsgf_atom_new((yyvsp[0].name), 1.0);
ckd_free((yyvsp[0].name)); }
1486 #line 1487 "jsgf_parser.c"
1490 #line 143 "jsgf_parser.y"
1491 { (yyval.atom) = jsgf_atom_new((yyvsp[0].name), 1.0);
ckd_free((yyvsp[0].name)); }
1492 #line 1493 "jsgf_parser.c"
1496 #line 144 "jsgf_parser.y"
1497 { (yyval.atom) = jsgf_atom_new((yyvsp[0].rule)->name, 1.0); }
1498 #line 1499 "jsgf_parser.c"
1502 #line 145 "jsgf_parser.y"
1503 { (yyval.atom) = jsgf_atom_new((yyvsp[0].rule)->name, 1.0); }
1504 #line 1505 "jsgf_parser.c"
1508 #line 146 "jsgf_parser.y"
1509 { (yyval.atom) = jsgf_kleene_new(jsgf, (yyvsp[-1].atom), 0); }
1510 #line 1511 "jsgf_parser.c"
1514 #line 147 "jsgf_parser.y"
1515 { (yyval.atom) = jsgf_kleene_new(jsgf, (yyvsp[-1].atom), 1); }
1516 #line 1517 "jsgf_parser.c"
1520 #line 1521 "jsgf_parser.c"
1535 YY_SYMBOL_PRINT (
"-> $$ =", yyr1[yyn], &yyval, &yyloc);
1539 YY_STACK_PRINT (yyss, yyssp);
1547 const int yylhs = yyr1[yyn] - YYNTOKENS;
1548 const int yyi = yypgoto[yylhs] + *yyssp;
1549 yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
1551 : yydefgoto[yylhs]);
1563 yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
1569 #if ! YYERROR_VERBOSE
1570 yyerror (yyscanner, jsgf, YY_(
"syntax error"));
1572 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
1575 char const *yymsgp = YY_(
"syntax error");
1576 int yysyntax_error_status;
1577 yysyntax_error_status = YYSYNTAX_ERROR;
1578 if (yysyntax_error_status == 0)
1580 else if (yysyntax_error_status == 1)
1582 if (yymsg != yymsgbuf)
1583 YYSTACK_FREE (yymsg);
1584 yymsg = YY_CAST (
char *, YYSTACK_ALLOC (YY_CAST (YYSIZE_T, yymsg_alloc)));
1588 yymsg_alloc =
sizeof yymsgbuf;
1589 yysyntax_error_status = 2;
1593 yysyntax_error_status = YYSYNTAX_ERROR;
1597 yyerror (yyscanner, jsgf, yymsgp);
1598 if (yysyntax_error_status == 2)
1599 goto yyexhaustedlab;
1601 # undef YYSYNTAX_ERROR
1607 if (yyerrstatus == 3)
1612 if (yychar <= YYEOF)
1615 if (yychar == YYEOF)
1620 yydestruct (
"Error: discarding",
1621 yytoken, &yylval, yyscanner, jsgf);
1644 YY_STACK_PRINT (yyss, yyssp);
1657 yyn = yypact[yystate];
1658 if (!yypact_value_is_default (yyn))
1661 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1674 yydestruct (
"Error: popping",
1675 yystos[yystate], yyvsp, yyscanner, jsgf);
1678 YY_STACK_PRINT (yyss, yyssp);
1681 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1683 YY_IGNORE_MAYBE_UNINITIALIZED_END
1687 YY_SYMBOL_PRINT (
"Shifting", yystos[yyn], yyvsp, yylsp);
1709 #if !defined yyoverflow || YYERROR_VERBOSE
1714 yyerror (yyscanner, jsgf, YY_(
"memory exhausted"));
1724 if (yychar != YYEMPTY)
1728 yytoken = YYTRANSLATE (yychar);
1729 yydestruct (
"Cleanup: discarding lookahead",
1730 yytoken, &yylval, yyscanner, jsgf);
1735 YY_STACK_PRINT (yyss, yyssp);
1736 while (yyssp != yyss)
1738 yydestruct (
"Cleanup: popping",
1739 yystos[*yyssp], yyvsp, yyscanner, jsgf);
1744 YYSTACK_FREE (yyss);
1747 if (yymsg != yymsgbuf)
1748 YYSTACK_FREE (yymsg);
1752 #line 150 "jsgf_parser.y"
1756 yyerror(yyscan_t lex,
jsgf_t *jsgf,
const char *s)
1758 E_ERROR(
"%s at line %d current token '%s'\n", s, yyget_lineno(lex), yyget_text(lex));