lrama 0.7.0 → 0.7.1

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

@@ -3,12 +3,12 @@
 
 module Lrama
   class Lexer
-    class Token
-      class InstantiateRule < Token
-        attr_reader :args #: Array[Lexer::Token]
+    module Token
+      class InstantiateRule < Base
+        attr_reader :args #: Array[Lexer::Token::Base]
         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
+        # @rbs (s_value: String, ?alias_name: String, ?location: Location, ?args: Array[Lexer::Token::Base], ?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

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

@@ -0,0 +1,14 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+module Lrama
+  class Lexer
+    module Token
+      class Int < Base
+        # @rbs!
+        #   def initialize: (s_value: Integer, ?alias_name: String, ?location: Location) -> void
+        #   def s_value: () -> Integer
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+module Lrama
+  class Lexer
+    module Token
+      class Str < Base
+      end
+    end
+  end
+end

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

@@ -3,8 +3,8 @@
 
 module Lrama
   class Lexer
-    class Token
-      class Tag < Token
+    module Token
+      class Tag < Base
         # @rbs () -> String
         def member
           # Omit "<>"

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

@@ -0,0 +1,11 @@
+# rbs_inline: enabled
+# frozen_string_literal: true
+
+module Lrama
+  class Lexer
+    module Token
+      class Token < Base
+      end
+    end
+  end
+end

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

@@ -5,8 +5,8 @@ require "strscan"
 
 module Lrama
   class Lexer
-    class Token
-      class UserCode < Token
+    module Token
+      class UserCode < Base
         attr_accessor :tag #: Lexer::Token::Tag
 
         # @rbs () -> Array[Lrama::Grammar::Reference]
@@ -38,43 +38,69 @@ module Lrama
         # @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)
+          if scanner.scan(/
+            # $ references
+            # It need to wrap an identifier with brackets to use ".-" for identifiers
+            \$(<[a-zA-Z0-9_]+>)?(?:
+              (\$)                            # $$, $<long>$
+            | (\d+)                           # $1, $2, $<long>1
+            | ([a-zA-Z_][a-zA-Z0-9_]*)        # $foo, $expr, $<long>program (named reference without brackets)
+            | \[([a-zA-Z_.][-a-zA-Z0-9_.]*)\] # $[expr.right], $[expr-right], $<long>[expr.right] (named reference with brackets)
+            )
+          |
+            # @ references
+            # It need to wrap an identifier with brackets to use ".-" for identifiers
+            @(?:
+              (\$)                            # @$
+            | (\d+)                           # @1
+            | ([a-zA-Z_][a-zA-Z0-9_]*)        # @foo, @expr (named reference without brackets)
+            | \[([a-zA-Z_.][-a-zA-Z0-9_.]*)\] # @[expr.right], @[expr-right]  (named reference with brackets)
+            )
+          |
+            # $: references
+            \$:
+            (?:
+              (\$)                            # $:$
+            | (\d+)                           # $:1
+            | ([a-zA-Z_][a-zA-Z0-9_]*)        # $:foo, $:expr (named reference without brackets)
+            | \[([a-zA-Z_.][-a-zA-Z0-9_.]*)\] # $:[expr.right], $:[expr-right] (named reference with brackets)
+            )
+          /x)
+            case
+            # $ references
+            when scanner[2] # $$, $<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[3] # $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[3]), index: Integer(scanner[3]), ex_tag: tag, first_column: start, last_column: scanner.pos)
+            when scanner[4] # $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[4], ex_tag: tag, first_column: start, last_column: scanner.pos)
+            when scanner[5] # $[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[5], ex_tag: tag, 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)
+            # @ references
+            when scanner[6] # @$
+              return Lrama::Grammar::Reference.new(type: :at, name: "$", first_column: start, last_column: scanner.pos)
+            when scanner[7] # @1
+              return Lrama::Grammar::Reference.new(type: :at, number: Integer(scanner[7]), index: Integer(scanner[7]), first_column: start, last_column: scanner.pos)
+            when scanner[8] # @foo, @expr (named reference without brackets)
+              return Lrama::Grammar::Reference.new(type: :at, name: scanner[8], first_column: start, last_column: scanner.pos)
+            when scanner[9] # @[expr.right], @[expr-right]  (named reference with brackets)
+              return Lrama::Grammar::Reference.new(type: :at, name: scanner[9], first_column: start, last_column: scanner.pos)
 
+            # $: references
+            when scanner[10] # $:$
+              return Lrama::Grammar::Reference.new(type: :index, name: "$", first_column: start, last_column: scanner.pos)
+            when scanner[11] # $:1
+              return Lrama::Grammar::Reference.new(type: :index, number: Integer(scanner[11]), index: Integer(scanner[11]), first_column: start, last_column: scanner.pos)
+            when scanner[12] # $:foo, $:expr (named reference without brackets)
+              return Lrama::Grammar::Reference.new(type: :index, name: scanner[12], first_column: start, last_column: scanner.pos)
+            when scanner[13] # $:[expr.right], $:[expr-right] (named reference with brackets)
+              return Lrama::Grammar::Reference.new(type: :index, name: scanner[13], first_column: start, last_column: scanner.pos)
+            end
           end
         end
       end

data/lib/lrama/lexer/token.rb

@@ -1,70 +1,20 @@
 # rbs_inline: enabled
 # frozen_string_literal: true
 
+require_relative 'token/base'
 require_relative 'token/char'
+require_relative 'token/empty'
 require_relative 'token/ident'
 require_relative 'token/instantiate_rule'
+require_relative 'token/int'
+require_relative 'token/str'
 require_relative 'token/tag'
+require_relative 'token/token'
 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
+    module Token
     end
   end
 end

data/lib/lrama/lexer.rb

@@ -1,3 +1,4 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 require "strscan"
@@ -8,10 +9,26 @@ require_relative "lexer/token"
 
 module Lrama
   class Lexer
-    attr_reader :head_line, :head_column, :line
-    attr_accessor :status, :end_symbol
-
-    SYMBOLS = ['%{', '%}', '%%', '{', '}', '\[', '\]', '\(', '\)', '\,', ':', '\|', ';'].freeze
+    # @rbs!
+    #
+    #   type token = lexer_token | c_token
+    #
+    #   type lexer_token = [String, Token::Token]  |
+    #                      [::Symbol, Token::Tag]  |
+    #                      [::Symbol, Token::Char] |
+    #                      [::Symbol, Token::Str]  |
+    #                      [::Symbol, Token::Int]  |
+    #                      [::Symbol, Token::Ident]
+    #
+    #   type c_token = [:C_DECLARATION, Token::UserCode]
+
+    attr_reader :head_line #: Integer
+    attr_reader :head_column #: Integer
+    attr_reader :line #: Integer
+    attr_accessor :status #: :initial | :c_declaration
+    attr_accessor :end_symbol #: String?
+
+    SYMBOLS = ['%{', '%}', '%%', '{', '}', '\[', '\]', '\(', '\)', '\,', ':', '\|', ';'].freeze #: Array[String]
     PERCENT_TOKENS = %w(
       %union
       %token
@@ -42,8 +59,11 @@ module Lrama
       %no-stdlib
       %inline
       %locations
-    ).freeze
+      %categories
+      %start
+    ).freeze #: Array[String]
 
+    # @rbs (GrammarFile grammar_file) -> void
     def initialize(grammar_file)
       @grammar_file = grammar_file
       @scanner = StringScanner.new(grammar_file.text)
@@ -53,6 +73,7 @@ module Lrama
       @end_symbol = nil
     end
 
+    # @rbs () -> token?
     def next_token
       case @status
       when :initial
@@ -62,10 +83,12 @@ module Lrama
       end
     end
 
+    # @rbs () -> Integer
     def column
       @scanner.pos - @head
     end
 
+    # @rbs () -> Location
     def location
       Location.new(
         grammar_file: @grammar_file,
@@ -74,13 +97,14 @@ module Lrama
       )
     end
 
+    # @rbs () -> lexer_token?
     def lex_token
       until @scanner.eos? do
         case
         when @scanner.scan(/\n/)
           newline
         when @scanner.scan(/\s+/)
-          # noop
+          @scanner.matched.count("\n").times { newline }
         when @scanner.scan(/\/\*/)
           lex_comment
         when @scanner.scan(/\/\/.*(?<newline>\n)?/)
@@ -96,11 +120,11 @@ module Lrama
       when @scanner.eos?
         return
       when @scanner.scan(/#{SYMBOLS.join('|')}/)
-        return [@scanner.matched, @scanner.matched]
+        return [@scanner.matched, Lrama::Lexer::Token::Token.new(s_value: @scanner.matched, location: location)]
       when @scanner.scan(/#{PERCENT_TOKENS.join('|')}/)
-        return [@scanner.matched, @scanner.matched]
+        return [@scanner.matched, Lrama::Lexer::Token::Token.new(s_value: @scanner.matched, location: location)]
       when @scanner.scan(/[\?\+\*]/)
-        return [@scanner.matched, @scanner.matched]
+        return [@scanner.matched, Lrama::Lexer::Token::Token.new(s_value: @scanner.matched, location: location)]
       when @scanner.scan(/<\w+>/)
         return [:TAG, Lrama::Lexer::Token::Tag.new(s_value: @scanner.matched, location: location)]
       when @scanner.scan(/'.'/)
@@ -108,9 +132,9 @@ module Lrama
       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})]
+        return [:STRING, Lrama::Lexer::Token::Str.new(s_value: %Q(#{@scanner.matched}), location: location)]
       when @scanner.scan(/\d+/)
-        return [:INTEGER, Integer(@scanner.matched)]
+        return [:INTEGER, Lrama::Lexer::Token::Int.new(s_value: Integer(@scanner.matched), location: location)]
       when @scanner.scan(/([a-zA-Z_.][-a-zA-Z0-9_.]*)/)
         token = Lrama::Lexer::Token::Ident.new(s_value: @scanner.matched, location: location)
         type =
@@ -121,51 +145,53 @@ module Lrama
           end
         return [type, token]
       else
-        raise ParseError, "Unexpected token: #{@scanner.peek(10).chomp}."
+        raise ParseError, location.generate_error_message("Unexpected token") # steep:ignore UnknownConstant
       end
     end
 
+    # @rbs () -> c_token
     def lex_c_code
       nested = 0
-      code = ''
+      code = +''
       reset_first_position
 
       until @scanner.eos? do
         case
         when @scanner.scan(/{/)
-          code += @scanner.matched
+          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
+            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
+          code << @scanner.matched
           newline
         when @scanner.scan(/".*?"/)
-          code += %Q(#{@scanner.matched})
+          code << %Q(#{@scanner.matched})
           @line += @scanner.matched.count("\n")
         when @scanner.scan(/'.*?'/)
-          code += %Q(#{@scanner.matched})
+          code << %Q(#{@scanner.matched})
         when @scanner.scan(/[^\"'\{\}\n]+/)
-          code += @scanner.matched
-        when @scanner.scan(/#{Regexp.escape(@end_symbol)}/)
-          code += @scanner.matched
+          code << @scanner.matched
+        when @scanner.scan(/#{Regexp.escape(@end_symbol)}/) # steep:ignore
+          code << @scanner.matched
         else
-          code += @scanner.getch
+          code << @scanner.getch
         end
       end
-      raise ParseError, "Unexpected code: #{code}."
+      raise ParseError, location.generate_error_message("Unexpected code: #{code}") # steep:ignore UnknownConstant
     end
 
     private
 
+    # @rbs () -> void
     def lex_comment
       until @scanner.eos? do
         case
@@ -178,11 +204,13 @@ module Lrama
       end
     end
 
+    # @rbs () -> void
     def reset_first_position
       @head_line = line
       @head_column = column
     end
 
+    # @rbs () -> void
     def newline
       @line += 1
       @head = @scanner.pos

data/lib/lrama/logger.rb

@@ -8,14 +8,24 @@ module Lrama
       @out = out
     end
 
+    # @rbs () -> void
+    def line_break
+      @out << "\n"
+    end
+
     # @rbs (String message) -> void
-    def warn(message)
+    def trace(message)
       @out << message << "\n"
     end
 
+    # @rbs (String message) -> void
+    def warn(message)
+      @out << 'warning: ' << message << "\n"
+    end
+
     # @rbs (String message) -> void
     def error(message)
-      @out << message << "\n"
+      @out << 'error: ' << message << "\n"
     end
   end
 end

data/lib/lrama/option_parser.rb

@@ -1,3 +1,4 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 require 'optparse'
@@ -5,17 +6,32 @@ require 'optparse'
 module Lrama
   # Handle option parsing for the command line interface.
   class OptionParser
+    # @rbs!
+    #   @options: Lrama::Options
+    #   @trace: Array[String]
+    #   @report: Array[String]
+    #   @profile: Array[String]
+
+    # @rbs (Array[String]) -> Lrama::Options
+    def self.parse(argv)
+      new.parse(argv)
+    end
+
+    # @rbs () -> void
     def initialize
       @options = Options.new
       @trace = []
       @report = []
+      @profile = []
     end
 
+    # @rbs (Array[String]) -> Lrama::Options
     def parse(argv)
       parse_by_option_parser(argv)
 
       @options.trace_opts = validate_trace(@trace)
       @options.report_opts = validate_report(@report)
+      @options.profile_opts = validate_profile(@profile)
       @options.grammar_file = argv.shift
 
       unless @options.grammar_file
@@ -46,6 +62,7 @@ module Lrama
 
     private
 
+    # @rbs (Array[String]) -> void
     def parse_by_option_parser(argv)
       ::OptionParser.new do |o|
         o.banner = <<~BANNER
@@ -60,7 +77,14 @@ module Lrama
         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 "                                     same as '-Dparse.trace'"
+        o.on('--locations', 'enable location support') {|v| @options.locations = true }
+        o.on('-D', '--define=NAME[=VALUE]', Array, "similar to '%define NAME VALUE'") do |v|
+          @options.define = v.each_with_object({}) do |item, hash| # steep:ignore UnannotatedEmptyCollection
+            key, value = item.split('=', 2)
+            hash[key] = value
+          end
+        end
         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 }
@@ -91,10 +115,19 @@ module Lrama
         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('--diagram=[FILE]', 'generate a diagram of the rules') do |v|
+          @options.diagram = true
+          @options.diagram_file = v if v
+        end
+        o.on('--profile=PROFILES', Array, 'profiles parser generation parts') {|v| @profile = v }
+        o.on_tail ''
+        o.on_tail 'PROFILES is a list of comma-separated words that can include:'
+        o.on_tail '    call-stack                       use sampling call-stack profiler (stackprof gem)'
+        o.on_tail '    memory                           use memory profiler (memory_profiler gem)'
         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.on('-W', '--warnings', 'report the warnings') {|v| @options.warnings = true }
         o.separator ''
         o.separator 'Error Recovery:'
         o.on('-e', 'enable error recovery') {|v| @options.error_recovery = true }
@@ -107,9 +140,10 @@ module Lrama
       end
     end
 
-    ALIASED_REPORTS = { cex: :counterexamples }.freeze
-    VALID_REPORTS = %i[states itemsets lookaheads solved counterexamples rules terms verbose].freeze
+    ALIASED_REPORTS = { cex: :counterexamples }.freeze #: Hash[Symbol, Symbol]
+    VALID_REPORTS = %i[states itemsets lookaheads solved counterexamples rules terms verbose].freeze #: Array[Symbol]
 
+    # @rbs (Array[String]) -> Hash[Symbol, bool]
     def validate_report(report)
       h = { grammar: true }
       return h if report.empty?
@@ -131,6 +165,7 @@ module Lrama
       return h
     end
 
+    # @rbs (String) -> Symbol
     def aliased_report_option(opt)
       (ALIASED_REPORTS[opt.to_sym] || opt).to_sym
     end
@@ -139,15 +174,16 @@ module Lrama
       locations scan parse automaton bitsets closure
       grammar rules only-explicit-rules actions resource
       sets muscles tools m4-early m4 skeleton time ielr cex
-    ].freeze
+    ].freeze #: Array[String]
     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
+    ].freeze #: Array[String]
+    SUPPORTED_TRACES = VALID_TRACES - NOT_SUPPORTED_TRACES #: Array[String]
 
+    # @rbs (Array[String]) -> Hash[Symbol, bool]
     def validate_trace(trace)
-      h = {}
+      h = {} #: Hash[Symbol, bool]
       return h if trace.empty? || trace == ['none']
       all_traces = SUPPORTED_TRACES - %w[only-explicit-rules]
       if trace == ['all']
@@ -159,7 +195,25 @@ module Lrama
         if SUPPORTED_TRACES.include?(t)
           h[t.gsub(/-/, '_').to_sym] = true
         else
-          raise "Invalid trace option \"#{t}\"."
+          raise "Invalid trace option \"#{t}\".\nValid options are [#{SUPPORTED_TRACES.join(", ")}]."
+        end
+      end
+
+      return h
+    end
+
+    VALID_PROFILES = %w[call-stack memory].freeze #: Array[String]
+
+    # @rbs (Array[String]) -> Hash[Symbol, bool]
+    def validate_profile(profile)
+      h = {} #: Hash[Symbol, bool]
+      return h if profile.empty?
+
+      profile.each do |t|
+        if VALID_PROFILES.include?(t)
+          h[t.gsub(/-/, '_').to_sym] = true
+        else
+          raise "Invalid profile option \"#{t}\".\nValid options are [#{VALID_PROFILES.join(", ")}]."
         end
       end