lrama 0.5.2 → 0.5.3

data/lib/lrama/report.rb

@@ -1,47 +1,2 @@
-module Lrama
-  class Report
-    module Profile
-      # 1. Wrap target method with Profile.report_profile like below:
-      #
-      #   Lrama::Report::Profile.report_profile { method }
-      #
-      # 2. Run lrama command, for example
-      #
-      #   $ ./exe/lrama --trace=time spec/fixtures/integration/ruby_3_2_0/parse.tmp.y
-      #
-      # 3. Generate html file
-      #
-      #   $ stackprof --d3-flamegraph tmp/stackprof-cpu-myapp.dump > tmp/flamegraph.html
-      #
-      def self.report_profile
-        require "stackprof"
-
-        StackProf.run(mode: :cpu, raw: true, out: 'tmp/stackprof-cpu-myapp.dump') do
-          yield
-        end
-      end
-    end
-
-    module Duration
-      def self.enable
-        @_report_duration_enabled = true
-      end
-
-      def self.enabled?
-        !!@_report_duration_enabled
-      end
-
-      def report_duration(method_name)
-        time1 = Time.now.to_f
-        result = yield
-        time2 = Time.now.to_f
-
-        if Duration.enabled?
-          puts sprintf("%s %10.5f s", method_name, time2 - time1)
-        end
-
-        return result
-      end
-    end
-  end
-end
+require 'lrama/report/duration'
+require 'lrama/report/profile'

data/lib/lrama/state/resolved_conflict.rb

@@ -0,0 +1,29 @@
+module Lrama
+  class State
+    # * symbol: A symbol under discussion
+    # * reduce: A reduce under discussion
+    # * which: For which a conflict is resolved. :shift, :reduce or :error (for nonassociative)
+    class ResolvedConflict < Struct.new(:symbol, :reduce, :which, :same_prec, keyword_init: true)
+      def report_message
+        s = symbol.display_name
+        r = reduce.rule.precedence_sym.display_name
+        case
+        when which == :shift && same_prec
+          msg = "resolved as #{which} (%right #{s})"
+        when which == :shift
+          msg = "resolved as #{which} (#{r} < #{s})"
+        when which == :reduce && same_prec
+          msg = "resolved as #{which} (%left #{s})"
+        when which == :reduce
+          msg = "resolved as #{which} (#{s} < #{r})"
+        when which == :error
+          msg = "resolved as an #{which} (%nonassoc #{s})"
+        else
+          raise "Unknown direction. #{self}"
+        end
+
+        "Conflict between rule #{reduce.rule.id} and token #{s} #{msg}."
+      end
+    end
+  end
+end

data/lib/lrama/state.rb

@@ -1,34 +1,9 @@
 require "lrama/state/reduce"
 require "lrama/state/shift"
+require "lrama/state/resolved_conflict"
 
 module Lrama
   class State
-    # * symbol: A symbol under discussion
-    # * reduce: A reduce under discussion
-    # * which: For which a conflict is resolved. :shift, :reduce or :error (for nonassociative)
-    ResolvedConflict = Struct.new(:symbol, :reduce, :which, :same_prec, keyword_init: true) do
-      def report_message
-        s = symbol.display_name
-        r = reduce.rule.precedence_sym.display_name
-        case
-        when which == :shift && same_prec
-          msg = "resolved as #{which} (%right #{s})"
-        when which == :shift
-          msg = "resolved as #{which} (#{r} < #{s})"
-        when which == :reduce && same_prec
-          msg = "resolved as #{which} (%left #{s})"
-        when which == :reduce
-          msg = "resolved as #{which} (#{s} < #{r})"
-        when which == :error
-          msg = "resolved as an #{which} (%nonassoc #{s})"
-        else
-          raise "Unknown direction. #{self}"
-        end
-
-        "Conflict between rule #{reduce.rule.id} and token #{s} #{msg}."
-      end
-    end
-
     Conflict = Struct.new(:symbols, :reduce, :type, keyword_init: true)
 
     attr_reader :id, :accessing_symbol, :kernels, :conflicts, :resolved_conflicts,
@@ -96,7 +71,7 @@ module Lrama
       reduce.look_ahead = look_ahead
     end
 
-    # Returns array of [nterm, next_state]
+    # Returns array of [Shift, next_state]
     def nterm_transitions
       return @nterm_transitions if @nterm_transitions
 
@@ -111,7 +86,7 @@ module Lrama
       @nterm_transitions
     end
 
-    # Returns array of [term, next_state]
+    # Returns array of [Shift, next_state]
     def term_transitions
       return @term_transitions if @term_transitions
 

data/lib/lrama/states/item.rb

@@ -0,0 +1,43 @@
+# TODO: Validate position is not over rule rhs
+
+module Lrama
+  class States
+    class Item < Struct.new(:rule, :position, keyword_init: true)
+      # Optimization for States#setup_state
+      def hash
+        [rule.id, position].hash
+      end
+
+      def rule_id
+        rule.id
+      end
+
+      def next_sym
+        rule.rhs[position]
+      end
+
+      def end_of_rule?
+        rule.rhs.count == position
+      end
+
+      def new_by_next_position
+        Item.new(rule: rule, position: position + 1)
+      end
+
+      def previous_sym
+        rule.rhs[position - 1]
+      end
+
+      def display_name
+        r = rule.rhs.map(&:display_name).insert(position, "•").join(" ")
+        "#{r}  (rule #{rule.id})"
+      end
+
+      # Right after position
+      def display_rest
+        r = rule.rhs[position..-1].map(&:display_name).join(" ")
+        ". #{r}  (rule #{rule.id})"
+      end
+    end
+  end
+end

data/lib/lrama/states.rb

@@ -1,5 +1,6 @@
 require "forwardable"
-require "lrama/report"
+require "lrama/report/duration"
+require "lrama/states/item"
 
 module Lrama
   # States is passed to a template file
@@ -11,46 +12,7 @@ module Lrama
     include Lrama::Report::Duration
 
     def_delegators "@grammar", :symbols, :terms, :nterms, :rules,
-      :accept_symbol, :eof_symbol, :find_symbol_by_s_value!
-
-    # TODO: Validate position is not over rule rhs
-    Item = Struct.new(:rule, :position, keyword_init: true) do
-      # Optimization for States#setup_state
-      def hash
-        [rule.id, position].hash
-      end
-
-      def rule_id
-        rule.id
-      end
-
-      def next_sym
-        rule.rhs[position]
-      end
-
-      def end_of_rule?
-        rule.rhs.count == position
-      end
-
-      def new_by_next_position
-        Item.new(rule: rule, position: position + 1)
-      end
-
-      def previous_sym
-        rule.rhs[position - 1]
-      end
-
-      def display_name
-        r = rule.rhs.map(&:display_name).insert(position, "•").join(" ")
-        "#{r}  (rule #{rule.id})"
-      end
-
-      # Right after position
-      def display_rest
-        r = rule.rhs[position..-1].map(&:display_name).join(" ")
-        ". #{r}  (rule #{rule.id})"
-      end
-    end
+      :accept_symbol, :eof_symbol, :undef_symbol, :find_symbol_by_s_value!
 
     attr_reader :states, :reads_relation, :includes_relation, :lookback_relation
 

data/lib/lrama/version.rb

@@ -1,3 +1,3 @@
 module Lrama
-  VERSION = "0.5.2".freeze
+  VERSION = "0.5.3".freeze
 end

data/lrama.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   spec.description   = "LALR (1) parser generator written by Ruby"
   spec.homepage      = "https://github.com/ruby/lrama"
   # See LEGAL.md file for detail
-  spec.license       = "GNU GPLv3"
+  spec.license       = "GPL-3.0-or-later"
   spec.required_ruby_version = Gem::Requirement.new(">= 2.5.0")
 
   spec.files = Dir.chdir(File.expand_path(__dir__)) do

data/sig/lrama/{report.rbs → report/duration.rbs}

@@ -1,9 +1,5 @@
 module Lrama
   class Report
-    module Profile
-      def self.report_profile: { -> void } -> StackProf::result
-    end
-
     module Duration
       self.@_report_duration_enabled: bool | nil
 

data/sig/lrama/report/profile.rbs

@@ -0,0 +1,7 @@
+module Lrama
+  class Report
+    module Profile
+      def self.report_profile: { -> void } -> StackProf::result
+    end
+  end
+end

data/template/bison/yacc.c

@@ -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[] =
@@ -1211,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 -%>
 
 
 
@@ -1281,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];
@@ -1415,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)
     {
@@ -1639,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.  */