Lrama v0.7.1

Author: yui-knk

tool/lrama/NEWS.md

@@ -4,4 +4,4 @@
 $LOAD_PATH << File.join(__dir__, "../lib")
 require "lrama"
 
-Lrama::Command.new.run(ARGV.dup)
+Lrama::Command.new(ARGV.dup).run

tool/lrama/exe/lrama

@@ -4,19 +4,19 @@
 require_relative "lrama/command"
 require_relative "lrama/context"
 require_relative "lrama/counterexamples"
-require_relative "lrama/diagnostics"
+require_relative "lrama/diagram"
 require_relative "lrama/digraph"
+require_relative "lrama/erb"
 require_relative "lrama/grammar"
-require_relative "lrama/grammar_validator"
 require_relative "lrama/lexer"
 require_relative "lrama/logger"
 require_relative "lrama/option_parser"
 require_relative "lrama/options"
 require_relative "lrama/output"
 require_relative "lrama/parser"
-require_relative "lrama/report"
+require_relative "lrama/reporter"
 require_relative "lrama/state"
 require_relative "lrama/states"
-require_relative "lrama/states_reporter"
-require_relative "lrama/trace_reporter"
+require_relative "lrama/tracer"
 require_relative "lrama/version"
+require_relative "lrama/warnings"

tool/lrama/lib/lrama.rb

@@ -3,7 +3,10 @@
 
 module Lrama
   module Bitmap
-    # @rbs (Array[Integer] ary) -> Integer
+    # @rbs!
+    #   type bitmap = Integer
+
+    # @rbs (Array[Integer] ary) -> bitmap
     def self.from_array(ary)
       bit = 0
 
@@ -14,21 +17,31 @@ def self.from_array(ary)
       bit
     end
 
-    # @rbs (Integer int) -> Array[Integer]
+    # @rbs (Integer int) -> bitmap
+    def self.from_integer(int)
+      1 << int
+    end
+
+    # @rbs (bitmap int) -> Array[Integer]
     def self.to_array(int)
       a = [] #: Array[Integer]
       i = 0
 
-      while int > 0 do
-        if int & 1 == 1
+      len = int.bit_length
+      while i < len do
+        if int[i] == 1
           a << i
         end
 
         i += 1
-        int >>= 1
       end
 
       a
     end
+
+    # @rbs (bitmap int, Integer size) -> Array[bool]
+    def self.to_bool_array(int, size)
+      Array.new(size) { |i| int[i] == 1 }
+    end
   end
 end

tool/lrama/lib/lrama/bitmap.rb

@@ -5,64 +5,116 @@ class Command
     LRAMA_LIB = File.realpath(File.join(File.dirname(__FILE__)))
     STDLIB_FILE_PATH = File.join(LRAMA_LIB, 'grammar', 'stdlib.y')
 
-    def run(argv)
-      begin
-        options = OptionParser.new.parse(argv)
-      rescue => e
-        message = e.message
-        message = message.gsub(/.+/, "\e[1m\\&\e[m") if Exception.to_tty?
-        abort message
-      end
-
-      Report::Duration.enable if options.trace_opts[:time]
+    def initialize(argv)
+      @logger = Lrama::Logger.new
+      @options = OptionParser.parse(argv)
+      @tracer = Tracer.new(STDERR, **@options.trace_opts)
+      @reporter = Reporter.new(**@options.report_opts)
+      @warnings = Warnings.new(@logger, @options.warnings)
+    rescue => e
+      abort format_error_message(e.message)
+    end
 
-      text = options.y.read
-      options.y.close if options.y != STDIN
-      begin
-        grammar = Lrama::Parser.new(text, options.grammar_file, options.debug, options.define).parse
-        unless grammar.no_stdlib
-          stdlib_grammar = Lrama::Parser.new(File.read(STDLIB_FILE_PATH), STDLIB_FILE_PATH, options.debug).parse
-          grammar.insert_before_parameterizing_rules(stdlib_grammar.parameterizing_rules)
+    def run
+      Lrama::Reporter::Profile::CallStack.report(@options.profile_opts[:call_stack]) do
+        Lrama::Reporter::Profile::Memory.report(@options.profile_opts[:memory]) do
+          execute_command_workflow
         end
-        grammar.prepare
-        grammar.validate!
-      rescue => e
-        raise e if options.debug
-        message = e.message
-        message = message.gsub(/.+/, "\e[1m\\&\e[m") if Exception.to_tty?
-        abort message
       end
-      states = Lrama::States.new(grammar, trace_state: (options.trace_opts[:automaton] || options.trace_opts[:closure]))
+    end
+
+    private
+
+    def execute_command_workflow
+      @tracer.enable_duration
+      text = read_input
+      grammar = build_grammar(text)
+      states, context = compute_status(grammar)
+      render_reports(states) if @options.report_file
+      @tracer.trace(grammar)
+      render_diagram(grammar)
+      render_output(context, grammar)
+      states.validate!(@logger)
+      @warnings.warn(grammar, states)
+    end
+
+    def read_input
+      text = @options.y.read
+      @options.y.close unless @options.y == STDIN
+      text
+    end
+
+    def build_grammar(text)
+      grammar =
+        Lrama::Parser.new(text, @options.grammar_file, @options.debug, @options.locations, @options.define).parse
+      merge_stdlib(grammar)
+      prepare_grammar(grammar)
+      grammar
+    rescue => e
+      raise e if @options.debug
+      abort format_error_message(e.message)
+    end
+
+    def format_error_message(message)
+      return message unless Exception.to_tty?
+
+      message.gsub(/.+/, "\e[1m\\&\e[m")
+    end
+
+    def merge_stdlib(grammar)
+      return if grammar.no_stdlib
+
+      stdlib_text = File.read(STDLIB_FILE_PATH)
+      stdlib_grammar = Lrama::Parser.new(
+        stdlib_text,
+        STDLIB_FILE_PATH,
+        @options.debug,
+        @options.locations,
+        @options.define,
+      ).parse
+
+      grammar.prepend_parameterized_rules(stdlib_grammar.parameterized_rules)
+    end
+
+    def prepare_grammar(grammar)
+      grammar.prepare
+      grammar.validate!
+    end
+
+    def compute_status(grammar)
+      states = Lrama::States.new(grammar, @tracer)
       states.compute
       states.compute_ielr if grammar.ielr_defined?
-      context = Lrama::Context.new(states)
+      [states, Lrama::Context.new(states)]
+    end
 
-      if options.report_file
-        reporter = Lrama::StatesReporter.new(states)
-        File.open(options.report_file, "w+") do |f|
-          reporter.report(f, **options.report_opts)
-        end
+    def render_reports(states)
+      File.open(@options.report_file, "w+") do |f|
+        @reporter.report(f, states)
       end
+    end
 
-      reporter = Lrama::TraceReporter.new(grammar)
-      reporter.report(**options.trace_opts)
+    def render_diagram(grammar)
+      return unless @options.diagram
 
-      File.open(options.outfile, "w+") do |f|
+      File.open(@options.diagram_file, "w+") do |f|
+        Lrama::Diagram.render(out: f, grammar: grammar)
+      end
+    end
+
+    def render_output(context, grammar)
+      File.open(@options.outfile, "w+") do |f|
         Lrama::Output.new(
           out: f,
-          output_file_path: options.outfile,
-          template_name: options.skeleton,
-          grammar_file_path: options.grammar_file,
-          header_file_path: options.header_file,
+          output_file_path: @options.outfile,
+          template_name: @options.skeleton,
+          grammar_file_path: @options.grammar_file,
+          header_file_path: @options.header_file,
           context: context,
           grammar: grammar,
-          error_recovery: options.error_recovery,
+          error_recovery: @options.error_recovery,
         ).render
       end
-
-      logger = Lrama::Logger.new
-      exit false unless Lrama::GrammarValidator.new(grammar, states, logger).valid?
-      Lrama::Diagnostics.new(grammar, states, logger).run(options.diagnostic)
     end
   end
 end

tool/lrama/lib/lrama/command.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
-require_relative "report/duration"
+require_relative "tracer/duration"
 
 module Lrama
   # This is passed to a template
   class Context
-    include Report::Duration
+    include Tracer::Duration
 
     ErrorActionNumber = -Float::INFINITY
     BaseMin = -Float::INFINITY
@@ -231,8 +231,8 @@ def compute_yydefact
         end
 
         # Shift is selected when S/R conflict exists.
-        state.selected_term_transitions.each do |shift, next_state|
-          actions[shift.next_sym.number] = next_state.id
+        state.selected_term_transitions.each do |shift|
+          actions[shift.next_sym.number] = shift.to_state.id
         end
 
         state.resolved_conflicts.select do |conflict|
@@ -292,18 +292,18 @@ def compute_yydefgoto
       # of a default nterm transition destination.
       @yydefgoto = Array.new(@states.nterms.count, 0)
       # Mapping from nterm to next_states
-      nterm_to_next_states = {}
+      nterm_to_to_states = {}
 
       @states.states.each do |state|
-        state.nterm_transitions.each do |shift, next_state|
-          key = shift.next_sym
-          nterm_to_next_states[key] ||= []
-          nterm_to_next_states[key] << [state, next_state] # [from_state, to_state]
+        state.nterm_transitions.each do |goto|
+          key = goto.next_sym
+          nterm_to_to_states[key] ||= []
+          nterm_to_to_states[key] << [state, goto.to_state] # [from_state, to_state]
         end
       end
 
       @states.nterms.each do |nterm|
-        if (states = nterm_to_next_states[nterm])
+        if (states = nterm_to_to_states[nterm])
           default_state = states.map(&:last).group_by {|s| s }.max_by {|_, v| v.count }.first
           default_goto = default_state.id
           not_default_gotos = []
@@ -417,27 +417,25 @@ def compute_packed_table
 
         res = lowzero - froms_and_tos.first[0]
 
+        # Find the smallest `res` such that `@table[res + from]` is empty for all `from` in `froms_and_tos`
         while true do
-          ok = true
+          advanced = false
 
-          froms_and_tos.each do |from, to|
-            loc = res + from
-
-            if @table[loc]
-              # If the cell of table is set, can not use the cell.
-              ok = false
-              break
-            end
+          while used_res[res]
+            res += 1
+            advanced = true
           end
 
-          if ok && used_res[res]
-            ok = false
+          froms_and_tos.each do |from, to|
+            while @table[res + from]
+              res += 1
+              advanced = true
+            end
           end
 
-          if ok
+          unless advanced
+            # no advance means that the current `res` satisfies the condition
             break
-          else
-            res += 1
           end
         end