enclave 0.1.0

data/ext/enclave/mruby/tools/lrama/lib/lrama/lexer/token/user_code.rb

@@ -0,0 +1,83 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+require "strscan"
+
+module Lrama
+  class Lexer
+    class Token
+      class UserCode < Token
+        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]
+
+          until scanner.eos? do
+            case
+            when reference = scan_reference(scanner)
+              references << reference
+            when scanner.scan(/\/\*/)
+              scanner.scan_until(/\*\//)
+            else
+              scanner.getch
+            end
+          end
+
+          references
+        end
+
+        # @rbs (StringScanner scanner) -> Lrama::Grammar::Reference?
+        def scan_reference(scanner)
+          start = scanner.pos
+          case
+          # $ references
+          # It need to wrap an identifier with brackets to use ".-" for identifiers
+          when scanner.scan(/\$(<[a-zA-Z0-9_]+>)?\$/) # $$, $<long>$
+            tag = scanner[1] ? Lrama::Lexer::Token::Tag.new(s_value: scanner[1]) : nil
+            return Lrama::Grammar::Reference.new(type: :dollar, name: "$", ex_tag: tag, first_column: start, last_column: scanner.pos)
+          when scanner.scan(/\$(<[a-zA-Z0-9_]+>)?(\d+)/) # $1, $2, $<long>1
+            tag = scanner[1] ? Lrama::Lexer::Token::Tag.new(s_value: scanner[1]) : nil
+            return Lrama::Grammar::Reference.new(type: :dollar, number: Integer(scanner[2]), index: Integer(scanner[2]), ex_tag: tag, first_column: start, last_column: scanner.pos)
+          when scanner.scan(/\$(<[a-zA-Z0-9_]+>)?([a-zA-Z_][a-zA-Z0-9_]*)/) # $foo, $expr, $<long>program (named reference without brackets)
+            tag = scanner[1] ? Lrama::Lexer::Token::Tag.new(s_value: scanner[1]) : nil
+            return Lrama::Grammar::Reference.new(type: :dollar, name: scanner[2], ex_tag: tag, first_column: start, last_column: scanner.pos)
+          when scanner.scan(/\$(<[a-zA-Z0-9_]+>)?\[([a-zA-Z_.][-a-zA-Z0-9_.]*)\]/) # $[expr.right], $[expr-right], $<long>[expr.right] (named reference with brackets)
+            tag = scanner[1] ? Lrama::Lexer::Token::Tag.new(s_value: scanner[1]) : nil
+            return Lrama::Grammar::Reference.new(type: :dollar, name: scanner[2], ex_tag: tag, first_column: start, last_column: scanner.pos)
+
+          # @ references
+          # It need to wrap an identifier with brackets to use ".-" for identifiers
+          when scanner.scan(/@\$/) # @$
+            return Lrama::Grammar::Reference.new(type: :at, name: "$", first_column: start, last_column: scanner.pos)
+          when scanner.scan(/@(\d+)/) # @1
+            return Lrama::Grammar::Reference.new(type: :at, number: Integer(scanner[1]), index: Integer(scanner[1]), first_column: start, last_column: scanner.pos)
+          when scanner.scan(/@([a-zA-Z][a-zA-Z0-9_]*)/) # @foo, @expr (named reference without brackets)
+            return Lrama::Grammar::Reference.new(type: :at, name: scanner[1], first_column: start, last_column: scanner.pos)
+          when scanner.scan(/@\[([a-zA-Z_.][-a-zA-Z0-9_.]*)\]/) # @[expr.right], @[expr-right]  (named reference with brackets)
+            return Lrama::Grammar::Reference.new(type: :at, name: scanner[1], first_column: start, last_column: scanner.pos)
+
+          # $: references
+          when scanner.scan(/\$:\$/) # $:$
+            return Lrama::Grammar::Reference.new(type: :index, name: "$", first_column: start, last_column: scanner.pos)
+          when scanner.scan(/\$:(\d+)/) # $:1
+            return Lrama::Grammar::Reference.new(type: :index, number: Integer(scanner[1]), first_column: start, last_column: scanner.pos)
+          when scanner.scan(/\$:([a-zA-Z_][a-zA-Z0-9_]*)/) # $:foo, $:expr (named reference without brackets)
+            return Lrama::Grammar::Reference.new(type: :index, name: scanner[1], first_column: start, last_column: scanner.pos)
+          when scanner.scan(/\$:\[([a-zA-Z_.][-a-zA-Z0-9_.]*)\]/) # $:[expr.right], $:[expr-right] (named reference with brackets)
+            return Lrama::Grammar::Reference.new(type: :index, name: scanner[1], first_column: start, last_column: scanner.pos)
+
+          end
+        end
+      end
+    end
+  end
+end

data/ext/enclave/mruby/tools/lrama/lib/lrama/lexer/token.rb

@@ -0,0 +1,70 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+require_relative 'token/char'
+require_relative 'token/ident'
+require_relative 'token/instantiate_rule'
+require_relative 'token/tag'
+require_relative 'token/user_code'
+
+module Lrama
+  class Lexer
+    class Token
+      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
+        @alias_name = alias_name
+        @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)
+      end
+    end
+  end
+end

data/ext/enclave/mruby/tools/lrama/lib/lrama/lexer.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require "strscan"
+
+require_relative "lexer/grammar_file"
+require_relative "lexer/location"
+require_relative "lexer/token"
+
+module Lrama
+  class Lexer
+    attr_reader :head_line, :head_column, :line
+    attr_accessor :status, :end_symbol
+
+    SYMBOLS = ['%{', '%}', '%%', '{', '}', '\[', '\]', '\(', '\)', '\,', ':', '\|', ';'].freeze
+    PERCENT_TOKENS = %w(
+      %union
+      %token
+      %type
+      %nterm
+      %left
+      %right
+      %nonassoc
+      %expect
+      %define
+      %require
+      %printer
+      %destructor
+      %lex-param
+      %parse-param
+      %initial-action
+      %precedence
+      %prec
+      %error-token
+      %before-reduce
+      %after-reduce
+      %after-shift-error-token
+      %after-shift
+      %after-pop-stack
+      %empty
+      %code
+      %rule
+      %no-stdlib
+      %inline
+      %locations
+    ).freeze
+
+    def initialize(grammar_file)
+      @grammar_file = grammar_file
+      @scanner = StringScanner.new(grammar_file.text)
+      @head_column = @head = @scanner.pos
+      @head_line = @line = 1
+      @status = :initial
+      @end_symbol = nil
+    end
+
+    def next_token
+      case @status
+      when :initial
+        lex_token
+      when :c_declaration
+        lex_c_code
+      end
+    end
+
+    def column
+      @scanner.pos - @head
+    end
+
+    def location
+      Location.new(
+        grammar_file: @grammar_file,
+        first_line: @head_line, first_column: @head_column,
+        last_line: line, last_column: column
+      )
+    end
+
+    def lex_token
+      until @scanner.eos? do
+        case
+        when @scanner.scan(/\n/)
+          newline
+        when @scanner.scan(/\s+/)
+          # noop
+        when @scanner.scan(/\/\*/)
+          lex_comment
+        when @scanner.scan(/\/\/.*(?<newline>\n)?/)
+          newline if @scanner[:newline]
+        else
+          break
+        end
+      end
+
+      reset_first_position
+
+      case
+      when @scanner.eos?
+        return
+      when @scanner.scan(/#{SYMBOLS.join('|')}/)
+        return [@scanner.matched, @scanner.matched]
+      when @scanner.scan(/#{PERCENT_TOKENS.join('|')}/)
+        return [@scanner.matched, @scanner.matched]
+      when @scanner.scan(/[\?\+\*]/)
+        return [@scanner.matched, @scanner.matched]
+      when @scanner.scan(/<\w+>/)
+        return [:TAG, Lrama::Lexer::Token::Tag.new(s_value: @scanner.matched, location: location)]
+      when @scanner.scan(/'.'/)
+        return [:CHARACTER, Lrama::Lexer::Token::Char.new(s_value: @scanner.matched, location: location)]
+      when @scanner.scan(/'\\\\'|'\\b'|'\\t'|'\\f'|'\\r'|'\\n'|'\\v'|'\\13'/)
+        return [:CHARACTER, Lrama::Lexer::Token::Char.new(s_value: @scanner.matched, location: location)]
+      when @scanner.scan(/".*?"/)
+        return [:STRING, %Q(#{@scanner.matched})]
+      when @scanner.scan(/\d+/)
+        return [:INTEGER, Integer(@scanner.matched)]
+      when @scanner.scan(/([a-zA-Z_.][-a-zA-Z0-9_.]*)/)
+        token = Lrama::Lexer::Token::Ident.new(s_value: @scanner.matched, location: location)
+        type =
+          if @scanner.check(/\s*(\[\s*[a-zA-Z_.][-a-zA-Z0-9_.]*\s*\])?\s*:/)
+            :IDENT_COLON
+          else
+            :IDENTIFIER
+          end
+        return [type, token]
+      else
+        raise ParseError, "Unexpected token: #{@scanner.peek(10).chomp}."
+      end
+    end
+
+    def lex_c_code
+      nested = 0
+      code = ''
+      reset_first_position
+
+      until @scanner.eos? do
+        case
+        when @scanner.scan(/{/)
+          code += @scanner.matched
+          nested += 1
+        when @scanner.scan(/}/)
+          if nested == 0 && @end_symbol == '}'
+            @scanner.unscan
+            return [:C_DECLARATION, Lrama::Lexer::Token::UserCode.new(s_value: code, location: location)]
+          else
+            code += @scanner.matched
+            nested -= 1
+          end
+        when @scanner.check(/#{@end_symbol}/)
+          return [:C_DECLARATION, Lrama::Lexer::Token::UserCode.new(s_value: code, location: location)]
+        when @scanner.scan(/\n/)
+          code += @scanner.matched
+          newline
+        when @scanner.scan(/".*?"/)
+          code += %Q(#{@scanner.matched})
+          @line += @scanner.matched.count("\n")
+        when @scanner.scan(/'.*?'/)
+          code += %Q(#{@scanner.matched})
+        when @scanner.scan(/[^\"'\{\}\n]+/)
+          code += @scanner.matched
+        when @scanner.scan(/#{Regexp.escape(@end_symbol)}/)
+          code += @scanner.matched
+        else
+          code += @scanner.getch
+        end
+      end
+      raise ParseError, "Unexpected code: #{code}."
+    end
+
+    private
+
+    def lex_comment
+      until @scanner.eos? do
+        case
+        when @scanner.scan_until(/[\s\S]*?\*\//)
+          @scanner.matched.count("\n").times { newline }
+          return
+        when @scanner.scan_until(/\n/)
+          newline
+        end
+      end
+    end
+
+    def reset_first_position
+      @head_line = line
+      @head_column = column
+    end
+
+    def newline
+      @line += 1
+      @head = @scanner.pos
+    end
+  end
+end

data/ext/enclave/mruby/tools/lrama/lib/lrama/logger.rb

@@ -0,0 +1,21 @@
+# 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
+  end
+end

data/ext/enclave/mruby/tools/lrama/lib/lrama/option_parser.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+module Lrama
+  # Handle option parsing for the command line interface.
+  class OptionParser
+    def initialize
+      @options = Options.new
+      @trace = []
+      @report = []
+    end
+
+    def parse(argv)
+      parse_by_option_parser(argv)
+
+      @options.trace_opts = validate_trace(@trace)
+      @options.report_opts = validate_report(@report)
+      @options.grammar_file = argv.shift
+
+      unless @options.grammar_file
+        abort "File should be specified\n"
+      end
+
+      if @options.grammar_file == '-'
+        @options.grammar_file = argv.shift or abort "File name for STDIN should be specified\n"
+      else
+        @options.y = File.open(@options.grammar_file, 'r')
+      end
+
+      if !@report.empty? && @options.report_file.nil? && @options.grammar_file
+        @options.report_file = File.dirname(@options.grammar_file) + "/" + File.basename(@options.grammar_file, ".*") + ".output"
+      end
+
+      if !@options.header_file && @options.header
+        case
+        when @options.outfile
+          @options.header_file = File.dirname(@options.outfile) + "/" + File.basename(@options.outfile, ".*") + ".h"
+        when @options.grammar_file
+          @options.header_file = File.dirname(@options.grammar_file) + "/" + File.basename(@options.grammar_file, ".*") + ".h"
+        end
+      end
+
+      @options
+    end
+
+    private
+
+    def parse_by_option_parser(argv)
+      ::OptionParser.new do |o|
+        o.banner = <<~BANNER
+          Lrama is LALR (1) parser generator written by Ruby.
+
+          Usage: lrama [options] FILE
+        BANNER
+        o.separator ''
+        o.separator 'STDIN mode:'
+        o.separator 'lrama [options] - FILE               read grammar from STDIN'
+        o.separator ''
+        o.separator 'Tuning the Parser:'
+        o.on('-S', '--skeleton=FILE', 'specify the skeleton to use') {|v| @options.skeleton = v }
+        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 }
+        o.on('-d', 'also produce a header file') { @options.header = true }
+        o.on('-r', '--report=REPORTS', Array, 'also produce details on the automaton') {|v| @report = v }
+        o.on_tail ''
+        o.on_tail 'REPORTS is a list of comma-separated words that can include:'
+        o.on_tail '    states                           describe the states'
+        o.on_tail '    itemsets                         complete the core item sets with their closure'
+        o.on_tail '    lookaheads                       explicitly associate lookahead tokens to items'
+        o.on_tail '    solved                           describe shift/reduce conflicts solving'
+        o.on_tail '    counterexamples, cex             generate conflict counterexamples'
+        o.on_tail '    rules                            list unused rules'
+        o.on_tail '    terms                            list unused terminals'
+        o.on_tail '    verbose                          report detailed internal state and analysis results'
+        o.on_tail '    all                              include all the above reports'
+        o.on_tail '    none                             disable all reports'
+        o.on('--report-file=FILE', 'also produce details on the automaton output to a file named FILE') {|v| @options.report_file = v }
+        o.on('-o', '--output=FILE', 'leave output to FILE') {|v| @options.outfile = v }
+        o.on('--trace=TRACES', Array, 'also output trace logs at runtime') {|v| @trace = v }
+        o.on_tail ''
+        o.on_tail 'TRACES is a list of comma-separated words that can include:'
+        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'
+        o.on_tail '    none                             disable all traces'
+        o.on('-v', '--verbose', "same as '--report=state'") {|_v| @report << 'states' }
+        o.separator ''
+        o.separator 'Diagnostics:'
+        o.on('-W', '--warnings', 'report the warnings') {|v| @options.diagnostic = true }
+        o.separator ''
+        o.separator 'Error Recovery:'
+        o.on('-e', 'enable error recovery') {|v| @options.error_recovery = true }
+        o.separator ''
+        o.separator 'Other options:'
+        o.on('-V', '--version', "output version information and exit") {|v| puts "lrama #{Lrama::VERSION}"; exit 0 }
+        o.on('-h', '--help', "display this help and exit") {|v| puts o; exit 0 }
+        o.on_tail
+        o.parse!(argv)
+      end
+    end
+
+    ALIASED_REPORTS = { cex: :counterexamples }.freeze
+    VALID_REPORTS = %i[states itemsets lookaheads solved counterexamples rules terms verbose].freeze
+
+    def validate_report(report)
+      h = { grammar: true }
+      return h if report.empty?
+      return {} if report == ['none']
+      if report == ['all']
+        VALID_REPORTS.each { |r| h[r] = true }
+        return h
+      end
+
+      report.each do |r|
+        aliased = aliased_report_option(r)
+        if VALID_REPORTS.include?(aliased)
+          h[aliased] = true
+        else
+          raise "Invalid report option \"#{r}\"."
+        end
+      end
+
+      return h
+    end
+
+    def aliased_report_option(opt)
+      (ALIASED_REPORTS[opt.to_sym] || opt).to_sym
+    end
+
+    VALID_TRACES = %w[
+      locations scan parse automaton bitsets closure
+      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']
+      all_traces = SUPPORTED_TRACES - %w[only-explicit-rules]
+      if trace == ['all']
+        all_traces.each { |t| h[t.gsub(/-/, '_').to_sym] = true }
+        return h
+      end
+
+      trace.each do |t|
+        if SUPPORTED_TRACES.include?(t)
+          h[t.gsub(/-/, '_').to_sym] = true
+        else
+          raise "Invalid trace option \"#{t}\"."
+        end
+      end
+
+      return h
+    end
+  end
+end

data/ext/enclave/mruby/tools/lrama/lib/lrama/options.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Lrama
+  # Command line options.
+  class Options
+    attr_accessor :skeleton, :header, :header_file,
+                  :report_file, :outfile,
+                  :error_recovery, :grammar_file,
+                  :trace_opts, :report_opts,
+                  :diagnostic, :y, :debug, :define
+
+    def initialize
+      @skeleton = "bison/yacc.c"
+      @define = {}
+      @header = false
+      @header_file = nil
+      @report_file = nil
+      @outfile = "y.tab.c"
+      @error_recovery = false
+      @grammar_file = nil
+      @trace_opts = nil
+      @report_opts = nil
+      @diagnostic = false
+      @y = STDIN
+      @debug = false
+    end
+  end
+end