lrama 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0a8a1b04a3e761af04029af3e3b74aaaf4fe9a9e2741205f430264ee3399f66c
-  data.tar.gz: a97ec2c2b2007f3bad6cbe5d1b37baa87d520cc3025e82403a9d8a70cddccc8a
+  metadata.gz: 20a0927bedeb14281abb8a5c59daf643fdfe556b5899cbe4872878b022804da2
+  data.tar.gz: 731fdd0201266db9724a2ebcc1162427a2cfaa9d0d94543e1298b3f2683eb14f
 SHA512:
-  metadata.gz: 820bce06aefc235c02995cc957f9e0d9b2e8d588ce7748225896f0d63c319135068da39977be860815276c360a66e3dd6c2132802aa30e3292d706bc6ae7ef9d
-  data.tar.gz: d5c4ec405196bca888c78bf8a16cc9aef47da0f9943d7eee2bf9033c104f9a07fcb07c4cb6aabb3bb49f0e3665bf37932e2206cd9acad925702c30c7124210fb
+  metadata.gz: 3a6e7c0ef4e7266dae41dba15e3a5d7609cb7171b82e0dbd5b75595e8e3cf8a4a402c5b710cc0f714c54357ef9fc20fd0935e55b8c529c99cd3c09ea173efb87
+  data.tar.gz: fa867c9be43384c7f282bf22ecd2b0939cd0dca263a51914871dba42f409ddc01fb00c34d8696288c3668177fdc450ff1bc9fb5e90fdf053e2d56a5bf31bbe04

data/.github/dependabot.yml

@@ -0,0 +1,6 @@
+version: 2
+updates:
+  - package-ecosystem: 'github-actions'
+    directory: '/'
+    schedule:
+      interval: 'weekly'

data/.github/workflows/test.yaml

@@ -22,6 +22,20 @@ jobs:
           bundler-cache: true
       - run: bundle install
       - run: bundle exec rspec
+  steep-check:
+    runs-on: ubuntu-20.04
+    strategy:
+      fail-fast: false
+      matrix:
+        ruby: ['head']
+    steps:
+      - uses: actions/checkout@v3
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+          bundler-cache: true
+      - run: bundle install
+      - run: bundle exec steep check
   test-ruby:
     runs-on: ubuntu-20.04
     strategy:
@@ -70,5 +84,5 @@ jobs:
       - run: sudo apt-get --purge remove bison
       - run: ../autogen.sh
       - run: ../configure -C --disable-install-doc
-      - run: make YACC=$(readlink -f $(pwd)/../tool/lrama/exe/lrama)
+      - run: make
       - run: make test-all

data/Gemfile

@@ -6,3 +6,5 @@ gem "rspec"
 gem "pry"
 gem "stackprof"
 gem "rake"
+gem "rbs", require: false
+gem "steep", require: false

data/README.md

@@ -21,9 +21,11 @@ $ gem install lrama
 From source codes,
 
 ```shell
+$ cd "$(lrama root)"
+$ bundle install
 $ bundle exec rake install
-$ lrama --version
-0.1.0
+$ bundle exec lrama --version
+0.5.0
 ```
 
 ## Usage
@@ -33,11 +35,36 @@ $ lrama --version
 $ lrama -d sample/parse.y
 ```
 
+```shell
+# "calc", "calc.c", and "calc.h" are generated
+$ lrama -d sample/calc.y -o calc.c && gcc -Wall calc.c -o calc && ./calc
+Enter the formula:
+1
+=> 1
+1+2*3
+=> 7
+(1+2)*3
+=> 9
+```
+
+## Versions and Branches
+
+### v0_4 (`lrama_0_4` branch)
+
+This branch generates "parse.c" compatible with Bison 3.8.2 for ruby 3.0, 3.1, 3.2. The first version migrated to ruby is ["0.4.0"](https://github.com/ruby/ruby/pull/7798) therefore keep this branch for Bison compatible branch.
+
 ## Build Ruby
 
 1. Install Lrama
 2. Run `make YACC=lrama`
 
+## Release flow
+
+1. Update `Lrama::VERSION`
+2. Release as a gem by `rake release`
+3. Update Lrama in ruby/ruby by `cp -r exe lib ruby/tool/lrama`
+4. Create new release on [GitHub](https://github.com/ruby/lrama/releases)
+
 ## License
 
 See LEGAL.md file.

data/Steepfile

@@ -0,0 +1,7 @@
+# D = Steep::Diagnostic
+#
+target :lib do
+  signature "sig"
+
+  check "lib/lrama/bitmap.rb"
+end

data/lib/lrama/grammar.rb

@@ -166,7 +166,7 @@ module Lrama
         when ref.type == :at # @n
           raise "@#{ref.number} can not be used in %printer."
         else
-          raise "Unexpected. #{code}, #{ref}"
+          raise "Unexpected. #{self}, #{ref}"
         end
 
         t_code[first_column..last_column] = str
@@ -205,7 +205,7 @@ module Lrama
           i = -ref.position_in_rhs + ref.number
           str = "(yylsp[#{i}])"
         else
-          raise "Unexpected. #{code}, #{ref}"
+          raise "Unexpected. #{self}, #{ref}"
         end
 
         t_code[first_column..last_column] = str
@@ -235,7 +235,7 @@ module Lrama
         when ref.type == :at # @n
           raise "@#{ref.number} can not be used in initial_action."
         else
-          raise "Unexpected. #{code}, #{ref}"
+          raise "Unexpected. #{self}, #{ref}"
         end
 
         t_code[first_column..last_column] = str
@@ -716,7 +716,7 @@ module Lrama
         # If id is Token::Char, it uses ASCII code
         if sym.term? && sym.token_id.nil?
           if sym.id.type == Token::Char
-            # Igonre ' on the both sides
+            # Ignore ' on the both sides
             case sym.id.s_value[1..-2]
             when "\\b"
               sym.token_id = 8
@@ -844,7 +844,7 @@ module Lrama
 
       return if invalid.empty?
 
-      raise "Symbol number is dupulicated. #{invalid}"
+      raise "Symbol number is duplicated. #{invalid}"
     end
   end
 end

data/lib/lrama/lexer.rb

@@ -206,6 +206,8 @@ module Lrama
         when ss.scan(/\/\*/)
           # TODO: Need to keep comment?
           line = lex_comment(ss, line, lines, "")
+        when ss.scan(/\/\//)
+          line = lex_line_comment(ss, line, "")
         when ss.scan(/'(.)'/)
           tokens << create_token(Token::Char, ss[0], line, ss.pos - column)
         when ss.scan(/'\\(.)'/) # '\\', '\t'
@@ -218,7 +220,7 @@ module Lrama
           l = line - lines.first[1]
           split = ss.string.split("\n")
           col = ss.pos - split[0...l].join("\n").length
-          raise "Parse error (unknow token): #{split[l]} \"#{ss.string[ss.pos]}\" (#{line}: #{col})"
+          raise "Parse error (unknown token): #{split[l]} \"#{ss.string[ss.pos]}\" (#{line}: #{col})"
         end
       end
     end
@@ -276,6 +278,9 @@ module Lrama
         when ss.scan(/\/\*/)
           str << ss[0]
           line = lex_comment(ss, line, lines, str)
+        when ss.scan(/\/\//)
+          str << ss[0]
+          line = lex_line_comment(ss, line, str)
         else
           # noop, just consume char
           str << ss.getch
@@ -314,8 +319,6 @@ module Lrama
       raise "Parse error (quote mismatch): #{ss.string.split("\n")[l]} \"#{ss.string[ss.pos]}\" (#{line}: #{ss.pos})"
     end
 
-    # TODO: Need to handle // style comment
-    #
     # /*  */ style comment
     def lex_comment(ss, line, lines, str)
       while !ss.eos? do
@@ -337,6 +340,23 @@ module Lrama
       raise "Parse error (comment mismatch): #{ss.string.split("\n")[l]} \"#{ss.string[ss.pos]}\" (#{line}: #{ss.pos})"
     end
 
+    # // style comment
+    def lex_line_comment(ss, line, str)
+      while !ss.eos? do
+        case
+        when ss.scan(/\n/)
+          return line + 1
+        else
+          str << ss.getch
+          next
+        end
+
+        str << ss[0]
+      end
+
+      line # Reach to end of input
+    end
+
     def lex_grammar_rules_tokens
       lex_common(@grammar_rules, @grammar_rules_tokens)
     end

data/lib/lrama/parser/token_scanner.rb

@@ -0,0 +1,55 @@
+module Lrama
+  class Parser
+    class TokenScanner
+      def initialize(tokens)
+        @tokens = tokens
+        @index = 0
+      end
+
+      def current_token
+        @tokens[@index]
+      end
+
+      def current_type
+        current_token && current_token.type
+      end
+
+      def next
+        token = current_token
+        @index += 1
+        return token
+      end
+
+      def consume(*token_types)
+        if token_types.include?(current_type)
+          token = current_token
+          self.next
+          return token
+        end
+
+        return nil
+      end
+
+      def consume!(*token_types)
+        consume(*token_types) || (raise "#{token_types} is expected but #{current_type}. #{current_token}")
+      end
+
+      def consume_multi(*token_types)
+        a = []
+
+        while token_types.include?(current_type)
+          a << current_token
+          self.next
+        end
+
+        raise "No token is consumed. #{token_types}" if a.empty?
+
+        return a
+      end
+
+      def eots?
+        current_token.nil?
+      end
+    end
+  end
+end

data/lib/lrama/parser.rb

@@ -1,4 +1,5 @@
 require "lrama/report"
+require "lrama/parser/token_scanner"
 
 module Lrama
   # Parser for parse.y, generates a grammar
@@ -7,58 +8,6 @@ module Lrama
 
     T = Lrama::Lexer::Token
 
-    class TokenScanner
-      def initialize(tokens)
-        @tokens = tokens
-        @index = 0
-      end
-
-      def current_token
-        @tokens[@index]
-      end
-
-      def current_type
-        current_token && current_token.type
-      end
-
-      def next
-        token = current_token
-        @index += 1
-        return token
-      end
-
-      def consume(*token_types)
-        if token_types.include?(current_type)
-          token = current_token
-          self.next
-          return token
-        end
-
-        return nil
-      end
-
-      def consume!(*token_types)
-        consume(*token_types) || (raise "#{token_types} is expected but #{current_type}. #{current_token}")
-      end
-
-      def consume_multi(*token_types)
-        a = []
-
-        while token_types.include?(current_type)
-          a << current_token
-          self.next
-        end
-
-        raise "No token is consumed. #{token_types}" if a.empty?
-
-        return a
-      end
-
-      def eots?
-        current_token.nil?
-      end
-    end
-
     def initialize(text)
       @text = text
     end

data/lib/lrama/state/reduce.rb

@@ -0,0 +1,35 @@
+module Lrama
+  class State
+    class Reduce
+      # https://www.gnu.org/software/bison/manual/html_node/Default-Reductions.html
+      attr_reader :item, :look_ahead, :not_selected_symbols
+      attr_accessor :default_reduction
+
+      def initialize(item)
+        @item = item
+        @look_ahead = nil
+        @not_selected_symbols = []
+      end
+
+      def rule
+        @item.rule
+      end
+
+      def look_ahead=(look_ahead)
+        @look_ahead = look_ahead.freeze
+      end
+
+      def add_not_selected_symbol(sym)
+        @not_selected_symbols << sym
+      end
+
+      def selected_look_ahead
+        if @look_ahead
+          @look_ahead - @not_selected_symbols
+        else
+          []
+        end
+      end
+    end
+  end
+end

data/lib/lrama/state/shift.rb

@@ -0,0 +1,13 @@
+module Lrama
+  class State
+    class Shift
+      attr_reader :next_sym, :next_items
+      attr_accessor :not_selected
+
+      def initialize(next_sym, next_items)
+        @next_sym = next_sym
+        @next_items = next_items
+      end
+    end
+  end
+end

data/lib/lrama/state.rb

@@ -0,0 +1,184 @@
+require "lrama/state/reduce"
+require "lrama/state/shift"
+
+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,
+                :default_reduction_rule, :closure, :items
+    attr_accessor :shifts, :reduces
+
+    def initialize(id, accessing_symbol, kernels)
+      @id = id
+      @accessing_symbol = accessing_symbol
+      @kernels = kernels.freeze
+      @items = @kernels
+      # Manage relationships between items to state
+      # to resolve next state
+      @items_to_state = {}
+      @conflicts = []
+      @resolved_conflicts = []
+      @default_reduction_rule = nil
+    end
+
+    def closure=(closure)
+      @closure = closure
+      @items = @kernels + @closure
+    end
+
+    def non_default_reduces
+      reduces.select do |reduce|
+        reduce.rule != @default_reduction_rule
+      end
+    end
+
+    def compute_shifts_reduces
+      _shifts = {}
+      reduces = []
+      items.each do |item|
+        # TODO: Consider what should be pushed
+        if item.end_of_rule?
+          reduces << Reduce.new(item)
+        else
+          key = item.next_sym
+          _shifts[key] ||= []
+          _shifts[key] << item.new_by_next_position
+        end
+      end
+
+      # It seems Bison 3.8.2 iterates transitions order by symbol number
+      shifts = _shifts.sort_by do |next_sym, new_items|
+        next_sym.number
+      end.map do |next_sym, new_items|
+        Shift.new(next_sym, new_items.flatten)
+      end
+      self.shifts = shifts.freeze
+      self.reduces = reduces.freeze
+    end
+
+    def set_items_to_state(items, next_state)
+      @items_to_state[items] = next_state
+    end
+
+    #
+    def set_look_ahead(rule, look_ahead)
+      reduce = reduces.find do |r|
+        r.rule == rule
+      end
+
+      reduce.look_ahead = look_ahead
+    end
+
+    # Returns array of [nterm, 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
+    end
+
+    # Returns array of [term, 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
+    end
+
+    def selected_term_transitions
+      term_transitions.select do |shift, next_state|
+        !shift.not_selected
+      end
+    end
+
+    # Move to next state by sym
+    def transition(sym)
+      result = nil
+
+      if sym.term?
+        term_transitions.each do |shift, next_state|
+          term = shift.next_sym
+          result = next_state if term == sym
+        end
+      else
+        nterm_transitions.each do |shift, next_state|
+          nterm = shift.next_sym
+          result = next_state if nterm == sym
+        end
+      end
+
+      raise "Can not transit by #{sym} #{self}" if result.nil?
+
+      result
+    end
+
+    def find_reduce_by_item!(item)
+      reduces.find do |r|
+        r.item == item
+      end || (raise "reduce is not found. #{item}")
+    end
+
+    def default_reduction_rule=(default_reduction_rule)
+      @default_reduction_rule = default_reduction_rule
+
+      reduces.each do |r|
+        if r.rule == default_reduction_rule
+          r.default_reduction = true
+        end
+      end
+    end
+
+    def sr_conflicts
+      @conflicts.select do |conflict|
+        conflict.type == :shift_reduce
+      end
+    end
+
+    def rr_conflicts
+      @conflicts.select do |conflict|
+        conflict.type == :reduce_reduce
+      end
+    end
+  end
+end

data/lib/lrama/states.rb

@@ -2,228 +2,6 @@ require "forwardable"
 require "lrama/report"
 
 module Lrama
-  class State
-    class Reduce
-      # https://www.gnu.org/software/bison/manual/html_node/Default-Reductions.html
-      attr_reader :item, :look_ahead, :not_selected_symbols
-      attr_accessor :default_reduction
-
-      def initialize(item)
-        @item = item
-        @look_ahead = nil
-        @not_selected_symbols = []
-      end
-
-      def rule
-        @item.rule
-      end
-
-      def look_ahead=(look_ahead)
-        @look_ahead = look_ahead.freeze
-      end
-
-      def add_not_selected_symbol(sym)
-        @not_selected_symbols << sym
-      end
-
-      def selected_look_ahead
-        if @look_ahead
-          @look_ahead - @not_selected_symbols
-        else
-          []
-        end
-      end
-    end
-
-    class Shift
-      attr_reader :next_sym, :next_items
-      attr_accessor :not_selected
-
-      def initialize(next_sym, next_items)
-        @next_sym = next_sym
-        @next_items = next_items
-      end
-    end
-
-    # * 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,
-                :default_reduction_rule, :closure, :items
-    attr_accessor :shifts, :reduces
-
-    def initialize(id, accessing_symbol, kernels)
-      @id = id
-      @accessing_symbol = accessing_symbol
-      @kernels = kernels.freeze
-      @items = @kernels
-      # Manage relationships between items to state
-      # to resolve next state
-      @items_to_state = {}
-      @conflicts = []
-      @resolved_conflicts = []
-      @default_reduction_rule = nil
-    end
-
-    def closure=(closure)
-      @closure = closure
-      @items = @kernels + @closure
-    end
-
-    def non_default_reduces
-      reduces.select do |reduce|
-        reduce.rule != @default_reduction_rule
-      end
-    end
-
-    def compute_shifts_reduces
-      _shifts = {}
-      reduces = []
-      items.each do |item|
-        # TODO: Consider what should be pushed
-        if item.end_of_rule?
-          reduces << Reduce.new(item)
-        else
-          key = item.next_sym
-          _shifts[key] ||= []
-          _shifts[key] << item.new_by_next_position
-        end
-      end
-
-      # It seems Bison 3.8.2 iterates transitions order by symbol number
-      shifts = _shifts.sort_by do |next_sym, new_items|
-        next_sym.number
-      end.map do |next_sym, new_items|
-        Shift.new(next_sym, new_items.flatten)
-      end
-      self.shifts = shifts.freeze
-      self.reduces = reduces.freeze
-    end
-
-    def set_items_to_state(items, next_state)
-      @items_to_state[items] = next_state
-    end
-
-    #
-    def set_look_ahead(rule, look_ahead)
-      reduce = reduces.find do |r|
-        r.rule == rule
-      end
-
-      reduce.look_ahead = look_ahead
-    end
-
-    # Returns array of [nterm, 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
-    end
-
-    # Returns array of [term, 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
-    end
-
-    def selected_term_transitions
-      term_transitions.select do |shift, next_state|
-        !shift.not_selected
-      end
-    end
-
-    # Move to next state by sym
-    def transition(sym)
-      result = nil
-
-      if sym.term?
-        term_transitions.each do |shift, next_state|
-          term = shift.next_sym
-          result = next_state if term == sym
-        end
-      else
-        nterm_transitions.each do |shift, next_state|
-          nterm = shift.next_sym
-          result = next_state if nterm == sym
-        end
-      end
-
-      raise "Can not transit by #{sym} #{self}" if result.nil?
-
-      result
-    end
-
-    def find_reduce_by_item!(item)
-      reduces.find do |r|
-        r.item == item
-      end || (raise "reduce is not found. #{item}, #{state}")
-    end
-
-    def default_reduction_rule=(default_reduction_rule)
-      @default_reduction_rule = default_reduction_rule
-
-      reduces.each do |r|
-        if r.rule == default_reduction_rule
-          r.default_reduction = true
-        end
-      end
-    end
-
-    def sr_conflicts
-      @conflicts.select do |conflict|
-        conflict.type == :shift_reduce
-      end
-    end
-
-    def rr_conflicts
-      @conflicts.select do |conflict|
-        conflict.type == :reduce_reduce
-      end
-    end
-  end
-
   # States is passed to a template file
   #
   # "Efficient Computation of LALR(1) Look-Ahead Sets"
@@ -411,23 +189,13 @@ module Lrama
       @states.flat_map(&:rr_conflicts)
     end
 
-    def initial_attrs
-      h = {}
-
-      attrs.each do |attr|
-        h[attr.id] = false
-      end
-
-      h
-    end
-
     def trace_state
       if @trace_state
         yield STDERR
       end
     end
 
-    def create_state(accessing_symbol, kernels, states_creted)
+    def create_state(accessing_symbol, kernels, states_created)
       # A item can appear in some states,
       # so need to use `kernels` (not `kernels.first`) as a key.
       #
@@ -464,11 +232,11 @@ module Lrama
       #    string_1: string •
       #    string_2: string • '+'
       #
-      return [states_creted[kernels], false] if states_creted[kernels]
+      return [states_created[kernels], false] if states_created[kernels]
 
       state = State.new(@states.count, accessing_symbol, kernels)
       @states << state
-      states_creted[kernels] = state
+      states_created[kernels] = state
 
       return [state, true]
     end
@@ -532,9 +300,9 @@ module Lrama
     def compute_lr0_states
       # State queue
       states = []
-      states_creted = {}
+      states_created = {}
 
-      state, _ = create_state(symbols.first, [Item.new(rule: @grammar.rules.first, position: 0)], states_creted)
+      state, _ = create_state(symbols.first, [Item.new(rule: @grammar.rules.first, position: 0)], states_created)
       enqueue_state(states, state)
 
       while (state = states.shift) do
@@ -550,7 +318,7 @@ module Lrama
         setup_state(state)
 
         state.shifts.each do |shift|
-          new_state, created = create_state(shift.next_sym, shift.next_items, states_creted)
+          new_state, created = create_state(shift.next_sym, shift.next_items, states_created)
           state.set_items_to_state(shift.next_items, new_state)
           enqueue_state(states, new_state) if created
         end

data/lib/lrama/states_reporter.rb

@@ -210,7 +210,7 @@ module Lrama
           io << "\n"
 
 
-          # Reprot reads_relation
+          # Report reads_relation
           io << "  [Reads Relation]\n"
           @states.nterms.each do |nterm|
             a = @states.reads_relation[[state.id, nterm.token_id]]
@@ -224,7 +224,7 @@ module Lrama
           io << "\n"
 
 
-          # Reprot read_sets
+          # Report read_sets
           io << "  [Read sets]\n"
           read_sets = @states.read_sets
           @states.nterms.each do |nterm|
@@ -239,7 +239,7 @@ module Lrama
           io << "\n"
 
 
-          # Reprot includes_relation
+          # Report includes_relation
           io << "  [Includes Relation]\n"
           @states.nterms.each do |nterm|
             a = @states.includes_relation[[state.id, nterm.token_id]]
@@ -267,7 +267,7 @@ module Lrama
           io << "\n"
 
 
-          # Reprot follow_sets
+          # Report follow_sets
           io << "  [Follow sets]\n"
           follow_sets = @states.follow_sets
           @states.nterms.each do |nterm|

data/lib/lrama/version.rb

@@ -1,3 +1,3 @@
 module Lrama
-  VERSION = "0.5.0".freeze
+  VERSION = "0.5.1".freeze
 end

data/lib/lrama.rb

@@ -7,6 +7,7 @@ require "lrama/lexer"
 require "lrama/output"
 require "lrama/parser"
 require "lrama/report"
+require "lrama/state"
 require "lrama/states"
 require "lrama/states_reporter"
 require "lrama/version"

data/sample/calc.output

@@ -0,0 +1,263 @@
+Grammar
+
+    0 $accept: list "end of file"
+
+    1 list: ε
+    2     | list LF
+    3     | list expr LF
+
+    4 expr: NUM
+    5     | expr '+' expr
+    6     | expr '-' expr
+    7     | expr '*' expr
+    8     | expr '/' expr
+    9     | '(' expr ')'
+
+
+State 0
+
+    0 $accept: • list "end of file"
+    1 list: ε •
+    2     | • list LF
+    3     | • list expr LF
+
+    $default  reduce using rule 1 (list)
+
+    list  go to state 1
+
+
+State 1
+
+    0 $accept: list • "end of file"
+    2 list: list • LF
+    3     | list • expr LF
+    4 expr: • NUM
+    5     | • expr '+' expr
+    6     | • expr '-' expr
+    7     | • expr '*' expr
+    8     | • expr '/' expr
+    9     | • '(' expr ')'
+
+    "end of file"  shift, and go to state 2
+    LF             shift, and go to state 3
+    NUM            shift, and go to state 4
+    '('            shift, and go to state 5
+
+    expr  go to state 6
+
+
+State 2
+
+    0 $accept: list "end of file" •
+
+    $default  accept
+
+
+State 3
+
+    2 list: list LF •
+
+    $default  reduce using rule 2 (list)
+
+
+State 4
+
+    4 expr: NUM •
+
+    $default  reduce using rule 4 (expr)
+
+
+State 5
+
+    4 expr: • NUM
+    5     | • expr '+' expr
+    6     | • expr '-' expr
+    7     | • expr '*' expr
+    8     | • expr '/' expr
+    9     | • '(' expr ')'
+    9     | '(' • expr ')'
+
+    NUM  shift, and go to state 4
+    '('  shift, and go to state 5
+
+    expr  go to state 7
+
+
+State 6
+
+    3 list: list expr • LF
+    5 expr: expr • '+' expr
+    6     | expr • '-' expr
+    7     | expr • '*' expr
+    8     | expr • '/' expr
+
+    LF   shift, and go to state 8
+    '+'  shift, and go to state 9
+    '-'  shift, and go to state 10
+    '*'  shift, and go to state 11
+    '/'  shift, and go to state 12
+
+
+State 7
+
+    5 expr: expr • '+' expr
+    6     | expr • '-' expr
+    7     | expr • '*' expr
+    8     | expr • '/' expr
+    9     | '(' expr • ')'
+
+    '+'  shift, and go to state 9
+    '-'  shift, and go to state 10
+    '*'  shift, and go to state 11
+    '/'  shift, and go to state 12
+    ')'  shift, and go to state 13
+
+
+State 8
+
+    3 list: list expr LF •
+
+    $default  reduce using rule 3 (list)
+
+
+State 9
+
+    4 expr: • NUM
+    5     | • expr '+' expr
+    5     | expr '+' • expr
+    6     | • expr '-' expr
+    7     | • expr '*' expr
+    8     | • expr '/' expr
+    9     | • '(' expr ')'
+
+    NUM  shift, and go to state 4
+    '('  shift, and go to state 5
+
+    expr  go to state 14
+
+
+State 10
+
+    4 expr: • NUM
+    5     | • expr '+' expr
+    6     | • expr '-' expr
+    6     | expr '-' • expr
+    7     | • expr '*' expr
+    8     | • expr '/' expr
+    9     | • '(' expr ')'
+
+    NUM  shift, and go to state 4
+    '('  shift, and go to state 5
+
+    expr  go to state 15
+
+
+State 11
+
+    4 expr: • NUM
+    5     | • expr '+' expr
+    6     | • expr '-' expr
+    7     | • expr '*' expr
+    7     | expr '*' • expr
+    8     | • expr '/' expr
+    9     | • '(' expr ')'
+
+    NUM  shift, and go to state 4
+    '('  shift, and go to state 5
+
+    expr  go to state 16
+
+
+State 12
+
+    4 expr: • NUM
+    5     | • expr '+' expr
+    6     | • expr '-' expr
+    7     | • expr '*' expr
+    8     | • expr '/' expr
+    8     | expr '/' • expr
+    9     | • '(' expr ')'
+
+    NUM  shift, and go to state 4
+    '('  shift, and go to state 5
+
+    expr  go to state 17
+
+
+State 13
+
+    9 expr: '(' expr ')' •
+
+    $default  reduce using rule 9 (expr)
+
+
+State 14
+
+    5 expr: expr • '+' expr
+    5     | expr '+' expr •  [LF, '+', '-', ')']
+    6     | expr • '-' expr
+    7     | expr • '*' expr
+    8     | expr • '/' expr
+
+    '*'  shift, and go to state 11
+    '/'  shift, and go to state 12
+
+    $default  reduce using rule 5 (expr)
+
+    Conflict between rule 5 and token '+' resolved as reduce (%left '+').
+    Conflict between rule 5 and token '-' resolved as reduce (%left '-').
+    Conflict between rule 5 and token '*' resolved as shift ('+' < '*').
+    Conflict between rule 5 and token '/' resolved as shift ('+' < '/').
+
+
+State 15
+
+    5 expr: expr • '+' expr
+    6     | expr • '-' expr
+    6     | expr '-' expr •  [LF, '+', '-', ')']
+    7     | expr • '*' expr
+    8     | expr • '/' expr
+
+    '*'  shift, and go to state 11
+    '/'  shift, and go to state 12
+
+    $default  reduce using rule 6 (expr)
+
+    Conflict between rule 6 and token '+' resolved as reduce (%left '+').
+    Conflict between rule 6 and token '-' resolved as reduce (%left '-').
+    Conflict between rule 6 and token '*' resolved as shift ('-' < '*').
+    Conflict between rule 6 and token '/' resolved as shift ('-' < '/').
+
+
+State 16
+
+    5 expr: expr • '+' expr
+    6     | expr • '-' expr
+    7     | expr • '*' expr
+    7     | expr '*' expr •  [LF, '+', '-', '*', '/', ')']
+    8     | expr • '/' expr
+
+    $default  reduce using rule 7 (expr)
+
+    Conflict between rule 7 and token '+' resolved as reduce ('+' < '*').
+    Conflict between rule 7 and token '-' resolved as reduce ('-' < '*').
+    Conflict between rule 7 and token '*' resolved as reduce (%left '*').
+    Conflict between rule 7 and token '/' resolved as reduce (%left '/').
+
+
+State 17
+
+    5 expr: expr • '+' expr
+    6     | expr • '-' expr
+    7     | expr • '*' expr
+    8     | expr • '/' expr
+    8     | expr '/' expr •  [LF, '+', '-', '*', '/', ')']
+
+    $default  reduce using rule 8 (expr)
+
+    Conflict between rule 8 and token '+' resolved as reduce ('+' < '/').
+    Conflict between rule 8 and token '-' resolved as reduce ('-' < '/').
+    Conflict between rule 8 and token '*' resolved as reduce (%left '*').
+    Conflict between rule 8 and token '/' resolved as reduce (%left '/').
+
+

data/sample/calc.y

@@ -0,0 +1,98 @@
+/*
+ * How to build and run:
+ *
+ * $ lrama -d calc.y -o calc.c && gcc -Wall calc.c -o calc && ./calc
+ * 1
+ * => 1
+ * 1+2*3
+ * => 7
+ * (1+2)*3
+ * => 9
+ *
+ */
+
+%{
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+
+#include "calc.h"
+
+static int yylex(YYSTYPE *val, YYLTYPE *loc);
+static int yyerror(YYLTYPE *loc, const char *str);
+%}
+
+%union {
+    int val;
+}
+%token LF
+%token <val> NUM
+%type <val> expr
+%left '+' '-'
+%left '*' '/'
+
+%%
+
+list : /* empty */
+     | list LF
+     | 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 ')'  { $$ = $2; }
+     ;
+
+%%
+
+static int yylex(YYSTYPE *yylval, YYLTYPE *loc) {
+    int c = getchar();
+    int val;
+
+    switch (c) {
+    case ' ': case '\t':
+        return yylex(yylval, loc);
+
+    case '0': case '1': case '2': case '3': case '4':
+    case '5': case '6': case '7': case '8': case '9':
+        val = c - '0';
+        while (1) {
+            c = getchar();
+            if (isdigit(c)) {
+                val = val * 10 + (c - '0');
+            }
+            else {
+                ungetc(c, stdin);
+                break;
+            }
+        }
+        yylval->val = val;
+        return NUM;
+
+    case '\n':
+        return LF;
+
+    case '+': case '-': case '*': case '/': case '(': case ')':
+        return c;
+
+    case EOF:
+        exit(0);
+
+    default:
+        fprintf(stderr, "unknown character: %c\n", c);
+        exit(1);
+    }
+}
+
+static int yyerror(YYLTYPE *loc, const char *str) {
+    fprintf(stderr, "parse error: %s\n", str);
+    return 0;
+}
+
+int main() {
+    printf("Enter the formula:\n");
+    yyparse();
+    return 0;
+}

data/sig/lrama/bitmap.rbs

@@ -0,0 +1,7 @@
+module Lrama
+  module Bitmap
+    def self.from_array: (Array[int] ary) -> Integer
+
+    def self.to_array: (Integer int) -> Array[Integer]
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lrama
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - Yuichiro Kaneko
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-05-15 00:00:00.000000000 Z
+date: 2023-05-20 00:00:00.000000000 Z
 dependencies: []
 description: LALR (1) parser generator written by Ruby
 email:
@@ -18,6 +18,7 @@ executables:
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/dependabot.yml"
 - ".github/workflows/test.yaml"
 - ".gitignore"
 - ".rspec"
@@ -26,6 +27,7 @@ files:
 - MIT
 - README.md
 - Rakefile
+- Steepfile
 - doc/TODO.md
 - exe/lrama
 - lib/lrama.rb
@@ -37,13 +39,20 @@ files:
 - lib/lrama/lexer.rb
 - lib/lrama/output.rb
 - lib/lrama/parser.rb
+- lib/lrama/parser/token_scanner.rb
 - lib/lrama/report.rb
+- lib/lrama/state.rb
+- lib/lrama/state/reduce.rb
+- lib/lrama/state/shift.rb
 - lib/lrama/states.rb
 - lib/lrama/states_reporter.rb
 - lib/lrama/version.rb
 - lib/lrama/warning.rb
 - lrama.gemspec
+- sample/calc.output
+- sample/calc.y
 - sample/parse.y
+- sig/lrama/bitmap.rbs
 - template/bison/yacc.c
 - template/bison/yacc.h
 homepage: https://github.com/yui-knk/lrama
@@ -65,7 +74,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.1
+rubygems_version: 3.5.0.dev
 signing_key:
 specification_version: 4
 summary: LALR (1) parser generator written by Ruby