lrama 0.6.11 → 0.7.0

data/lib/lrama/grammar.rb

@@ -28,14 +28,14 @@ module Lrama
     attr_reader :percent_codes, :eof_symbol, :error_symbol, :undef_symbol, :accept_symbol, :aux, :parameterizing_rule_resolver
     attr_accessor :union, :expect, :printers, :error_tokens, :lex_param, :parse_param, :initial_action,
                   :after_shift, :before_reduce, :after_reduce, :after_shift_error_token, :after_pop_stack,
-                  :symbols_resolver, :types, :rules, :rule_builders, :sym_to_rules, :no_stdlib, :locations
+                  :symbols_resolver, :types, :rules, :rule_builders, :sym_to_rules, :no_stdlib, :locations, :define
 
     def_delegators "@symbols_resolver", :symbols, :nterms, :terms, :add_nterm, :add_term, :find_term_by_s_value,
                                         :find_symbol_by_number!, :find_symbol_by_id!, :token_to_symbol,
                                         :find_symbol_by_s_value!, :fill_symbol_number, :fill_nterm_type,
                                         :fill_printer, :fill_destructor, :fill_error_token, :sort_by_number!
 
-    def initialize(rule_counter)
+    def initialize(rule_counter, define = {})
       @rule_counter = rule_counter
 
       # Code defined by "%code"
@@ -57,6 +57,7 @@ module Lrama
       @aux = Auxiliary.new
       @no_stdlib = false
       @locations = false
+      @define = define.map {|d| d.split('=') }.to_h
 
       append_special_symbols
     end
@@ -171,6 +172,10 @@ module Lrama
       @sym_to_rules[sym.number]
     end
 
+    def ielr_defined?
+      @define.key?('lr.type') && @define['lr.type'] == 'ielr'
+    end
+
     private
 
     def compute_nullable
@@ -294,7 +299,7 @@ module Lrama
     end
 
     def resolve_inline_rules
-      while @rule_builders.any? {|r| r.has_inline_rules? } do
+      while @rule_builders.any?(&:has_inline_rules?) do
         @rule_builders = @rule_builders.flat_map do |builder|
           if builder.has_inline_rules?
             builder.resolve_inline_rules

data/lib/lrama/lexer/grammar_file.rb

@@ -1,30 +1,37 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 module Lrama
   class Lexer
     class GrammarFile
       class Text < String
+        # @rbs () -> String
         def inspect
           length <= 50 ? super : "#{self[0..47]}...".inspect
         end
       end
 
-      attr_reader :path, :text
+      attr_reader :path #: String
+      attr_reader :text #: String
 
+      # @rbs (String path, String text) -> void
       def initialize(path, text)
         @path = path
         @text = Text.new(text).freeze
       end
 
+      # @rbs () -> String
       def inspect
         "<#{self.class}: @path=#{path}, @text=#{text.inspect}>"
       end
 
+      # @rbs (GrammarFile other) -> bool
       def ==(other)
         self.class == other.class &&
         self.path == other.path
       end
 
+      # @rbs () -> Array[String]
       def lines
         @lines ||= text.split("\n")
       end

data/lib/lrama/lexer/location.rb

@@ -1,10 +1,16 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 module Lrama
   class Lexer
     class Location
-      attr_reader :grammar_file, :first_line, :first_column, :last_line, :last_column
+      attr_reader :grammar_file #: GrammarFile
+      attr_reader :first_line #: Integer
+      attr_reader :first_column #: Integer
+      attr_reader :last_line #: Integer
+      attr_reader :last_column #: Integer
 
+      # @rbs (grammar_file: GrammarFile, first_line: Integer, first_column: Integer, last_line: Integer, last_column: Integer) -> void
       def initialize(grammar_file:, first_line:, first_column:, last_line:, last_column:)
         @grammar_file = grammar_file
         @first_line = first_line
@@ -13,6 +19,7 @@ module Lrama
         @last_column = last_column
       end
 
+      # @rbs (Location other) -> bool
       def ==(other)
         self.class == other.class &&
         self.grammar_file == other.grammar_file &&
@@ -22,6 +29,7 @@ module Lrama
         self.last_column == other.last_column
       end
 
+      # @rbs (Integer left, Integer right) -> Location
       def partial_location(left, right)
         offset = -first_column
         new_first_line = -1
@@ -52,10 +60,12 @@ module Lrama
         )
       end
 
+      # @rbs () -> String
       def to_s
         "#{path} (#{first_line},#{first_column})-(#{last_line},#{last_column})"
       end
 
+      # @rbs (String error_message) -> String
       def generate_error_message(error_message)
         <<~ERROR.chomp
           #{path}:#{first_line}:#{first_column}: #{error_message}
@@ -63,6 +73,7 @@ module Lrama
         ERROR
       end
 
+      # @rbs () -> String
       def line_with_carets
         <<~TEXT
           #{text}
@@ -72,22 +83,27 @@ module Lrama
 
       private
 
+      # @rbs () -> String
       def path
         grammar_file.path
       end
 
+      # @rbs () -> String
       def blanks
         (text[0...first_column] or raise "#{first_column} is invalid").gsub(/[^\t]/, ' ')
       end
 
+      # @rbs () -> String
       def carets
         blanks + '^' * (last_column - first_column)
       end
 
+      # @rbs () -> String
       def text
         @text ||= _text.join("\n")
       end
 
+      # @rbs () -> Array[String]
       def _text
         @_text ||=begin
           range = (first_line - 1)...last_line

data/lib/lrama/lexer/token/char.rb

@@ -1,3 +1,4 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 module Lrama

data/lib/lrama/lexer/token/ident.rb

@@ -1,3 +1,4 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 module Lrama

data/lib/lrama/lexer/token/instantiate_rule.rb

@@ -1,21 +1,26 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 module Lrama
   class Lexer
     class Token
       class InstantiateRule < Token
-        attr_reader :args, :lhs_tag
+        attr_reader :args #: Array[Lexer::Token]
+        attr_reader :lhs_tag #: Lexer::Token::Tag?
 
+        # @rbs (s_value: String, ?alias_name: String, ?location: Location, ?args: Array[Lexer::Token], ?lhs_tag: Lexer::Token::Tag?) -> void
         def initialize(s_value:, alias_name: nil, location: nil, args: [], lhs_tag: nil)
           super s_value: s_value, alias_name: alias_name, location: location
           @args = args
           @lhs_tag = lhs_tag
         end
 
+        # @rbs () -> String
         def rule_name
           s_value
         end
 
+        # @rbs () -> Integer
         def args_count
           args.count
         end

data/lib/lrama/lexer/token/tag.rb

@@ -1,11 +1,13 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 module Lrama
   class Lexer
     class Token
       class Tag < Token
-        # Omit "<>"
+        # @rbs () -> String
         def member
+          # Omit "<>"
           s_value[1..-2] or raise "Unexpected Tag format (#{s_value})"
         end
       end

data/lib/lrama/lexer/token/user_code.rb

@@ -1,3 +1,4 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 require "strscan"
@@ -6,14 +7,16 @@ module Lrama
   class Lexer
     class Token
       class UserCode < Token
-        attr_accessor :tag
+        attr_accessor :tag #: Lexer::Token::Tag
 
+        # @rbs () -> Array[Lrama::Grammar::Reference]
         def references
           @references ||= _references
         end
 
         private
 
+        # @rbs () -> Array[Lrama::Grammar::Reference]
         def _references
           scanner = StringScanner.new(s_value)
           references = [] #: Array[Grammar::Reference]
@@ -32,6 +35,7 @@ module Lrama
           references
         end
 
+        # @rbs (StringScanner scanner) -> Lrama::Grammar::Reference?
         def scan_reference(scanner)
           start = scanner.pos
           case

data/lib/lrama/lexer/token.rb

@@ -1,3 +1,4 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 require_relative 'token/char'
@@ -9,9 +10,12 @@ require_relative 'token/user_code'
 module Lrama
   class Lexer
     class Token
-      attr_reader :s_value, :location
-      attr_accessor :alias_name, :referred
+      attr_reader :s_value #: String
+      attr_reader :location #: Location
+      attr_accessor :alias_name #: String
+      attr_accessor :referred #: bool
 
+      # @rbs (s_value: String, ?alias_name: String, ?location: Location) -> void
       def initialize(s_value:, alias_name: nil, location: nil)
         s_value.freeze
         @s_value = s_value
@@ -19,36 +23,44 @@ module Lrama
         @location = location
       end
 
+      # @rbs () -> String
       def to_s
         "value: `#{s_value}`, location: #{location}"
       end
 
+      # @rbs (String string) -> bool
       def referred_by?(string)
         [self.s_value, self.alias_name].compact.include?(string)
       end
 
+      # @rbs (Token other) -> bool
       def ==(other)
         self.class == other.class && self.s_value == other.s_value
       end
 
+      # @rbs () -> Integer
       def first_line
         location.first_line
       end
       alias :line :first_line
 
+      # @rbs () -> Integer
       def first_column
         location.first_column
       end
       alias :column :first_column
 
+      # @rbs () -> Integer
       def last_line
         location.last_line
       end
 
+      # @rbs () -> Integer
       def last_column
         location.last_column
       end
 
+      # @rbs (Lrama::Grammar::Reference ref, String message) -> bot
       def invalid_ref(ref, message)
         location = self.location.partial_location(ref.first_column, ref.last_column)
         raise location.generate_error_message(message)

data/lib/lrama/lexer.rb

@@ -169,12 +169,11 @@ module Lrama
     def lex_comment
       until @scanner.eos? do
         case
-        when @scanner.scan(/\n/)
-          newline
-        when @scanner.scan(/\*\//)
+        when @scanner.scan_until(/[\s\S]*?\*\//)
+          @scanner.matched.count("\n").times { newline }
           return
-        else
-          @scanner.getch
+        when @scanner.scan_until(/\n/)
+          newline
         end
       end
     end

data/lib/lrama/logger.rb

@@ -1,15 +1,19 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 module Lrama
   class Logger
+    # @rbs (IO out) -> void
     def initialize(out = STDERR)
       @out = out
     end
 
+    # @rbs (String message) -> void
     def warn(message)
       @out << message << "\n"
     end
 
+    # @rbs (String message) -> void
     def error(message)
       @out << message << "\n"
     end

data/lib/lrama/option_parser.rb

@@ -59,8 +59,8 @@ module Lrama
         o.separator ''
         o.separator 'Tuning the Parser:'
         o.on('-S', '--skeleton=FILE', 'specify the skeleton to use') {|v| @options.skeleton = v }
-        o.on('-t', 'reserved, do nothing') { }
-        o.on('--debug', 'display debugging outputs of internal parser') {|v| @options.debug = true }
+        o.on('-t', '--debug', 'display debugging outputs of internal parser') {|v| @options.debug = true }
+        o.on('-D', '--define=NAME[=VALUE]', Array, "similar to '%define NAME VALUE'") {|v| @options.define = v }
         o.separator ''
         o.separator 'Output:'
         o.on('-H', '--header=[FILE]', 'also produce a header file named FILE') {|v| @options.header = true; @options.header_file = v }
@@ -86,6 +86,7 @@ module Lrama
         o.on_tail '    automaton                        display states'
         o.on_tail '    closure                          display states'
         o.on_tail '    rules                            display grammar rules'
+        o.on_tail '    only-explicit-rules              display only explicit grammar rules'
         o.on_tail '    actions                          display grammar rules with actions'
         o.on_tail '    time                             display generation time'
         o.on_tail '    all                              include all the above traces'
@@ -136,26 +137,27 @@ module Lrama
 
     VALID_TRACES = %w[
       locations scan parse automaton bitsets closure
-      grammar rules actions resource sets muscles
-      tools m4-early m4 skeleton time ielr cex
+      grammar rules only-explicit-rules actions resource
+      sets muscles tools m4-early m4 skeleton time ielr cex
     ].freeze
     NOT_SUPPORTED_TRACES = %w[
       locations scan parse bitsets grammar resource
       sets muscles tools m4-early m4 skeleton ielr cex
     ].freeze
+    SUPPORTED_TRACES = VALID_TRACES - NOT_SUPPORTED_TRACES
 
     def validate_trace(trace)
       h = {}
       return h if trace.empty? || trace == ['none']
-      supported = VALID_TRACES - NOT_SUPPORTED_TRACES
+      all_traces = SUPPORTED_TRACES - %w[only-explicit-rules]
       if trace == ['all']
-        supported.each { |t| h[t.to_sym] = true }
+        all_traces.each { |t| h[t.gsub(/-/, '_').to_sym] = true }
         return h
       end
 
       trace.each do |t|
-        if supported.include?(t)
-          h[t.to_sym] = true
+        if SUPPORTED_TRACES.include?(t)
+          h[t.gsub(/-/, '_').to_sym] = true
         else
           raise "Invalid trace option \"#{t}\"."
         end

data/lib/lrama/options.rb

@@ -7,10 +7,11 @@ module Lrama
                   :report_file, :outfile,
                   :error_recovery, :grammar_file,
                   :trace_opts, :report_opts,
-                  :diagnostic, :y, :debug
+                  :diagnostic, :y, :debug, :define
 
     def initialize
       @skeleton = "bison/yacc.c"
+      @define = {}
       @header = false
       @header_file = nil
       @report_file = nil

data/lib/lrama/parser.rb

@@ -658,17 +658,18 @@ module_eval(<<'...end parser.y/module_eval...', 'parser.y', 428)
 
 include Lrama::Report::Duration
 
-def initialize(text, path, debug = false)
+def initialize(text, path, debug = false, define = {})
   @grammar_file = Lrama::Lexer::GrammarFile.new(path, text)
   @yydebug = debug
   @rule_counter = Lrama::Grammar::Counter.new(0)
   @midrule_action_counter = Lrama::Grammar::Counter.new(1)
+  @define = define
 end
 
 def parse
   report_duration(:parse) do
     @lexer = Lrama::Lexer.new(@grammar_file)
-    @grammar = Lrama::Grammar.new(@rule_counter)
+    @grammar = Lrama::Grammar.new(@rule_counter, @define)
     @precedence_number = 0
     reset_precs
     do_parse
@@ -914,7 +915,7 @@ racc_reduce_table = [
   2, 73, :_reduce_15,
   1, 60, :_reduce_none,
   2, 60, :_reduce_17,
-  3, 60, :_reduce_none,
+  3, 60, :_reduce_18,
   2, 60, :_reduce_none,
   2, 60, :_reduce_20,
   2, 60, :_reduce_21,
@@ -1328,7 +1329,12 @@ module_eval(<<'.,.,', 'parser.y', 26)
   end
 .,.,
 
-# reduce 18 omitted
+module_eval(<<'.,.,', 'parser.y', 27)
+  def _reduce_18(val, _values, result)
+     @grammar.define[val[1].s_value] = val[2]&.s_value
+    result
+  end
+.,.,
 
 # reduce 19 omitted