lrama 0.6.9 → 0.6.10

data/sig/lrama/grammar/parameterizing_rule/resolver.rbs

@@ -2,12 +2,13 @@ module Lrama
   class Grammar
     class ParameterizingRule
       class Resolver
+        attr_accessor rules: Array[Grammar::ParameterizingRule::Rule]
         attr_accessor created_lhs_list: Array[Lexer::Token]
 
         @rules: Array[Grammar::ParameterizingRule::Rule]
 
         def initialize: () -> void
-        def add_parameterizing_rule: (Grammar::ParameterizingRule::Rule rule) -> void
+        def add_parameterizing_rule: (Grammar::ParameterizingRule::Rule rule) -> Array[Grammar::ParameterizingRule::Rule]
         def find_rule: (Lexer::Token::InstantiateRule token) -> Grammar::ParameterizingRule::Rule?
         def find_inline: (Lexer::Token token) -> Grammar::ParameterizingRule::Rule?
         def created_lhs: (String lhs_s_value) -> Lexer::Token?

data/sig/lrama/grammar/parameterizing_rule/rhs.rbs

@@ -4,7 +4,7 @@ module Lrama
       class Rhs
         attr_reader symbols: Array[untyped]
         attr_reader user_code: Lexer::Token::UserCode?
-        attr_reader precedence_sym: Lexer::Token?
+        attr_reader precedence_sym: Grammar::Symbol?
 
         def initialize: () -> void
         def resolve_user_code: (Grammar::Binding bindings) -> Lexer::Token::UserCode?

data/sig/lrama/grammar/precedence.rbs

@@ -2,9 +2,11 @@ module Lrama
   class Grammar
     class Precedence
       include Comparable
-      attr_accessor type: Symbol
+      attr_accessor type: ::Symbol
       attr_accessor precedence: Integer
 
+      def initialize: (?type: ::Symbol, ?precedence: Integer) -> void
+
       def <=>: (Precedence other) -> Integer
     end
   end

data/sig/lrama/grammar/printer.rbs

@@ -5,7 +5,9 @@ module Lrama
       attr_accessor token_code: Grammar::Code
       attr_accessor lineno: Integer
 
-      def translated_code: (Lexer::Token member) -> String
+      def initialize: (?ident_or_tags: Array[Lexer::Token::Ident|Lexer::Token::Tag], ?token_code: Grammar::Code, ?lineno: Integer) -> void
+
+      def translated_code: (Lexer::Token::Tag tag) -> String
     end
   end
 end

data/sig/lrama/grammar/rule.rbs

@@ -1,13 +1,45 @@
 module Lrama
   class Grammar
     class Rule
+      attr_accessor id: Integer
+      attr_accessor _lhs: Lexer::Token
+      attr_accessor lhs: Grammar::Symbol
+      attr_accessor lhs_tag: Lexer::Token::Tag?
+      attr_accessor _rhs: Array[Lexer::Token]
+      attr_accessor rhs: Array[Grammar::Symbol]
+      attr_accessor token_code: Grammar::Code?
+      attr_accessor position_in_original_rule_rhs: Integer
+      attr_accessor nullable: bool
+      attr_accessor precedence_sym: Grammar::Symbol?
+      attr_accessor lineno: Integer?
       attr_accessor original_rule: Rule
 
       def initialize: (
-        ?id: untyped, ?_lhs: untyped, ?lhs: untyped, ?lhs_tag: untyped, ?_rhs: untyped, ?rhs: untyped,
-        ?token_code: untyped, ?position_in_original_rule_rhs: untyped, ?nullable: untyped,
-        ?precedence_sym: untyped, ?lineno: untyped
+        ?id: Integer, ?_lhs: Lexer::Token, ?lhs: Lexer::Token, ?lhs_tag: Lexer::Token::Tag?, ?_rhs: Array[Lexer::Token], ?rhs: Array[Grammar::Symbol],
+        ?token_code: Lexer::Token::UserCode?, ?position_in_original_rule_rhs: Integer?, ?nullable: bool,
+        ?precedence_sym: Grammar::Symbol?, ?lineno: Integer?
       ) -> void
+
+      def display_name: () -> String
+
+      def as_comment: -> String
+
+      def empty_rule?: -> bool
+
+      def initial_rule?: -> bool
+
+      def precedence: -> Precedence?
+
+      def translated_code: -> String?
+
+      def with_actions: -> String
+
+      def contains_at_reference?: -> bool
+
+      interface _DelegatedMethods
+        def lhs: -> Grammar::Symbol
+        def rhs: -> Array[Grammar::Symbol]
+      end
     end
   end
 end

data/sig/lrama/grammar/rule_builder.rbs

@@ -6,28 +6,29 @@ module Lrama
       attr_reader lhs_tag: Lexer::Token::Tag?
       attr_reader rhs: Array[Lexer::Token]
       attr_reader user_code: Lexer::Token::UserCode?
-      attr_reader precedence_sym: Lexer::Token?
+      attr_reader precedence_sym: Grammar::Symbol?
 
       @rule_counter: Counter
       @midrule_action_counter: Counter
+      @parameterizing_rule_resolver: Grammar::ParameterizingRule::Resolver
       @position_in_original_rule_rhs: Integer?
       @skip_preprocess_references: bool
       @user_code: Lexer::Token::UserCode?
       @rule_builders_for_parameterizing_rules: Array[RuleBuilder]
       @rule_builders_for_derived_rules: Array[RuleBuilder]
-      @rule_builders_for_inline_rules: Array[RuleBuilder]
       @rules: Array[Rule]
       @replaced_rhs: Array[Lexer::Token]
       @parameterizing_rules: Array[Rule]
-      @inline_rules: Array[Rule]
       @midrule_action_rules: Array[Rule]
 
-      def initialize: (Counter rule_counter, Counter midrule_action_counter, ?Integer position_in_original_rule_rhs, ?lhs_tag: Lexer::Token::Tag?, ?skip_preprocess_references: bool) -> void
+      def initialize: (Counter rule_counter, Counter midrule_action_counter, Grammar::ParameterizingRule::Resolver parameterizing_rule_resolver, ?Integer position_in_original_rule_rhs, ?lhs_tag: Lexer::Token::Tag?, ?skip_preprocess_references: bool) -> void
       def add_rhs: (Lexer::Token rhs) -> void
+      def has_inline_rules?: -> bool
+      def resolve_inline_rules: -> Array[RuleBuilder]
       def user_code=: (Lexer::Token::UserCode? user_code) -> void
-      def precedence_sym=: (Lexer::Token? precedence_sym) -> void
+      def precedence_sym=: (Grammar::Symbol? precedence_sym) -> void
       def complete_input: () -> void
-      def setup_rules: (Grammar::ParameterizingRule::Resolver parameterizing_rule_resolver) -> void
+      def setup_rules: () -> void
       def rules: () -> Array[Rule]
 
       private
@@ -35,10 +36,10 @@ module Lrama
       def freeze_rhs: () -> void
       def preprocess_references: () -> void
       def build_rules: () -> void
-      def process_rhs: (Grammar::ParameterizingRule::Resolver parameterizing_rule_resolver) -> void
+      def process_rhs: () -> void
       def lhs_s_value: (Lexer::Token::InstantiateRule token, Grammar::Binding bindings) -> String
-      def resolve_inline: (Grammar::ParameterizingRule::Resolver parameterizing_rule_resolver) -> void
-      def resolve_inline_rhs: (RuleBuilder rule_builder, Grammar::ParameterizingRule::Rhs inline_rhs, Integer index) -> void
+      def resolve_inline: () -> void
+      def resolve_inline_rhs: (RuleBuilder rule_builder, Grammar::ParameterizingRule::Rhs inline_rhs, Integer index, ?Binding bindings) -> void
       def replace_inline_user_code: (Grammar::ParameterizingRule::Rhs inline_rhs, Integer index) -> Lexer::Token::UserCode?
       def numberize_references: () -> void
       def flush_user_code: () -> void

data/sig/lrama/grammar/symbol.rbs

@@ -4,7 +4,7 @@ module Lrama
       attr_accessor id: Lexer::Token
       attr_accessor alias_name: String?
       attr_accessor number: Integer
-      attr_accessor tag: Lexer::Token?
+      attr_accessor tag: Lexer::Token::Tag?
       attr_accessor term: bool
       attr_accessor token_id: Integer
       attr_accessor nullable: bool
@@ -13,12 +13,12 @@ module Lrama
       attr_accessor destructor: Destructor?
       attr_accessor error_token: ErrorToken
 
-      attr_accessor first_set: Set[Array[Symbol]]
+      attr_accessor first_set: Set[Array[Symbol]] | Set[Symbol]
       attr_accessor first_set_bitmap: Integer
-      attr_writer eof_symbol: Symbol
-      attr_writer error_symbol: Symbol
-      attr_writer undef_symbol: Symbol
-      attr_writer accept_symbol: Symbol
+      attr_writer eof_symbol: bool
+      attr_writer error_symbol: bool
+      attr_writer undef_symbol: bool
+      attr_writer accept_symbol: bool
 
       def initialize: (
           id: Lexer::Token, term: bool, ?alias_name: String?, ?number: Integer?, ?tag: Lexer::Token?,

data/sig/lrama/grammar/symbols/resolver.rbs

@@ -11,9 +11,9 @@ module Lrama
 
         def initialize: () -> void
         def symbols: () -> Array[Grammar::Symbol]
-        def sort_by_number!: () -> void
-        def add_term: (id: Lexer::Token, ?alias_name: String?, ?tag: Lexer::Token?, ?token_id: Integer?, ?replace: bool) -> Grammar::Symbol
-        def add_nterm: (id: Lexer::Token, ?alias_name: String?, ?tag: Lexer::Token?) -> Grammar::Symbol?
+        def sort_by_number!: () -> Array[Grammar::Symbol]
+        def add_term: (id: Lexer::Token, ?alias_name: String?, ?tag: Lexer::Token::Tag?, ?token_id: Integer?, ?replace: bool) -> Grammar::Symbol
+        def add_nterm: (id: Lexer::Token, ?alias_name: String?, ?tag: Lexer::Token::Tag?) -> Grammar::Symbol
         def find_symbol_by_s_value: (Grammar::Symbol s_value) -> Grammar::Symbol?
         def find_symbol_by_s_value!: (Grammar::Symbol s_value) -> Grammar::Symbol
         def find_symbol_by_id: (Lexer::Token id) -> Grammar::Symbol?
@@ -21,6 +21,7 @@ module Lrama
         def find_symbol_by_token_id: (Integer token_id) -> Grammar::Symbol?
         def find_symbol_by_number!: (Integer number) -> Grammar::Symbol
         def fill_symbol_number: () -> void
+        def fill_destructor: (Array[Destructor] destructors) -> (Array[Grammar::Symbol] | bot)
         def fill_nterm_type: (Array[Grammar::Type] types) -> void
         def fill_printer: (Array[Grammar::Printer] printers) -> void
         def fill_error_token: (Array[Grammar::ErrorToken] error_tokens) -> void
@@ -36,6 +37,24 @@ module Lrama
         def validate_number_uniqueness!: () -> void
         def validate_alias_name_uniqueness!: () -> void
       end
+
+      interface _DelegatedMethods
+        def symbols: () -> Array[Grammar::Symbol]
+        def nterms: () -> Array[Grammar::Symbol]
+        def terms: () -> Array[Grammar::Symbol]
+        def add_nterm: (id: Lexer::Token, ?alias_name: String?, ?tag: Lexer::Token::Tag?) -> Grammar::Symbol
+        def add_term: (id: Lexer::Token, ?alias_name: String?, ?tag: Lexer::Token::Tag?, ?token_id: Integer?, ?replace: bool) -> Grammar::Symbol
+        def find_symbol_by_number!: (Integer number) -> Grammar::Symbol
+        def find_symbol_by_id!: (Lexer::Token id) -> Grammar::Symbol
+        def token_to_symbol: (Lexer::Token token) -> Grammar::Symbol
+        def find_symbol_by_s_value!: (Grammar::Symbol s_value) -> Grammar::Symbol
+        def fill_nterm_type: (Array[Grammar::Type] types) -> void
+        def fill_symbol_number: () -> void
+        def fill_printer: (Array[Grammar::Printer] printers) -> void
+        def fill_destructor: (Array[Destructor] destructors) -> (Destructor | bot)
+        def fill_error_token: (Array[Grammar::ErrorToken] error_tokens) -> void
+        def sort_by_number!: () -> Array[Grammar::Symbol]
+      end
     end
   end
 end

data/sig/lrama/grammar/type.rbs

@@ -2,9 +2,9 @@ module Lrama
   class Grammar
     class Type
       attr_reader id: Lexer::Token
-      attr_reader tag: Lexer::Token
+      attr_reader tag: Lexer::Token::Tag
 
-      def initialize: (id: Lexer::Token, tag: Lexer::Token) -> void
+      def initialize: (id: Lexer::Token, tag: Lexer::Token::Tag) -> void
       def ==: (Grammar::Type other) -> bool
     end
   end

data/sig/lrama/grammar/union.rbs

@@ -0,0 +1,12 @@
+module Lrama
+  class Grammar
+    class Union
+      attr_accessor code: Grammar::Code::NoReferenceCode
+      attr_accessor lineno: Integer
+
+      def initialize: (code: Grammar::Code::NoReferenceCode, lineno: Integer) -> void
+
+      def braces_less_code: () -> String
+    end
+  end
+end

data/sig/lrama/grammar.rbs

@@ -1,5 +1,95 @@
 module Lrama
   class Grammar
-    def numberize_references: (Lexer::Token lhs, Array[Lexer::Token] rhs, Array[Reference]) -> void
+    include Symbols::_DelegatedMethods
+
+    @rule_counter: Counter
+    @percent_codes: Array[PercentCode]
+    @printers: Array[Printer]
+    @destructors: Array[Destructor]
+    @error_tokens: Array[ErrorToken]
+    @symbols_resolver: Symbols::Resolver
+    @types: Array[Type]
+    @rule_builders: Array[RuleBuilder]
+    @rules: Array[Rule]
+    @sym_to_rules: Hash[Integer, Array[Rule]]
+    @parameterizing_rule_resolver: ParameterizingRule::Resolver
+    @empty_symbol: Grammar::Symbol
+    @eof_symbol: Grammar::Symbol
+    @error_symbol: Grammar::Symbol
+    @undef_symbol: Grammar::Symbol
+    @accept_symbol: Grammar::Symbol
+    @aux: Auxiliary
+    @no_stdlib: bool
+    @locations: bool
+    @union: Union
+
+    extend Forwardable
+
+    attr_reader percent_codes: Array[PercentCode]
+    attr_reader eof_symbol: Grammar::Symbol
+    attr_reader error_symbol: Grammar::Symbol
+    attr_reader undef_symbol: Grammar::Symbol
+    attr_reader accept_symbol: Grammar::Symbol
+    attr_reader aux: Auxiliary
+    attr_accessor union: Union
+    attr_accessor expect: Integer
+    attr_accessor printers: Array[Printer]
+    attr_accessor error_tokens: Array[ErrorToken]
+    attr_accessor lex_param: String
+    attr_accessor parse_param: String
+    attr_accessor initial_action: Grammar::Code::InitialActionCode
+    attr_accessor after_shift: Lexer::Token
+    attr_accessor before_reduce: Lexer::Token
+    attr_accessor after_reduce: Lexer::Token
+    attr_accessor after_shift_error_token: Lexer::Token
+    attr_accessor after_pop_stack: Lexer::Token
+    attr_accessor symbols_resolver: Symbols::Resolver
+    attr_accessor types: Array[Type]
+    attr_accessor rules: Array[Rule]
+    attr_accessor rule_builders: Array[RuleBuilder]
+    attr_accessor sym_to_rules: Hash[Integer, Array[Rule]]
+    attr_accessor no_stdlib: bool
+
+    def initialize: (Counter rule_counter) -> void
+    def create_rule_builder: (Counter rule_counter, Counter midrule_action_counter) -> RuleBuilder
+    def add_percent_code: (id: Lexer::Token, code: Lexer::Token::UserCode) -> Array[PercentCode]
+    def add_destructor: (ident_or_tags: Array[Lexer::Token::Ident|Lexer::Token::Tag], token_code: Code, lineno: Integer) -> Array[Destructor]
+    def add_printer: (ident_or_tags: Array[Lexer::Token::Ident|Lexer::Token::Tag], token_code: Code, lineno: Integer) -> Array[Printer]
+    def add_error_token: (ident_or_tags: Array[Lexer::Token::Ident|Lexer::Token::Tag], token_code: Code, lineno: Integer) -> Array[ErrorToken]
+    def add_type: (id: Lexer::Token, tag: Lexer::Token::Tag) -> Array[Type]
+    def add_nonassoc: (Grammar::Symbol sym, Integer precedence) -> Precedence
+    def add_left: (Grammar::Symbol sym, Integer precedence) -> Precedence
+    def add_right: (Grammar::Symbol sym, Integer precedence) -> Precedence
+    def add_precedence: (Grammar::Symbol sym, Integer precedence) -> Precedence
+    def set_precedence: (Grammar::Symbol sym, Precedence precedence) -> (Precedence | bot)
+    def set_union: (Grammar::Code::NoReferenceCode code, Integer lineno) -> Union
+    def add_rule_builder: (RuleBuilder builder) -> Array[RuleBuilder]
+    def add_parameterizing_rule: (ParameterizingRule::Rule rule) -> Array[ParameterizingRule::Rule]
+    def parameterizing_rules: () -> Array[ParameterizingRule::Rule]
+    def insert_before_parameterizing_rules: (Array[ParameterizingRule::Rule] rules) -> Array[ParameterizingRule::Rule]
+    def prologue_first_lineno=: (Integer prologue_first_lineno) -> Integer
+    def prologue=: (String prologue) -> String
+    def epilogue_first_lineno=: (Integer epilogue_first_lineno) -> Integer
+    def epilogue=: (String epilogue) -> String
+    def prepare: () -> void
+    def validate!: () -> void
+    def find_rules_by_symbol!: (Grammar::Symbol sym) -> Array[Rule]
+    def find_rules_by_symbol: (Grammar::Symbol sym) -> Array[Rule]?
+
+    private
+
+    def compute_nullable: () -> Array[Grammar::Symbol]
+    def compute_first_set: () -> Array[Grammar::Symbol]
+    def resolve_inline_rules: () -> void
+    def setup_rules: () -> Array[RuleBuilder]
+    def append_special_symbols: () -> Grammar::Symbol
+    def normalize_rules: () -> Array[Rule]
+    def collect_symbols: () -> Array[Lexer::Token]
+    def set_lhs_and_rhs: () -> void
+    def fill_default_precedence: () -> void
+    def fill_symbols: () -> Array[Grammar::Symbol]
+    def fill_sym_to_rules: () -> Array[Rule]
+    def validate_rule_lhs_is_nterm!: () -> void
+    def set_locations: () -> void
   end
 end

data/sig/lrama/options.rbs

@@ -1,5 +1,5 @@
 module Lrama
- class Options
+  class Options
     attr_accessor skeleton: String
     attr_accessor header: bool
     attr_accessor header_file: String?
@@ -9,9 +9,10 @@ module Lrama
     attr_accessor grammar_file: String?
     attr_accessor trace_opts: Hash[Symbol, bool]?
     attr_accessor report_opts: Hash[Symbol, bool]?
+    attr_accessor diagnostic: bool
     attr_accessor y: IO
     attr_accessor debug: bool
 
     def initialize: () -> void
- end
+  end
 end

data/sig/lrama/state/reduce.rbs

@@ -0,0 +1,20 @@
+module Lrama
+  class State
+    class Reduce
+      @item: States::Item
+      @look_ahead: Array[Grammar::Symbol]?
+      @not_selected_symbols: Array[Grammar::Symbol]
+
+      attr_reader item: States::Item
+      attr_reader look_ahead: Array[Grammar::Symbol]?
+      attr_reader not_selected_symbols: Array[Grammar::Symbol]
+      attr_accessor default_reduction: bool
+
+      def initialize: (States::Item item) -> void
+      def rule: -> Grammar::Rule
+      def look_ahead=: (Array[Grammar::Symbol] look_ahead) -> Array[Grammar::Symbol]
+      def add_not_selected_symbol: (Grammar::Symbol sym) -> Array[Grammar::Symbol]
+      def selected_look_ahead: () -> (::Array[Grammar::Symbol?])
+    end
+  end
+end

data/sig/lrama/state/reduce_reduce_conflict.rbs

@@ -0,0 +1,13 @@
+module Lrama
+  class State
+    class ReduceReduceConflict
+      attr_accessor symbols: Array[Grammar::Symbol?]
+      attr_accessor reduce1: State::Reduce
+      attr_accessor reduce2: State::Reduce
+
+      def initialize: (?symbols: Array[Grammar::Symbol?], ?reduce1: State::Reduce, ?reduce2: State::Reduce) -> void
+
+      def type: () -> :reduce_reduce
+    end
+  end
+end

data/sig/lrama/state/resolved_conflict.rbs

@@ -0,0 +1,14 @@
+module Lrama
+  class State
+    class ResolvedConflict
+      attr_accessor symbol: Grammar::Symbol
+      attr_accessor reduce: State::Reduce
+      attr_accessor which: (:reduce | :shift)
+      attr_accessor same_prec: bool
+
+      def initialize: (?symbol: Grammar::Symbol, ?reduce: State::Reduce, ?which: (:reduce | :shift), ?same_prec: bool) -> void
+
+      def report_message: () -> (::String | bot)
+    end
+  end
+end

data/sig/lrama/state/shift.rbs

@@ -0,0 +1,14 @@
+module Lrama
+  class State
+    class Shift
+      @next_sym: Grammar::Symbol
+      @next_items: Array[States::Item]
+
+      attr_reader next_sym: Grammar::Symbol
+      attr_reader next_items: Array[States::Item]
+      attr_accessor not_selected: bool
+
+      def initialize: (Grammar::Symbol next_sym, Array[States::Item] next_items) -> void
+    end
+  end
+end

data/sig/lrama/state/shift_reduce_conflict.rbs

@@ -0,0 +1,13 @@
+module Lrama
+  class State
+    class ShiftReduceConflict
+      attr_accessor symbols: Array[Grammar::Symbol]
+      attr_accessor shift: State::Shift
+      attr_accessor reduce: State::Reduce
+
+      def initialize: (?symbols: Array[Grammar::Symbol], ?shift: State::Shift, ?reduce: State::Reduce) -> void
+
+      def type: () -> :shift_reduce
+    end
+  end
+end

data/sig/lrama/states/item.rbs

@@ -0,0 +1,30 @@
+module Lrama
+  class States
+    class Item
+      extend Forwardable
+      include Grammar::Rule::_DelegatedMethods
+
+      attr_accessor rule: Grammar::Rule
+      attr_accessor position: Integer
+
+      def initialize: (?rule: Grammar::Rule, ?position: Integer) -> void
+
+      def hash: () -> Integer
+      def rule_id: () -> Integer
+      def empty_rule?: () -> bool
+      def number_of_rest_symbols: () -> Integer
+      def next_sym: () -> Grammar::Symbol
+      def next_next_sym: () -> Grammar::Symbol
+      def previous_sym: () -> Grammar::Symbol
+      def end_of_rule?: () -> bool
+      def beginning_of_rule?: () -> bool
+      def start_item?: () -> bool
+      def new_by_next_position: () -> States::Item
+      def symbols_before_dot: () -> Array[Grammar::Symbol]
+      def symbols_after_dot: () -> Array[Grammar::Symbol]
+      def to_s: () -> ::String
+      def display_name: () -> ::String
+      def display_rest: () -> ::String
+    end
+  end
+end

data/template/bison/yacc.c

@@ -1166,9 +1166,9 @@ yydestruct (const char *yymsg,
 #endif
 
 enum yy_repair_type {
-  insert,
-  delete,
-  shift,
+  inserting,
+  deleting,
+  shifting,
 };
 
 struct yy_repair {
@@ -1401,27 +1401,27 @@ yyrecover(yy_state_t *yyss, yy_state_t *yyssp, int yychar<%= output.user_formals
                   if (current->repair_length + 1 > YYMAXREPAIR(<%= output.parse_param_name %>))
                     continue;
 
-                  yy_repairs *new = (yy_repairs *) YYMALLOC (sizeof (yy_repairs));
-                  new->id = count;
-                  new->next = 0;
-                  new->stack_length = stack_length;
-                  new->states = (yy_state_t *) YYMALLOC (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;
+                  yy_repairs *reps = (yy_repairs *) YYMALLOC (sizeof (yy_repairs));
+                  reps->id = count;
+                  reps->next = 0;
+                  reps->stack_length = stack_length;
+                  reps->states = (yy_state_t *) YYMALLOC (sizeof (yy_state_t) * (stack_length));
+                  reps->state = reps->states + (current->state - current->states);
+                  YYCOPY (reps->states, current->states, current->state - current->states + 1);
+                  reps->repair_length = current->repair_length + 1;
+                  reps->prev_repair = current;
+                  reps->repair.type = inserting;
+                  reps->repair.term = (yysymbol_kind_t) yyx;
 
                   /* Process PDA assuming next token is yyx */
-                  if (! yy_process_repairs (new, yyx))
+                  if (! yy_process_repairs (reps, (yysymbol_kind_t)yyx))
                     {
-                      YYFREE (new);
+                      YYFREE (reps);
                       continue;
                     }
 
-                  tail->next = new;
-                  tail = new;
+                  tail->next = reps;
+                  tail = reps;
                   count++;
 
                   if (yyx == yytoken)
@@ -1437,7 +1437,7 @@ yyrecover(yy_state_t *yyss, yy_state_t *yyssp, int yychar<%= output.user_formals
                   YYDPRINTF ((stderr,
                         "New repairs is enqueued. count: %d, yystate: %d, yyx: %d\n",
                         count, yystate, yyx));
-                  yy_print_repairs (new<%= output.user_args %>);
+                  yy_print_repairs (reps<%= output.user_args %>);
                 }
             }
         }
@@ -1475,7 +1475,12 @@ int yychar;
 /* The semantic value of the lookahead symbol.  */
 /* Default value used for initialization, for pacifying older GCCs
    or non-GCC compilers.  */
+#ifdef __cplusplus
+static const YYSTYPE yyval_default = {};
+(void) yyval_default;
+#else
 YY_INITIAL_VALUE (static const YYSTYPE yyval_default;)
+#endif
 YYSTYPE yylval YY_INITIAL_VALUE (= yyval_default);
 
 /* Location data for the lookahead symbol.  */

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lrama
 version: !ruby/object:Gem::Version
-  version: 0.6.9
+  version: 0.6.10
 platform: ruby
 authors:
 - Yuichiro Kaneko
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-05-02 00:00:00.000000000 Z
+date: 2024-09-12 00:00:00.000000000 Z
 dependencies: []
 description: LALR (1) parser generator written by Ruby
 email:
@@ -45,6 +45,7 @@ files:
 - lib/lrama/counterexamples/state_item.rb
 - lib/lrama/counterexamples/transition_path.rb
 - lib/lrama/counterexamples/triple.rb
+- lib/lrama/diagnostics.rb
 - lib/lrama/digraph.rb
 - lib/lrama/grammar.rb
 - lib/lrama/grammar/auxiliary.rb
@@ -74,6 +75,7 @@ files:
 - lib/lrama/grammar/symbols/resolver.rb
 - lib/lrama/grammar/type.rb
 - lib/lrama/grammar/union.rb
+- lib/lrama/grammar_validator.rb
 - lib/lrama/lexer.rb
 - lib/lrama/lexer/grammar_file.rb
 - lib/lrama/lexer/location.rb
@@ -83,6 +85,7 @@ files:
 - lib/lrama/lexer/token/instantiate_rule.rb
 - lib/lrama/lexer/token/tag.rb
 - lib/lrama/lexer/token/user_code.rb
+- lib/lrama/logger.rb
 - lib/lrama/option_parser.rb
 - lib/lrama/options.rb
 - lib/lrama/output.rb
@@ -99,22 +102,23 @@ files:
 - lib/lrama/states.rb
 - lib/lrama/states/item.rb
 - lib/lrama/states_reporter.rb
+- lib/lrama/trace_reporter.rb
 - lib/lrama/version.rb
-- lib/lrama/warning.rb
 - lrama.gemspec
 - parser.y
 - rbs_collection.lock.yaml
 - rbs_collection.yaml
-- sample/calc.output
-- sample/calc.y
-- sample/parse.y
 - sig/lrama/bitmap.rbs
 - sig/lrama/digraph.rbs
 - sig/lrama/grammar.rbs
+- sig/lrama/grammar/auxiliary.rbs
 - sig/lrama/grammar/binding.rbs
 - sig/lrama/grammar/code.rbs
 - sig/lrama/grammar/code/destructor_code.rbs
+- sig/lrama/grammar/code/initial_action_code.rbs
+- sig/lrama/grammar/code/no_reference_code.rbs
 - sig/lrama/grammar/code/printer_code.rbs
+- sig/lrama/grammar/code/rule_action.rbs
 - sig/lrama/grammar/counter.rbs
 - sig/lrama/grammar/destructor.rbs
 - sig/lrama/grammar/error_token.rbs
@@ -131,6 +135,7 @@ files:
 - sig/lrama/grammar/symbol.rbs
 - sig/lrama/grammar/symbols/resolver.rbs
 - sig/lrama/grammar/type.rbs
+- sig/lrama/grammar/union.rbs
 - sig/lrama/lexer/grammar_file.rbs
 - sig/lrama/lexer/location.rbs
 - sig/lrama/lexer/token.rbs
@@ -142,6 +147,12 @@ files:
 - sig/lrama/options.rbs
 - sig/lrama/report/duration.rbs
 - sig/lrama/report/profile.rbs
+- sig/lrama/state/reduce.rbs
+- sig/lrama/state/reduce_reduce_conflict.rbs
+- sig/lrama/state/resolved_conflict.rbs
+- sig/lrama/state/shift.rbs
+- sig/lrama/state/shift_reduce_conflict.rbs
+- sig/lrama/states/item.rbs
 - sig/lrama/warning.rbs
 - sig/stdlib/strscan/string_scanner.rbs
 - template/bison/_yacc.h