lrama 0.5.0 → 0.5.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0a8a1b04a3e761af04029af3e3b74aaaf4fe9a9e2741205f430264ee3399f66c
-  data.tar.gz: a97ec2c2b2007f3bad6cbe5d1b37baa87d520cc3025e82403a9d8a70cddccc8a
+  metadata.gz: 26bcef726eebf61de01200b02250b2aef91ca957df43db5d72e99ae30e320f4e
+  data.tar.gz: 751b62d184806c0cff319bffc4990ad0de9dd143accafdf6bdf1652eb02512b7
 SHA512:
-  metadata.gz: 820bce06aefc235c02995cc957f9e0d9b2e8d588ce7748225896f0d63c319135068da39977be860815276c360a66e3dd6c2132802aa30e3292d706bc6ae7ef9d
-  data.tar.gz: d5c4ec405196bca888c78bf8a16cc9aef47da0f9943d7eee2bf9033c104f9a07fcb07c4cb6aabb3bb49f0e3665bf37932e2206cd9acad925702c30c7124210fb
+  metadata.gz: 02001b5b137d023c4f5ce48c1d9284ce90c5aad2ec269d7ef7a17e6ffa65be9e553e213400fc63d8256c0209908fc4b314de261993442af4a25772449453fbeb
+  data.tar.gz: 76a9f6bac19c0dcbdc6f9e2834d3c437f9fc5eb999d1b45d20362d52a94c9dc74bca3411b681993e28f388374df7f9b8ea7d0f534e53399efb8cc24112f75ea4

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,21 @@ 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 rbs collection install
+      - run: bundle exec steep check
   test-ruby:
     runs-on: ubuntu-20.04
     strategy:
@@ -43,9 +58,7 @@ jobs:
       - run: mkdir -p tool/lrama
         working-directory: ../ruby
       - name: Copy Lrama to ruby/tool
-        run: cp -r exe lib ../ruby/tool/lrama
-        # TODO: Consider how to manage changes on ruby/ruby master and ruby/lrama
-        # run: cp -r exe lib template ../ruby/tool/lrama
+        run: cp -r exe lib template ../ruby/tool/lrama
         working-directory:
       - run: tree tool/lrama
         working-directory: ../ruby
@@ -70,5 +83,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/.gitignore

@@ -1,3 +1,4 @@
+/.gem_rbs_collection/
 /tmp
 .irbrc
 /Gemfile.lock

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 LEGAL.md MIT 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,9 @@
+# D = Steep::Diagnostic
+#
+target :lib do
+  signature "sig"
+
+  check "lib/lrama/bitmap.rb"
+  check "lib/lrama/report.rb"
+  check "lib/lrama/warning.rb"
+end

data/lib/lrama/grammar.rb

@@ -155,18 +155,18 @@ module Lrama
         last_column = ref.last_column
 
         case
-        when ref.number == "$" && ref.type == :dollar # $$
+        when ref.value == "$" && ref.type == :dollar # $$
           # Omit "<>"
           member = tag.s_value[1..-2]
           str = "((*yyvaluep).#{member})"
-        when ref.number == "$" && ref.type == :at # @$
+        when ref.value == "$" && ref.type == :at # @$
           str = "(*yylocationp)"
         when ref.type == :dollar # $n
-          raise "$#{ref.number} can not be used in %printer."
+          raise "$#{ref.value} can not be used in %printer."
         when ref.type == :at # @n
-          raise "@#{ref.number} can not be used in %printer."
+          raise "@#{ref.value} can not be used in %printer."
         else
-          raise "Unexpected. #{code}, #{ref}"
+          raise "Unexpected. #{self}, #{ref}"
         end
 
         t_code[first_column..last_column] = str
@@ -190,22 +190,22 @@ module Lrama
         last_column = ref.last_column
 
         case
-        when ref.number == "$" && ref.type == :dollar # $$
+        when ref.value == "$" && ref.type == :dollar # $$
           # Omit "<>"
           member = ref.tag.s_value[1..-2]
           str = "(yyval.#{member})"
-        when ref.number == "$" && ref.type == :at # @$
+        when ref.value == "$" && ref.type == :at # @$
           str = "(yyloc)"
         when ref.type == :dollar # $n
-          i = -ref.position_in_rhs + ref.number
+          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.number
+          i = -ref.position_in_rhs + ref.value
           str = "(yylsp[#{i}])"
         else
-          raise "Unexpected. #{code}, #{ref}"
+          raise "Unexpected. #{self}, #{ref}"
         end
 
         t_code[first_column..last_column] = str
@@ -226,16 +226,16 @@ module Lrama
         last_column = ref.last_column
 
         case
-        when ref.number == "$" && ref.type == :dollar # $$
+        when ref.value == "$" && ref.type == :dollar # $$
           str = "yylval"
-        when ref.number == "$" && ref.type == :at # @$
+        when ref.value == "$" && ref.type == :at # @$
           str = "yylloc"
         when ref.type == :dollar # $n
-          raise "$#{ref.number} can not be used in initial_action."
+          raise "$#{ref.value} can not be used in initial_action."
         when ref.type == :at # @n
-          raise "@#{ref.number} can not be used in initial_action."
+          raise "@#{ref.value} can not be used in initial_action."
         else
-          raise "Unexpected. #{code}, #{ref}"
+          raise "Unexpected. #{self}, #{ref}"
         end
 
         t_code[first_column..last_column] = str
@@ -247,7 +247,7 @@ module Lrama
 
   # type: :dollar or :at
   # ex_tag: "$<tag>1" (Optional)
-  Reference = Struct.new(:type, :number, :ex_tag, :first_column, :last_column, :referring_symbol, :position_in_rhs, keyword_init: true) do
+  Reference = Struct.new(:type, :value, :ex_tag, :first_column, :last_column, :referring_symbol, :position_in_rhs, keyword_init: true) do
     def tag
       if ex_tag
         ex_tag
@@ -382,8 +382,8 @@ module Lrama
     end
 
     def build_references(token_code)
-      token_code.references.map! do |type, number, tag, first_column, last_column|
-        Reference.new(type: type, number: number, ex_tag: tag, first_column: first_column, last_column: last_column)
+      token_code.references.map! do |type, value, tag, first_column, last_column|
+        Reference.new(type: type, value: value, ex_tag: tag, first_column: first_column, last_column: last_column)
       end
 
       token_code
@@ -627,15 +627,23 @@ module Lrama
               ref.position_in_rhs = i - 1
               next if ref.type == :at
               # $$, $n, @$, @n can be used in any actions
-              number = ref.number
 
-              if number == "$"
+              if ref.value == "$"
                 # TODO: Should be postponed after middle actions are extracted?
                 ref.referring_symbol = lhs
-              else
-                raise "Can not refer following component. #{number} >= #{i}. #{token}" if number >= i
-                rhs1[number - 1].referred = true
-                ref.referring_symbol = rhs1[number - 1]
+              elsif ref.value.is_a?(Integer)
+                raise "Can not refer following component. #{ref.value} >= #{i}. #{token}" if ref.value >= i
+                rhs1[ref.value - 1].referred = true
+                ref.referring_symbol = rhs1[ref.value - 1]
+              elsif ref.value.is_a?(String)
+                target_tokens = ([lhs] + rhs1 + [code]).compact.first(i)
+                referring_symbol_candidate = target_tokens.filter {|token| token.referred_by?(ref.value) }
+                raise "Referring symbol `#{ref.value}` is duplicated. #{token}" if referring_symbol_candidate.size >= 2
+                raise "Referring symbol `#{ref.value}` is not found. #{token}" if referring_symbol_candidate.count == 0
+
+                referring_symbol = referring_symbol_candidate.first
+                referring_symbol.referred = true
+                ref.referring_symbol = referring_symbol
               end
             end
           end
@@ -716,7 +724,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 +852,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

@@ -7,7 +7,7 @@ module Lrama
     include Lrama::Report::Duration
 
     # s_value is semantic value
-    Token = Struct.new(:type, :s_value, keyword_init: true) do
+    Token = Struct.new(:type, :s_value, :alias, keyword_init: true) do
       Type = Struct.new(:id, :name, keyword_init: true)
 
       attr_accessor :line, :column, :referred
@@ -18,6 +18,31 @@ module Lrama
         "#{super} line: #{line}, column: #{column}"
       end
 
+      def referred_by?(string)
+        [self.s_value, self.alias].include?(string)
+      end
+
+      def ==(other)
+        self.class == other.class && self.type == other.type && self.s_value == other.s_value
+      end
+
+      def numberize_references(lhs, rhs)
+        self.references.map! {|ref|
+          ref_name = ref[1]
+          if ref_name.is_a?(String) && ref_name != '$'
+            value =
+              if lhs.referred_by?(ref_name)
+                '$'
+              else
+                rhs.find_index {|token| token.referred_by?(ref_name) } + 1
+              end
+            [ref[0], value, ref[2], ref[3], ref[4]]
+          else
+            ref
+          end
+        }
+      end
+
       @i = 0
       @types = []
 
@@ -47,6 +72,7 @@ module Lrama
       define_type(:Number)           # 0
       define_type(:Ident_Colon)      # k_if:, k_if  : (spaces can be there)
       define_type(:Ident)            # api.pure, tNUMBER
+      define_type(:Named_Ref)        # [foo]
       define_type(:Semicolon)        # ;
       define_type(:Bar)              # |
       define_type(:String)           # "str"
@@ -166,10 +192,15 @@ module Lrama
           tokens << create_token(Token::Number, Integer(ss[0]), line, ss.pos - column)
         when ss.scan(/(<[a-zA-Z0-9_]+>)/)
           tokens << create_token(Token::Tag, ss[0], line, ss.pos - column)
+        when ss.scan(/([a-zA-Z_.][-a-zA-Z0-9_.]*)\[([a-zA-Z_.][-a-zA-Z0-9_.]*)\]\s*:/)
+          tokens << create_token(Token::Ident_Colon, ss[1], line, ss.pos - column)
+          tokens << create_token(Token::Named_Ref, ss[2], line, ss.pos - column)
         when ss.scan(/([a-zA-Z_.][-a-zA-Z0-9_.]*)\s*:/)
           tokens << create_token(Token::Ident_Colon, ss[1], line, ss.pos - column)
         when ss.scan(/([a-zA-Z_.][-a-zA-Z0-9_.]*)/)
           tokens << create_token(Token::Ident, ss[0], line, ss.pos - column)
+        when ss.scan(/\[([a-zA-Z_.][-a-zA-Z0-9_.]*)\]/)
+          tokens << create_token(Token::Named_Ref, ss[1], line, ss.pos - column)
         when ss.scan(/%expect/)
           tokens << create_token(Token::P_expect, ss[0], line, ss.pos - column)
         when ss.scan(/%define/)
@@ -206,6 +237,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 +251,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
@@ -255,6 +288,9 @@ module Lrama
         when ss.scan(/\$(<[a-zA-Z0-9_]+>)?(\d+)/) # $1, $2, $<long>1
           tag = ss[1] ? create_token(Token::Tag, ss[1], line, str.length) : nil
           references << [:dollar, Integer(ss[2]), tag, str.length, str.length + ss[0].length - 1]
+        when ss.scan(/\$(<[a-zA-Z0-9_]+>)?([a-zA-Z_.][-a-zA-Z0-9_.]*)/) # $foo, $expr, $<long>program
+          tag = ss[1] ? create_token(Token::Tag, ss[1], line, str.length) : nil
+          references << [:dollar, ss[2], tag, str.length, str.length + ss[0].length - 1]
         when ss.scan(/@\$/) # @$
           references << [:at, "$", nil, str.length, str.length + ss[0].length - 1]
         when ss.scan(/@(\d)+/) # @1
@@ -276,6 +312,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 +353,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 +374,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,59 @@
+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 previous_token
+        @tokens[@index - 1]
+      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
@@ -226,8 +175,11 @@ module Lrama
       # LHS
       lhs = ts.consume!(T::Ident_Colon) # class:
       lhs.type = T::Ident
+      if named_ref = ts.consume(T::Named_Ref)
+        lhs.alias = named_ref.s_value
+      end
 
-      rhs = parse_grammar_rule_rhs(ts, grammar)
+      rhs = parse_grammar_rule_rhs(ts, grammar, lhs)
 
       grammar.add_rule(lhs: lhs, rhs: rhs, lineno: rhs.first ? rhs.first.line : lhs.line)
 
@@ -237,7 +189,7 @@ module Lrama
           # |
           bar_lineno = ts.current_token.line
           ts.next
-          rhs = parse_grammar_rule_rhs(ts, grammar)
+          rhs = parse_grammar_rule_rhs(ts, grammar, lhs)
           grammar.add_rule(lhs: lhs, rhs: rhs, lineno: rhs.first ? rhs.first.line : bar_lineno)
         when T::Semicolon
           # ;
@@ -256,13 +208,13 @@ module Lrama
       end
     end
 
-    def parse_grammar_rule_rhs(ts, grammar)
+    def parse_grammar_rule_rhs(ts, grammar, lhs)
       a = []
       prec_seen = false
       code_after_prec = false
 
       while true do
-        # TODO: Srting can be here
+        # TODO: String can be here
         case ts.current_type
         when T::Ident
           # keyword_class
@@ -295,9 +247,13 @@ module Lrama
           end
 
           code = ts.current_token
+          code.numberize_references(lhs, a)
           grammar.build_references(code)
           a << code
           ts.next
+        when T::Named_Ref
+          ts.previous_token.alias = ts.current_token.s_value
+          ts.next
         when T::Bar
           # |
           break

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