lrama 0.6.4 → 0.6.6

data/lib/lrama/state.rb

@@ -70,38 +70,16 @@ module Lrama
       reduce.look_ahead = look_ahead
     end
 
-    # Returns array of [Shift, next_state]
     def nterm_transitions
-      return @nterm_transitions if @nterm_transitions
-
-      @nterm_transitions = []
-
-      shifts.each do |shift|
-        next if shift.next_sym.term?
-
-        @nterm_transitions << [shift, @items_to_state[shift.next_items]]
-      end
-
-      @nterm_transitions
+      @nterm_transitions ||= transitions.select {|shift, _| shift.next_sym.nterm? }
     end
 
-    # Returns array of [Shift, next_state]
     def term_transitions
-      return @term_transitions if @term_transitions
-
-      @term_transitions = []
-
-      shifts.each do |shift|
-        next if shift.next_sym.nterm?
-
-        @term_transitions << [shift, @items_to_state[shift.next_items]]
-      end
-
-      @term_transitions
+      @term_transitions ||= transitions.select {|shift, _| shift.next_sym.term? }
     end
 
     def transitions
-      term_transitions + nterm_transitions
+      @transitions ||= shifts.map {|shift| [shift, @items_to_state[shift.next_items]] }
     end
 
     def selected_term_transitions

data/lib/lrama/version.rb

@@ -1,3 +1,3 @@
 module Lrama
-  VERSION = "0.6.4".freeze
+  VERSION = "0.6.6".freeze
 end

data/parser.y

@@ -30,6 +30,7 @@ rule
 
   bison_declaration: grammar_declaration
                    | rule_declaration
+                   | inline_declaration
                    | "%expect" INTEGER { @grammar.expect = val[1] }
                    | "%define" variable value
                    | "%param" params
@@ -237,6 +238,12 @@ rule
                         @grammar.add_parameterizing_rule(rule)
                       }
 
+  inline_declaration: "%rule" "%inline" id_colon ":" rule_rhs_list
+                      {
+                        rule = Grammar::ParameterizingRule::Rule.new(val[2].s_value, [], val[4], is_inline: true)
+                        @grammar.add_parameterizing_rule(rule)
+                      }
+
   rule_args: IDENTIFIER { result = [val[0]] }
            | rule_args "," IDENTIFIER { result = val[0].append(val[2]) }
 
@@ -462,10 +469,11 @@ rule
          {
            end_c_declaration
          }
-       "}" named_ref_opt
+       "}" named_ref_opt tag_opt
          {
            user_code = val[3]
            user_code.alias_name = val[6]
+           user_code.tag = val[7]
            builder = val[0]
            builder.user_code = user_code
            result = builder

data/sample/calc.y

@@ -31,6 +31,12 @@ static int yyerror(YYLTYPE *loc, const char *str);
 %left '+' '-'
 %left '*' '/'
 
+%rule %inline op    : '+' { + }
+                    | '-' { - }
+                    | '*' { * }
+                    | '/' { / }
+                    ;
+
 %%
 
 list : /* empty */
@@ -38,10 +44,7 @@ list : /* empty */
      | list expr LF { printf("=> %d\n", $2); }
      ;
 expr : NUM
-     | expr '+' expr { $$ = $1 + $3; }
-     | expr '-' expr { $$ = $1 - $3; }
-     | expr '*' expr { $$ = $1 * $3; }
-     | expr '/' expr { $$ = $1 / $3; }
+     | expr op expr { $$ = $1 $2 $3; }
      | '(' expr ')'  { $$ = $2; }
      ;
 

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

@@ -8,13 +8,15 @@ module Lrama
 
         def initialize: () -> void
         def add_parameterizing_rule: (Grammar::ParameterizingRule::Rule rule) -> void
-        def find: (Lexer::Token::InstantiateRule token) -> 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?
 
         private
 
-        def select_rules: (Lexer::Token::InstantiateRule token) -> Array[Grammar::ParameterizingRule::Rule]
-        def select_rules_by_name: (String rule_name) -> Array[Grammar::ParameterizingRule::Rule]
+        def select_rules: (Array[Grammar::ParameterizingRule::Rule] rules, Lexer::Token::InstantiateRule token) -> Array[Grammar::ParameterizingRule::Rule]
+        def select_not_inline_rules: (Array[Grammar::ParameterizingRule::Rule] rules) -> Array[Grammar::ParameterizingRule::Rule]
+        def select_rules_by_name: (Array[Grammar::ParameterizingRule::Rule] rules, String rule_name) -> Array[Grammar::ParameterizingRule::Rule]
       end
     end
   end

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

@@ -6,8 +6,9 @@ module Lrama
         attr_reader parameters: Array[Lexer::Token]
         attr_reader rhs_list: Array[Grammar::ParameterizingRule::Rhs]
         attr_reader required_parameters_count: Integer
+        attr_reader is_inline: bool
 
-        def initialize: (String name, Array[Lexer::Token] parameters, Array[Grammar::ParameterizingRule::Rhs] rhs_list) -> void
+        def initialize: (String name, Array[Lexer::Token] parameters, Array[Grammar::ParameterizingRule::Rhs] rhs_list, ?is_inline: bool) -> void
       end
     end
   end

data/sig/lrama/grammar/rule_builder.rbs

@@ -15,10 +15,11 @@ module Lrama
       @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]
-      @old_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
@@ -36,6 +37,9 @@ module Lrama
       def build_rules: () -> void
       def process_rhs: (Grammar::ParameterizingRule::Resolver parameterizing_rule_resolver) -> 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 replace_inline_user_code: (Grammar::ParameterizingRule::Rhs inline_rhs, Integer index) -> Lexer::Token::UserCode?
       def numberize_references: () -> void
       def flush_user_code: () -> void
     end

data/sig/lrama/lexer/grammar_file.rbs

@@ -1,6 +1,8 @@
 module Lrama
   class Lexer
     class GrammarFile
+      class Text < String
+      end
       attr_reader path: String
       attr_reader text: String
 

data/sig/lrama/lexer/token/user_code.rbs

@@ -2,6 +2,7 @@ module Lrama
   class Lexer
     class Token
       class UserCode < Token
+        attr_accessor tag: Lexer::Token::Tag
         @references: Array[Lrama::Grammar::Reference]
 
         def references: () -> Array[Lrama::Grammar::Reference]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lrama
 version: !ruby/object:Gem::Version
-  version: 0.6.4
+  version: 0.6.6
 platform: ruby
 authors:
 - Yuichiro Kaneko
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-03-22 00:00:00.000000000 Z
+date: 2024-04-27 00:00:00.000000000 Z
 dependencies: []
 description: LALR (1) parser generator written by Ruby
 email: