lrama 0.5.1 → 0.5.3

data/template/bison/yacc.c

@@ -114,7 +114,7 @@
 #ifndef YYDEBUG
 # define YYDEBUG 0
 #endif
-#if YYDEBUG
+#if YYDEBUG && !defined(yydebug)
 extern int yydebug;
 #endif
   <%-# b4_percent_code_get([[requires]]). %code is not supported -%>
@@ -542,6 +542,13 @@ static const <%= output.int_type_for(output.context.yytranslate) %> yytranslate[
 <%= output.yytranslate %>
 };
 
+<%- if output.error_recovery -%>
+/* YYTRANSLATE_INVERTED[SYMBOL-NUM] -- Token number corresponding to SYMBOL-NUM */
+static const <%= output.int_type_for(output.context.yytranslate_inverted) %> yytranslate_inverted[] =
+{
+<%= output.yytranslate_inverted %>
+};
+<%- end -%>
 #if YYDEBUG
 /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
 static const <%= output.int_type_for(output.context.yyrline) %> yyrline[] =
@@ -731,7 +738,7 @@ do {                                            \
 
    /* Temporary convenience wrapper in case some people defined the
       undocumented and private YY_LOCATION_PRINT macros.  */
-#   define YYLOCATION_PRINT(File, Loc)  YY_LOCATION_PRINT(File, *(Loc))
+#   define YYLOCATION_PRINT(File, Loc<%= output.user_args %>)  YY_LOCATION_PRINT(File, *(Loc)<%= output.user_args %>)
 
 #  elif defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
 
@@ -767,11 +774,11 @@ yy_location_print_ (FILE *yyo, YYLTYPE const * const yylocp)
 
     /* Temporary convenience wrapper in case some people defined the
        undocumented and private YY_LOCATION_PRINT macros.  */
-#   define YY_LOCATION_PRINT(File, Loc)  YYLOCATION_PRINT(File, &(Loc))
+#   define YY_LOCATION_PRINT(File, Loc<%= output.user_args %>)  YYLOCATION_PRINT(File, &(Loc)<%= output.user_args %>)
 
 #  else
 
-#   define YYLOCATION_PRINT(File, Loc) ((void) 0)
+#   define YYLOCATION_PRINT(File, Loc<%= output.user_args %>) ((void) 0)
     /* Temporary convenience wrapper in case some people defined the
        undocumented and private YY_LOCATION_PRINT macros.  */
 #   define YY_LOCATION_PRINT  YYLOCATION_PRINT
@@ -780,13 +787,13 @@ yy_location_print_ (FILE *yyo, YYLTYPE const * const yylocp)
 # endif /* !defined YYLOCATION_PRINT */
 
 
-# define YY_SYMBOL_PRINT(Title, Kind, Value, Location)                    \
+# define YY_SYMBOL_PRINT(Title, Kind, Value, Location<%= output.user_args %>) \
 do {                                                                      \
   if (yydebug)                                                            \
     {                                                                     \
       YYFPRINTF (stderr, "%s ", Title);                                   \
       yy_symbol_print (stderr,                                            \
-                  Kind, Value, Location, p); \
+                  Kind, Value, Location<%= output.user_args %>);          \
       YYFPRINTF (stderr, "\n");                                           \
     }                                                                     \
 } while (0)
@@ -828,9 +835,9 @@ yy_symbol_print (FILE *yyo,
   YYFPRINTF (yyo, "%s %s (",
              yykind < YYNTOKENS ? "token" : "nterm", yysymbol_name (yykind));
 
-  YYLOCATION_PRINT (yyo, yylocationp);
+  YYLOCATION_PRINT (yyo, yylocationp<%= output.user_args %>);
   YYFPRINTF (yyo, ": ");
-  yy_symbol_value_print (yyo, yykind, yyvaluep, yylocationp, p);
+  yy_symbol_value_print (yyo, yykind, yyvaluep, yylocationp<%= output.user_args %>);
   YYFPRINTF (yyo, ")");
 }
 
@@ -840,7 +847,7 @@ yy_symbol_print (FILE *yyo,
 `------------------------------------------------------------------*/
 
 static void
-yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
+yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop<%= output.user_formals %>)
 {
   YYFPRINTF (stderr, "Stack now");
   for (; yybottom <= yytop; yybottom++)
@@ -851,10 +858,10 @@ yy_stack_print (yy_state_t *yybottom, yy_state_t *yytop)
   YYFPRINTF (stderr, "\n");
 }
 
-# define YY_STACK_PRINT(Bottom, Top)                            \
+# define YY_STACK_PRINT(Bottom, Top<%= output.user_args %>)     \
 do {                                                            \
   if (yydebug)                                                  \
-    yy_stack_print ((Bottom), (Top));                           \
+    yy_stack_print ((Bottom), (Top)<%= output.user_args %>);    \
 } while (0)
 
 
@@ -878,25 +885,27 @@ yy_reduce_print (yy_state_t *yyssp, YYSTYPE *yyvsp, YYLTYPE *yylsp,
       yy_symbol_print (stderr,
                        YY_ACCESSING_SYMBOL (+yyssp[yyi + 1 - yynrhs]),
                        &yyvsp[(yyi + 1) - (yynrhs)],
-                       &(yylsp[(yyi + 1) - (yynrhs)]), p);
+                       &(yylsp[(yyi + 1) - (yynrhs)])<%= output.user_args %>);
       YYFPRINTF (stderr, "\n");
     }
 }
 
-# define YY_REDUCE_PRINT(Rule)          \
+# define YY_REDUCE_PRINT(Rule<%= output.user_args %>) \
 do {                                    \
   if (yydebug)                          \
-    yy_reduce_print (yyssp, yyvsp, yylsp, Rule, p); \
+    yy_reduce_print (yyssp, yyvsp, yylsp, Rule<%= output.user_args %>); \
 } while (0)
 
 /* Nonzero means print parse trace.  It is left uninitialized so that
    multiple parsers can coexist.  */
+#ifndef yydebug
 int yydebug;
+#endif
 #else /* !YYDEBUG */
 # define YYDPRINTF(Args) ((void) 0)
-# define YY_SYMBOL_PRINT(Title, Kind, Value, Location)
-# define YY_STACK_PRINT(Bottom, Top)
-# define YY_REDUCE_PRINT(Rule)
+# define YY_SYMBOL_PRINT(Title, Kind, Value, Location<%= output.user_args %>)
+# define YY_STACK_PRINT(Bottom, Top<%= output.user_args %>)
+# define YY_REDUCE_PRINT(Rule<%= output.user_args %>)
 #endif /* !YYDEBUG */
 
 
@@ -1110,7 +1119,7 @@ yy_syntax_error_arguments (const yypcontext_t *yyctx,
    required number of bytes is too large to store.  */
 static int
 yysyntax_error (YYPTRDIFF_T *yymsg_alloc, char **yymsg,
-                const yypcontext_t *yyctx)
+                const yypcontext_t *yyctx<%= output.user_formals %>)
 {
   enum { YYARGS_MAX = 5 };
   /* Internationalized format string. */
@@ -1200,7 +1209,7 @@ yydestruct (const char *yymsg,
 <%= output.parse_param_use("yyvaluep", "yylocationp") %>
   if (!yymsg)
     yymsg = "Deleting";
-  YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp);
+  YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp<%= output.user_args %>);
 
   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
   YY_USE (yykind);
@@ -1209,6 +1218,303 @@ yydestruct (const char *yymsg,
 
 
 
+<%- if output.error_recovery -%>
+#ifndef YYMAXREPAIR
+# define YYMAXREPAIR 3
+#endif
+
+enum repair_type {
+  insert,
+  delete,
+  shift,
+};
+
+struct repair {
+  enum repair_type type;
+  yysymbol_kind_t term;
+};
+typedef struct repair repair;
+
+struct repairs {
+  /* For debug */
+  int id;
+  /* For breadth-first traversing */
+  struct repairs *next;
+  YYPTRDIFF_T stack_length;
+  /* Bottom of states */
+  yy_state_t *states;
+  /* Top of states */
+  yy_state_t *state;
+  /* repair length */
+  int repair_length;
+  /*  */
+  struct repairs *prev_repair;
+  struct repair repair;
+};
+typedef struct repairs repairs;
+
+struct yy_term {
+  yysymbol_kind_t kind;
+  YYSTYPE value;
+  YYLTYPE location;
+};
+typedef struct yy_term yy_term;
+
+struct repair_terms {
+  int id;
+  int length;
+  yy_term terms[];
+};
+typedef struct repair_terms repair_terms;
+
+static void
+yy_error_token_initialize (yysymbol_kind_t yykind, YYSTYPE * const yyvaluep, YYLTYPE * const yylocationp<%= output.user_formals %>)
+{
+  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
+switch (yykind)
+    {
+<%= output.symbol_actions_for_error_token -%>
+      default:
+        break;
+    }
+  YY_IGNORE_MAYBE_UNINITIALIZED_END
+}
+
+static repair_terms *
+yy_create_repair_terms(repairs *reps)
+{
+  repairs *r = reps;
+  repair_terms *rep_terms;
+  int count = 0;
+
+  while (r->prev_repair)
+  {
+    count++;
+    r = r->prev_repair;
+  }
+
+  rep_terms = (repair_terms *) malloc (sizeof (repair_terms) + sizeof (yy_term) * count);
+  rep_terms->id = reps->id;
+  rep_terms->length = count;
+
+  r = reps;
+  while (r->prev_repair)
+  {
+    rep_terms->terms[count-1].kind = r->repair.term;
+    count--;
+    r = r->prev_repair;
+  }
+
+  return rep_terms;
+}
+
+static void
+yy_print_repairs(repairs *reps)
+{
+  repairs *r = reps;
+
+  fprintf (stderr,
+        "id: %d, repair_length: %d, repair_state: %d, prev_repair_id: %d\n",
+        reps->id, reps->repair_length, *reps->state, reps->prev_repair->id);
+
+  while (r->prev_repair)
+  {
+    fprintf (stderr, "%s ", yysymbol_name (r->repair.term));
+    r = r->prev_repair;
+  }
+
+  fprintf (stderr, "\n");
+}
+
+static void
+yy_print_repair_terms(repair_terms *rep_terms)
+{
+  for (int i = 0; i < rep_terms->length; i++)
+    fprintf (stderr, "%s ", yysymbol_name (rep_terms->terms[i].kind));
+
+  fprintf (stderr, "\n");
+}
+
+static void
+yy_free_repairs(repairs *reps)
+{
+  while (reps)
+    {
+      repairs *r = reps;
+      reps = reps->next;
+      free (r->states);
+      free (r);
+    }
+}
+
+static int
+yy_process_repairs(repairs *reps, yysymbol_kind_t token)
+{
+  int yyn;
+  int yystate = *reps->state;
+  int yylen = 0;
+  yysymbol_kind_t yytoken = token;
+
+  goto yyrecover_backup;
+
+yyrecover_newstate:
+  // TODO: check reps->stack_length
+  reps->state += 1;
+  *reps->state = (yy_state_t) yystate;
+
+
+yyrecover_backup:
+  yyn = yypact[yystate];
+  if (yypact_value_is_default (yyn))
+    goto yyrecover_default;
+
+  /* "Reading a token" */
+  if (yytoken == YYSYMBOL_YYEMPTY)
+    return 1;
+
+  yyn += yytoken;
+  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
+    goto yyrecover_default;
+  yyn = yytable[yyn];
+  if (yyn <= 0)
+    {
+      if (yytable_value_is_error (yyn))
+        goto yyrecover_errlab;
+      yyn = -yyn;
+      goto yyrecover_reduce;
+    }
+
+  /* shift */
+  yystate = yyn;
+  yytoken = YYSYMBOL_YYEMPTY;
+  goto yyrecover_newstate;
+
+
+yyrecover_default:
+  yyn = yydefact[yystate];
+  if (yyn == 0)
+    goto yyrecover_errlab;
+  goto yyrecover_reduce;
+
+
+yyrecover_reduce:
+  yylen = yyr2[yyn];
+  /* YYPOPSTACK */
+  reps->state -= yylen;
+  yylen = 0;
+
+  {
+    const int yylhs = yyr1[yyn] - YYNTOKENS;
+    const int yyi = yypgoto[yylhs] + *reps->state;
+    yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *reps->state
+               ? yytable[yyi]
+               : yydefgoto[yylhs]);
+  }
+
+  goto yyrecover_newstate;
+
+yyrecover_errlab:
+  return 0;
+}
+
+static repair_terms *
+yyrecover(yy_state_t *yyss, yy_state_t *yyssp, int yychar)
+{
+  yysymbol_kind_t yytoken = YYTRANSLATE (yychar);
+  repair_terms *rep_terms = YY_NULLPTR;
+  int count = 0;
+
+  repairs *head = (repairs *) malloc (sizeof (repairs));
+  repairs *current = head;
+  repairs *tail = head;
+  YYPTRDIFF_T stack_length = yyssp - yyss + 1;
+
+  head->id = count;
+  head->next = 0;
+  head->stack_length = stack_length;
+  head->states = (yy_state_t *) malloc (sizeof (yy_state_t) * (stack_length));
+  head->state = head->states + (yyssp - yyss);
+  YYCOPY (head->states, yyss, stack_length);
+  head->repair_length = 0;
+  head->prev_repair = 0;
+
+  stack_length = (stack_length * 2 > 100) ? (stack_length * 2) : 100;
+  count++;
+
+  while (current)
+    {
+      int yystate = *current->state;
+      int yyn = yypact[yystate];
+      /* See also: yypcontext_expected_tokens */
+      if (!yypact_value_is_default (yyn))
+        {
+          int yyxbegin = yyn < 0 ? -yyn : 0;
+          int yychecklim = YYLAST - yyn + 1;
+          int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
+          int yyx;
+          for (yyx = yyxbegin; yyx < yyxend; ++yyx)
+            {
+              if (yyx != YYSYMBOL_YYerror)
+                {
+                  if (current->repair_length + 1 > YYMAXREPAIR)
+                    continue;
+
+                  repairs *new = (repairs *) malloc (sizeof (repairs));
+                  new->id = count;
+                  new->next = 0;
+                  new->stack_length = stack_length;
+                  new->states = (yy_state_t *) malloc (sizeof (yy_state_t) * (stack_length));
+                  new->state = new->states + (current->state - current->states);
+                  YYCOPY (new->states, current->states, current->state - current->states + 1);
+                  new->repair_length = current->repair_length + 1;
+                  new->prev_repair = current;
+                  new->repair.type = insert;
+                  new->repair.term = (yysymbol_kind_t) yyx;
+
+                  /* Process PDA assuming next token is yyx */
+                  if (! yy_process_repairs (new, yyx))
+                    {
+                      free (new);
+                      continue;
+                    }
+
+                  tail->next = new;
+                  tail = new;
+                  count++;
+
+                  if (yyx == yytoken)
+                    {
+                      rep_terms = yy_create_repair_terms (current);
+                      fprintf (stderr, "repair_terms found. id: %d, length: %d\n", rep_terms->id, rep_terms->length);
+                      yy_print_repairs (current);
+                      yy_print_repair_terms (rep_terms);
+
+                      goto done;
+                    }
+
+                  fprintf (stderr,
+                        "New repairs is enqueued. count: %d, yystate: %d, yyx: %d\n",
+                        count, yystate, yyx);
+                  yy_print_repairs (new);
+                }
+            }
+        }
+
+      current = current->next;
+    }
+
+done:
+
+  yy_free_repairs(head);
+
+  if (!rep_terms)
+    {
+      fprintf (stderr, "repair_terms not found\n");
+    }
+
+  return rep_terms;
+}
+<%- end -%>
 
 
 
@@ -1227,11 +1533,11 @@ int yychar;
 /* The semantic value of the lookahead symbol.  */
 /* Default value used for initialization, for pacifying older GCCs
    or non-GCC compilers.  */
-YY_INITIAL_VALUE (static YYSTYPE yyval_default;)
+YY_INITIAL_VALUE (static const YYSTYPE yyval_default;)
 YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
 
 /* Location data for the lookahead symbol.  */
-static YYLTYPE yyloc_default
+static const YYLTYPE yyloc_default
 # if defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL
   = { 1, 1, 1, 1 }
 # endif
@@ -1279,6 +1585,12 @@ YYLTYPE yylloc = yyloc_default;
 
   /* The locations where the error started and ended.  */
   YYLTYPE yyerror_range[3];
+<%- if output.error_recovery -%>
+  repair_terms *rep_terms = 0;
+  yy_term term_backup;
+  int rep_terms_index;
+  int yychar_backup;
+<%- end -%>
 
   /* Buffer for error messages, and its allocated size.  */
   char yymsgbuf[128];
@@ -1322,7 +1634,7 @@ yysetstate:
   YY_IGNORE_USELESS_CAST_BEGIN
   *yyssp = YY_CAST (yy_state_t, yystate);
   YY_IGNORE_USELESS_CAST_END
-  YY_STACK_PRINT (yyss, yyssp);
+  YY_STACK_PRINT (yyss, yyssp<%= output.user_args %>);
 
   if (yyss + yystacksize - 1 <= yyssp)
 #if !defined yyoverflow && !defined YYSTACK_RELOCATE
@@ -1413,6 +1725,36 @@ yybackup:
 
   /* Not known => get a lookahead token if don't already have one.  */
 
+<%- if output.error_recovery -%>
+  if (yychar == YYEMPTY && rep_terms)
+    {
+
+      if (rep_terms_index < rep_terms->length)
+        {
+          YYDPRINTF ((stderr, "An error recovery token is used\n"));
+          yy_term term = rep_terms->terms[rep_terms_index];
+          yytoken = term.kind;
+          yylval = term.value;
+          yylloc = term.location;
+          yychar = yytranslate_inverted[yytoken];
+          YY_SYMBOL_PRINT ("Next error recovery token is", yytoken, &yylval, &yylloc<%= output.user_args %>);
+          rep_terms_index++;
+        }
+      else
+        {
+          YYDPRINTF ((stderr, "Error recovery is completed\n"));
+          yytoken = term_backup.kind;
+          yylval = term_backup.value;
+          yylloc = term_backup.location;
+          yychar = yychar_backup;
+          YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc<%= output.user_args %>);
+
+          free (rep_terms);
+          rep_terms = 0;
+          yychar_backup = 0;
+        }
+    }
+<%- end -%>
   /* YYCHAR is either empty, or end-of-input, or a valid lookahead.  */
   if (yychar == YYEMPTY)
     {
@@ -1440,7 +1782,7 @@ yybackup:
   else
     {
       yytoken = YYTRANSLATE (yychar);
-      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
+      YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc<%= output.user_args %>);
     }
 
   /* If the proper action on seeing token YYTOKEN is to reduce or to
@@ -1463,7 +1805,7 @@ yybackup:
     yyerrstatus--;
 
   /* Shift the lookahead token.  */
-  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
+  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc<%= output.user_args %>);
   yystate = yyn;
   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
   *++yyvsp = yylval;
@@ -1505,7 +1847,7 @@ yyreduce:
   /* Default location. */
   YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
   yyerror_range[1] = yyloc;
-  YY_REDUCE_PRINT (yyn);
+  YY_REDUCE_PRINT (yyn<%= output.user_args %>);
   switch (yyn)
     {
 <%= output.user_actions -%>
@@ -1523,7 +1865,7 @@ yyreduce:
      case of YYERROR or YYBACKUP, subsequent parser actions might lead
      to an incorrect destructor call or verbose syntax error message
      before the lookahead is translated.  */
-  YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc);
+  YY_SYMBOL_PRINT ("-> $$ =", YY_CAST (yysymbol_kind_t, yyr1[yyn]), &yyval, &yyloc<%= output.user_args %>);
 
   YYPOPSTACK (yylen);
   yylen = 0;
@@ -1561,7 +1903,7 @@ yyerrlab:
           = {yyssp, yytoken, &yylloc};
         char const *yymsgp = YY_("syntax error");
         int yysyntax_error_status;
-        yysyntax_error_status = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx);
+        yysyntax_error_status = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx<%= output.user_args %>);
         if (yysyntax_error_status == 0)
           yymsgp = yymsg;
         else if (yysyntax_error_status == -1)
@@ -1573,7 +1915,7 @@ yyerrlab:
             if (yymsg)
               {
                 yysyntax_error_status
-                  = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx);
+                  = yysyntax_error (&yymsg_alloc, &yymsg, &yyctx<%= output.user_args %>);
                 yymsgp = yymsg;
               }
             else
@@ -1628,7 +1970,7 @@ yyerrorlab:
      this YYERROR.  */
   YYPOPSTACK (yylen);
   yylen = 0;
-  YY_STACK_PRINT (yyss, yyssp);
+  YY_STACK_PRINT (yyss, yyssp<%= output.user_args %>);
   yystate = *yyssp;
   goto yyerrlab1;
 
@@ -1637,6 +1979,29 @@ yyerrorlab:
 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
 `-------------------------------------------------------------*/
 yyerrlab1:
+<%- if output.error_recovery -%>
+  {
+    rep_terms = yyrecover (yyss, yyssp, yychar);
+    if (rep_terms)
+      {
+        for (int i = 0; i < rep_terms->length; i++)
+          {
+            yy_term *term = &rep_terms->terms[i];
+            yy_error_token_initialize (term->kind, &term->value, &term->location<%= output.user_args %>);
+          }
+
+        yychar_backup = yychar;
+        /* Can be packed into (the tail of) rep_terms? */
+        term_backup.kind = yytoken;
+        term_backup.value = yylval;
+        term_backup.location = yylloc;
+        rep_terms_index = 0;
+        yychar = YYEMPTY;
+
+        goto yybackup;
+      }
+  }
+<%- end -%>
   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
 
   /* Pop stack until we find a state that shifts the error token.  */
@@ -1663,7 +2028,7 @@ yyerrlab1:
                   YY_ACCESSING_SYMBOL (yystate), yyvsp, yylsp<%= output.user_args %>);
       YYPOPSTACK (1);
       yystate = *yyssp;
-      YY_STACK_PRINT (yyss, yyssp);
+      YY_STACK_PRINT (yyss, yyssp<%= output.user_args %>);
     }
 
   YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
@@ -1675,7 +2040,7 @@ yyerrlab1:
   YYLLOC_DEFAULT (*yylsp, yyerror_range, 2);
 
   /* Shift the error token.  */
-  YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp);
+  YY_SYMBOL_PRINT ("Shifting", YY_ACCESSING_SYMBOL (yyn), yyvsp, yylsp<%= output.user_args %>);
 
   yystate = yyn;
   goto yynewstate;
@@ -1721,7 +2086,7 @@ yyreturnlab:
   /* Do not reclaim the symbols of the rule whose action triggered
      this YYABORT or YYACCEPT.  */
   YYPOPSTACK (yylen);
-  YY_STACK_PRINT (yyss, yyssp);
+  YY_STACK_PRINT (yyss, yyssp<%= output.user_args %>);
   while (yyssp != yyss)
     {
       yydestruct ("Cleanup: popping",

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lrama
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.5.3
 platform: ruby
 authors:
 - Yuichiro Kaneko
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-05-20 00:00:00.000000000 Z
+date: 2023-08-05 00:00:00.000000000 Z
 dependencies: []
 description: LALR (1) parser generator written by Ruby
 email:
@@ -36,28 +36,46 @@ files:
 - lib/lrama/context.rb
 - lib/lrama/digraph.rb
 - lib/lrama/grammar.rb
+- lib/lrama/grammar/code.rb
+- lib/lrama/grammar/error_token.rb
+- lib/lrama/grammar/precedence.rb
+- lib/lrama/grammar/printer.rb
+- lib/lrama/grammar/reference.rb
+- lib/lrama/grammar/rule.rb
+- lib/lrama/grammar/symbol.rb
+- lib/lrama/grammar/union.rb
 - lib/lrama/lexer.rb
+- lib/lrama/lexer/token.rb
 - lib/lrama/output.rb
 - lib/lrama/parser.rb
 - lib/lrama/parser/token_scanner.rb
 - lib/lrama/report.rb
+- lib/lrama/report/duration.rb
+- lib/lrama/report/profile.rb
 - lib/lrama/state.rb
 - lib/lrama/state/reduce.rb
+- lib/lrama/state/resolved_conflict.rb
 - lib/lrama/state/shift.rb
 - lib/lrama/states.rb
+- lib/lrama/states/item.rb
 - lib/lrama/states_reporter.rb
 - lib/lrama/version.rb
 - lib/lrama/warning.rb
 - lrama.gemspec
+- rbs_collection.lock.yaml
+- rbs_collection.yaml
 - sample/calc.output
 - sample/calc.y
 - sample/parse.y
 - sig/lrama/bitmap.rbs
+- sig/lrama/report/duration.rbs
+- sig/lrama/report/profile.rbs
+- sig/lrama/warning.rbs
 - template/bison/yacc.c
 - template/bison/yacc.h
-homepage: https://github.com/yui-knk/lrama
+homepage: https://github.com/ruby/lrama
 licenses:
-- GNU GPLv3
+- GPL-3.0-or-later
 metadata: {}
 post_install_message:
 rdoc_options: []
@@ -74,7 +92,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.0.dev
+rubygems_version: 3.4.1
 signing_key:
 specification_version: 4
 summary: LALR (1) parser generator written by Ruby