lrama 0.5.8 → 0.5.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 52e495f849079217c2cb4ee28edf873dd7c999d02f2f486acf8b9c2c1e74006f
-  data.tar.gz: 708aea3d87d066b71857d09c4b9fc0705c8abaedc1e8b8e465ae5f6c2a5e0315
+  metadata.gz: '0097beb1eb7af4947e417b356a7e3c81c3002916f4a1b2940b2df196ee58f144'
+  data.tar.gz: 982c957cdb8c42d8b77210756046e35f395875bb527f32a66b3a82ff236cbe78
 SHA512:
-  metadata.gz: 779e08f5090a78347214d8fbe73e710469ed62f61e923b5fbf50ed1e4c022a4096961df035b517b4c6434fa69326d3a006d94cff144f2c87b48407093f8961c7
-  data.tar.gz: df1e4828906ae7613bca0f5f7dda3466091aa0fe15d7d5147e92bcd803f8ef0e58b6935a6e5061bb18d715a1e0f8b47aaab678c553edda828cb7ff1b05b2bc0f
+  metadata.gz: a4bbdebc7f100a1b26c801c3c153519e3fb11d34f6dc5001391302665e779905d95041781917af93b2dac64854f174630044e384465bd5606df40f9f878707b1
+  data.tar.gz: b46f8eb2dffa4df04563bbc8997a9efd06f5a70dcbc26e19f6301624aadf5bc416721045ecf6650b83ae64b9889689c8aeef078e9637e0a152a9ac204ab766de

data/.github/workflows/test.yaml

@@ -20,6 +20,7 @@ jobs:
         with:
           ruby-version: ${{ matrix.ruby }}
           bundler-cache: true
+      - run: flex --help
       - run: bundle install
       - run: bundle exec rspec
   test-windows:
@@ -34,6 +35,8 @@ jobs:
         with:
           ruby-version: ${{ matrix.ruby }}
           bundler-cache: true
+      - run: choco install winflexbison
+      - run: win_flex --help
       - run: bundle install
       - run: bundle exec rspec
   check-misc:
@@ -57,7 +60,7 @@ jobs:
 
       - name: Check for parser.rb is up to date
         run: |
-          bundle exec rake build:racc_parser
+          bundle exec rake build:parser
           git diff --color --no-ext-diff --ignore-submodules --exit-code lib/lrama/parser.rb
   steep-check:
     runs-on: ubuntu-20.04
@@ -65,6 +68,8 @@ jobs:
       fail-fast: false
       matrix:
         ruby: ['head']
+    env:
+      INSTALL_STEEP: 'true'
     steps:
       - uses: actions/checkout@v4
       - uses: ruby/setup-ruby@v1

data/.gitignore

@@ -1,7 +1,10 @@
+/.DS_Store
+/.bundle/
 /.gem_rbs_collection/
-/tmp
-.irbrc
+/.irbrc
 /Gemfile.lock
-/pkg/
-coverage/
+/coverage/
 /parser.output
+/pkg/
+/tmp/
+/vendor/bundle

data/Gemfile

@@ -2,12 +2,16 @@ source 'https://rubygems.org'
 
 gemspec
 
-gem "rspec"
 gem "pry"
-# stackprof doesn't support Windows
-gem "stackprof", platforms: [:ruby]
-gem "racc"
+gem "racc", "1.7.3"
 gem "rake"
-gem "rbs", require: false
-gem "steep", require: false
+gem "rspec"
 gem "simplecov", require: false
+gem "stackprof", platforms: [:ruby] # stackprof doesn't support Windows
+
+# Recent steep requires Ruby >= 3.0.0.
+# Then skip install on some CI jobs.
+if !ENV['GITHUB_ACTION'] || ENV['INSTALL_STEEP'] == 'true'
+  gem "rbs", "3.3.0", require: false
+  gem "steep", "1.6.0", require: false
+end

data/README.md

@@ -65,13 +65,13 @@ This also requires Lrama to be able to run with only default gems because BASERU
 
 ## Development
 
-### How to generate new_parser.rb
+### How to generate parser.rb
 
 ```shell
-$ rake build:racc_parser
+$ rake build:parser
 ```
 
-`new_parser.rb` is generated from `parser.y` by Racc.
+`parser.rb` is generated from `parser.y` by Racc.
 Run the rake command when you update `parser.y` then commit changes of both files.
 
 ### Test

data/Rakefile

@@ -1,13 +1,21 @@
 require "bundler/gem_tasks"
 
 namespace "build" do
-  desc "build parser from parser.y by using Racc"
-  task :racc_parser do
-    sh "bundle exec racc parser.y --embedded -o lib/lrama/parser.rb"
-  end
-
-  desc "build parser for debugging"
-  task :racc_verbose_parser do
+  desc "build parser from parser.y"
+  task :parser do
     sh "bundle exec racc parser.y --embedded -o lib/lrama/parser.rb -t --log-file=parser.output"
   end
 end
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+task :spec => "build:parser"
+
+desc "steep check"
+task :steep do
+  sh "bundle exec steep check"
+end
+
+task default: %i[spec steep]

data/Steepfile

@@ -6,8 +6,22 @@ target :lib do
 
   check "lib/lrama/bitmap.rb"
   check "lib/lrama/digraph.rb"
+  check "lib/lrama/grammar/code.rb"
+  check "lib/lrama/grammar/code/printer_code.rb"
+  check "lib/lrama/grammar/counter.rb"
+  check "lib/lrama/grammar/percent_code.rb"
+  check "lib/lrama/grammar/precedence.rb"
+  check "lib/lrama/grammar/printer.rb"
+  check "lib/lrama/grammar/reference.rb"
+  check "lib/lrama/grammar/rule_builder.rb"
+  check "lib/lrama/lexer/token/char.rb"
+  check "lib/lrama/lexer/token/ident.rb"
+  check "lib/lrama/lexer/token/parameterizing.rb"
+  check "lib/lrama/lexer/token/tag.rb"
+  check "lib/lrama/lexer/token/user_code.rb"
+  check "lib/lrama/lexer/location.rb"
+  check "lib/lrama/lexer/token.rb"
   check "lib/lrama/report/duration.rb"
   check "lib/lrama/report/profile.rb"
-  check "lib/lrama/token/type.rb"
   check "lib/lrama/warning.rb"
 end

data/lib/lrama/command.rb

@@ -8,7 +8,7 @@ module Lrama
       warning = Lrama::Warning.new
       text = options.y.read
       options.y.close if options.y != STDIN
-      grammar = Lrama::Parser.new(text, options.grammar_file).parse
+      grammar = Lrama::Parser.new(text, options.grammar_file, options.debug).parse
       states = Lrama::States.new(grammar, warning, trace_state: (options.trace_opts[:automaton] || options.trace_opts[:closure]))
       states.compute
       context = Lrama::Context.new(states)
@@ -20,6 +20,11 @@ module Lrama
         end
       end
 
+      if options.trace_opts && options.trace_opts[:rules]
+        puts "Grammar rules:"
+        puts grammar.rules
+      end
+
       File.open(options.outfile, "w+") do |f|
         Lrama::Output.new(
           out: f,

data/lib/lrama/context.rb

@@ -309,10 +309,8 @@ module Lrama
       # Index is sequence number of nterm, value is state id
       # of a default nterm transition destination.
       @yydefgoto = Array.new(@states.nterms.count, 0)
-      h = {}
       # Mapping from nterm to next_states
       nterm_to_next_states = {}
-      terms_count = @states.terms.count
 
       @states.states.each do |state|
         state.nterm_transitions.each do |shift, next_state|
@@ -369,7 +367,7 @@ module Lrama
         end
 
         j = @sorted_actions.count - 1
-        state_id, froms_and_tos, count, width = action
+        _state_id, _froms_and_tos, count, width = action
 
         while (j >= 0) do
           case

data/lib/lrama/counterexamples/path.rb

@@ -19,51 +19,5 @@ module Lrama
       end
       alias :inspect :to_s
     end
-
-    class StartPath < Path
-      def initialize(to_state_item)
-        super nil, to_state_item
-      end
-
-      def type
-        :start
-      end
-
-      def transition?
-        false
-      end
-
-      def production?
-        false
-      end
-    end
-
-    class TransitionPath < Path
-      def type
-        :transition
-      end
-
-      def transition?
-        true
-      end
-
-      def production?
-        false
-      end
-    end
-
-    class ProductionPath < Path
-      def type
-        :production
-      end
-
-      def transition?
-        false
-      end
-
-      def production?
-        true
-      end
-    end
   end
 end

data/lib/lrama/counterexamples/production_path.rb

@@ -0,0 +1,17 @@
+module Lrama
+  class Counterexamples
+    class ProductionPath < Path
+      def type
+        :production
+      end
+
+      def transition?
+        false
+      end
+
+      def production?
+        true
+      end
+    end
+  end
+end

data/lib/lrama/counterexamples/start_path.rb

@@ -0,0 +1,21 @@
+module Lrama
+  class Counterexamples
+    class StartPath < Path
+      def initialize(to_state_item)
+        super nil, to_state_item
+      end
+
+      def type
+        :start
+      end
+
+      def transition?
+        false
+      end
+
+      def production?
+        false
+      end
+    end
+  end
+end

data/lib/lrama/counterexamples/transition_path.rb

@@ -0,0 +1,17 @@
+module Lrama
+  class Counterexamples
+    class TransitionPath < Path
+      def type
+        :transition
+      end
+
+      def transition?
+        true
+      end
+
+      def production?
+        false
+      end
+    end
+  end
+end

data/lib/lrama/counterexamples.rb

@@ -3,7 +3,10 @@ require "set"
 require "lrama/counterexamples/derivation"
 require "lrama/counterexamples/example"
 require "lrama/counterexamples/path"
+require "lrama/counterexamples/production_path"
+require "lrama/counterexamples/start_path"
 require "lrama/counterexamples/state_item"
+require "lrama/counterexamples/transition_path"
 require "lrama/counterexamples/triple"
 
 module Lrama

data/lib/lrama/grammar/code/initial_action_code.rb

@@ -0,0 +1,28 @@
+module Lrama
+  class Grammar
+    class Code
+      class InitialActionCode < Code
+        private
+
+        # * ($$) yylval
+        # * (@$) yylloc
+        # * ($1) error
+        # * (@1) error
+        def reference_to_c(ref)
+          case
+          when ref.type == :dollar && ref.name == "$" # $$
+            "yylval"
+          when ref.type == :at && ref.name == "$" # @$
+            "yylloc"
+          when ref.type == :dollar # $n
+            raise "$#{ref.value} can not be used in initial_action."
+          when ref.type == :at # @n
+            raise "@#{ref.value} can not be used in initial_action."
+          else
+            raise "Unexpected. #{self}, #{ref}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lrama/grammar/code/no_reference_code.rb

@@ -0,0 +1,24 @@
+module Lrama
+  class Grammar
+    class Code
+      class NoReferenceCode < Code
+        private
+
+        # * ($$) error
+        # * (@$) error
+        # * ($1) error
+        # * (@1) error
+        def reference_to_c(ref)
+          case
+          when ref.type == :dollar # $$, $n
+            raise "$#{ref.value} can not be used in #{type}."
+          when ref.type == :at # @$, @n
+            raise "@#{ref.value} can not be used in #{type}."
+          else
+            raise "Unexpected. #{self}, #{ref}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lrama/grammar/code/printer_code.rb

@@ -0,0 +1,34 @@
+module Lrama
+  class Grammar
+    class Code
+      class PrinterCode < Code
+        def initialize(type: nil, token_code: nil, tag: nil)
+          super(type: type, token_code: token_code)
+          @tag = tag
+        end
+
+        private
+
+        # * ($$) *yyvaluep
+        # * (@$) *yylocationp
+        # * ($1) error
+        # * (@1) error
+        def reference_to_c(ref)
+          case
+          when ref.type == :dollar && ref.name == "$" # $$
+            member = @tag.member
+            "((*yyvaluep).#{member})"
+          when ref.type == :at && ref.name == "$" # @$
+            "(*yylocationp)"
+          when ref.type == :dollar # $n
+            raise "$#{ref.value} can not be used in #{type}."
+          when ref.type == :at # @n
+            raise "@#{ref.value} can not be used in #{type}."
+          else
+            raise "Unexpected. #{self}, #{ref}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lrama/grammar/code/rule_action.rb

@@ -0,0 +1,62 @@
+module Lrama
+  class Grammar
+    class Code
+      class RuleAction < Code
+        def initialize(type: nil, token_code: nil, rule: nil)
+          super(type: type, token_code: token_code)
+          @rule = rule
+        end
+
+        private
+
+        # * ($$) yyval
+        # * (@$) yyloc
+        # * ($1) yyvsp[i]
+        # * (@1) yylsp[i]
+        #
+        # "Rule"                class: keyword_class { $1 } tSTRING { $2 + $3 } keyword_end { $class = $1 + $keyword_end }
+        # "Position in grammar"                   $1    $2      $3          $4          $5                             $6
+        # "Index for yyvsp"                       -4    -3      -2          -1           0
+        def reference_to_c(ref)
+          case
+          when ref.type == :dollar && ref.name == "$" # $$
+            tag = ref.ex_tag || lhs.tag
+            raise_tag_not_found_error(ref) unless tag
+            "(yyval.#{tag.member})"
+          when ref.type == :at && ref.name == "$" # @$
+            "(yyloc)"
+          when ref.type == :dollar # $n
+            i = -position_in_rhs + ref.index
+            tag = ref.ex_tag || rhs[ref.index - 1].tag
+            raise_tag_not_found_error(ref) unless tag
+            "(yyvsp[#{i}].#{tag.member})"
+          when ref.type == :at # @n
+            i = -position_in_rhs + ref.index
+            "(yylsp[#{i}])"
+          else
+            raise "Unexpected. #{self}, #{ref}"
+          end
+        end
+
+        def position_in_rhs
+          # If rule is not derived rule, User Code is only action at
+          # the end of rule RHS. In such case, the action is located on
+          # `@rule.rhs.count`.
+          @rule.position_in_original_rule_rhs || @rule.rhs.count
+        end
+
+        def rhs
+          (@rule.original_rule || @rule).rhs
+        end
+
+        def lhs
+          (@rule.original_rule || @rule).lhs
+        end
+
+        def raise_tag_not_found_error(ref)
+          raise "Tag is not specified for '$#{ref.value}' in '#{@rule.to_s}'"
+        end
+      end
+    end
+  end
+end

data/lib/lrama/grammar/code.rb

@@ -7,116 +7,32 @@ module Lrama
 
       def_delegators "token_code", :s_value, :line, :column, :references
 
-      # $$, $n, @$, @n is translated to C code
+      # $$, $n, @$, @n are translated to C code
       def translated_code
-        case type
-        when :user_code
-          translated_user_code
-        when :initial_action
-          translated_initial_action_code
-        end
-      end
-
-      # * ($1) error
-      # * ($$) *yyvaluep
-      # * (@1) error
-      # * (@$) *yylocationp
-      def translated_printer_code(tag)
         t_code = s_value.dup
 
         references.reverse.each do |ref|
           first_column = ref.first_column
           last_column = ref.last_column
 
-          case
-          when ref.value == "$" && ref.type == :dollar # $$
-            # Omit "<>"
-            member = tag.s_value[1..-2]
-            str = "((*yyvaluep).#{member})"
-          when ref.value == "$" && ref.type == :at # @$
-            str = "(*yylocationp)"
-          when ref.type == :dollar # $n
-            raise "$#{ref.value} can not be used in %printer."
-          when ref.type == :at # @n
-            raise "@#{ref.value} can not be used in %printer."
-          else
-            raise "Unexpected. #{self}, #{ref}"
-          end
+          str = reference_to_c(ref)
 
           t_code[first_column..last_column] = str
         end
 
         return t_code
       end
-      alias :translated_error_token_code :translated_printer_code
 
       private
 
-      # * ($1) yyvsp[i]
-      # * ($$) yyval
-      # * (@1) yylsp[i]
-      # * (@$) yyloc
-      def translated_user_code
-        t_code = s_value.dup
-
-        references.reverse.each do |ref|
-          first_column = ref.first_column
-          last_column = ref.last_column
-
-          case
-          when ref.value == "$" && ref.type == :dollar # $$
-            # Omit "<>"
-            member = ref.tag.s_value[1..-2]
-            str = "(yyval.#{member})"
-          when ref.value == "$" && ref.type == :at # @$
-            str = "(yyloc)"
-          when ref.type == :dollar # $n
-            i = -ref.position_in_rhs + ref.value
-            # Omit "<>"
-            member = ref.tag.s_value[1..-2]
-            str = "(yyvsp[#{i}].#{member})"
-          when ref.type == :at # @n
-            i = -ref.position_in_rhs + ref.value
-            str = "(yylsp[#{i}])"
-          else
-            raise "Unexpected. #{self}, #{ref}"
-          end
-
-          t_code[first_column..last_column] = str
-        end
-
-        return t_code
-      end
-
-      # * ($1) error
-      # * ($$) yylval
-      # * (@1) error
-      # * (@$) yylloc
-      def translated_initial_action_code
-        t_code = s_value.dup
-
-        references.reverse.each do |ref|
-          first_column = ref.first_column
-          last_column = ref.last_column
-
-          case
-          when ref.value == "$" && ref.type == :dollar # $$
-            str = "yylval"
-          when ref.value == "$" && ref.type == :at # @$
-            str = "yylloc"
-          when ref.type == :dollar # $n
-            raise "$#{ref.value} can not be used in initial_action."
-          when ref.type == :at # @n
-            raise "@#{ref.value} can not be used in initial_action."
-          else
-            raise "Unexpected. #{self}, #{ref}"
-          end
-
-          t_code[first_column..last_column] = str
-        end
-
-        return t_code
+      def reference_to_c(ref)
+        raise NotImplementedError.new("#reference_to_c is not implemented")
       end
     end
   end
 end
+
+require "lrama/grammar/code/initial_action_code"
+require "lrama/grammar/code/no_reference_code"
+require "lrama/grammar/code/printer_code"
+require "lrama/grammar/code/rule_action"

data/lib/lrama/grammar/counter.rb

@@ -0,0 +1,15 @@
+module Lrama
+  class Grammar
+    class Counter
+      def initialize(number)
+        @number = number
+      end
+
+      def increment
+        n = @number
+        @number += 1
+        n
+      end
+    end
+  end
+end

data/lib/lrama/grammar/error_token.rb

@@ -1,8 +1,8 @@
 module Lrama
   class Grammar
-    class ErrorToken < Struct.new(:ident_or_tags, :code, :lineno, keyword_init: true)
-      def translated_code(member)
-        code.translated_error_token_code(member)
+    class ErrorToken < Struct.new(:ident_or_tags, :token_code, :lineno, keyword_init: true)
+      def translated_code(tag)
+        Code::PrinterCode.new(type: :error_token, token_code: token_code, tag: tag).translated_code
       end
     end
   end

data/lib/lrama/grammar/parameterizing_rules/builder/base.rb

@@ -0,0 +1,28 @@
+module Lrama
+  class Grammar
+    class ParameterizingRules
+      class Builder
+        class Base
+          def initialize(token, rule_counter, lhs, user_code, precedence_sym, line)
+            @args = token.args
+            @token = @args.first
+            @rule_counter = rule_counter
+            @lhs = lhs
+            @user_code = user_code
+            @precedence_sym = precedence_sym
+            @line = line
+            @expected_argument_num = 1
+          end
+
+          private
+
+          def validate_argument_number!
+            unless @args.count == @expected_argument_num
+              raise "Invalid number of arguments. expect: #{@expected_argument_num} actual: #{@args.count}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lrama/grammar/parameterizing_rules/builder/list.rb

@@ -0,0 +1,20 @@
+module Lrama
+  class Grammar
+    class ParameterizingRules
+      class Builder
+        class List < Base
+          def build
+            validate_argument_number!
+
+            rules = []
+            list_token = Lrama::Lexer::Token::Ident.new(s_value: "list_#{@token.s_value}")
+            rules << Rule.new(id: @rule_counter.increment, _lhs: @lhs, _rhs: [list_token], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
+            rules << Rule.new(id: @rule_counter.increment, _lhs: list_token, _rhs: [], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
+            rules << Rule.new(id: @rule_counter.increment, _lhs: list_token, _rhs: [list_token, @token], token_code: @user_code, precedence_sym: @precedence_sym, lineno: @line)
+            rules
+          end
+        end
+      end
+    end
+  end
+end