lrama 0.6.10 → 0.7.0

data/doc/development/compressed_state_table/parse.output

@@ -0,0 +1,174 @@
+Symbol
+
+   -2 EMPTY
+    0 "end of file"
+    1 error
+    2 "invalid token" (undef)
+    3 LF
+    4 NUM
+    5 '+'
+    6 '*'
+    7 '('
+    8 ')'
+    9 $accept # Start of nonterminal
+   10 program
+   11 expr
+
+
+Grammar
+
+    0 $accept: program "end of file"
+
+    1 program: ε
+    2        | expr LF
+
+    3 expr: NUM
+    4     | expr '+' expr
+    5     | expr '*' expr
+    6     | '(' expr ')'
+
+
+State 0
+
+    0 $accept: • program "end of file"
+    1 program: ε •  ["end of file"]
+    2        | • expr LF
+    3 expr: • NUM
+    4     | • expr '+' expr
+    5     | • expr '*' expr
+    6     | • '(' expr ')'
+
+    NUM  shift, and go to state 1
+    '('  shift, and go to state 2
+
+    $default  reduce using rule 1 (program)
+
+    program  go to state 3
+    expr     go to state 4
+
+
+State 1
+
+    3 expr: NUM •
+
+    $default  reduce using rule 3 (expr)
+
+
+State 2
+
+    3 expr: • NUM
+    4     | • expr '+' expr
+    5     | • expr '*' expr
+    6     | • '(' expr ')'
+    6     | '(' • expr ')'
+
+    NUM  shift, and go to state 1
+    '('  shift, and go to state 2
+
+    expr  go to state 5
+
+
+State 3
+
+    0 $accept: program • "end of file"
+
+    "end of file"  shift, and go to state 6
+
+
+State 4
+
+    2 program: expr • LF
+    4 expr: expr • '+' expr
+    5     | expr • '*' expr
+
+    LF   shift, and go to state 7
+    '+'  shift, and go to state 8
+    '*'  shift, and go to state 9
+
+
+State 5
+
+    4 expr: expr • '+' expr
+    5     | expr • '*' expr
+    6     | '(' expr • ')'
+
+    '+'  shift, and go to state 8
+    '*'  shift, and go to state 9
+    ')'  shift, and go to state 10
+
+
+State 6
+
+    0 $accept: program "end of file" •
+
+    $default  accept
+
+
+State 7
+
+    2 program: expr LF •
+
+    $default  reduce using rule 2 (program)
+
+
+State 8
+
+    3 expr: • NUM
+    4     | • expr '+' expr
+    4     | expr '+' • expr
+    5     | • expr '*' expr
+    6     | • '(' expr ')'
+
+    NUM  shift, and go to state 1
+    '('  shift, and go to state 2
+
+    expr  go to state 11
+
+
+State 9
+
+    3 expr: • NUM
+    4     | • expr '+' expr
+    5     | • expr '*' expr
+    5     | expr '*' • expr
+    6     | • '(' expr ')'
+
+    NUM  shift, and go to state 1
+    '('  shift, and go to state 2
+
+    expr  go to state 12
+
+
+State 10
+
+    6 expr: '(' expr ')' •
+
+    $default  reduce using rule 6 (expr)
+
+
+State 11
+
+    4 expr: expr • '+' expr
+    4     | expr '+' expr •  [LF, '+', ')']
+    5     | expr • '*' expr
+
+    '*'  shift, and go to state 9
+
+    $default  reduce using rule 4 (expr)
+
+    Conflict between rule 4 and token '+' resolved as reduce (%left '+').
+    Conflict between rule 4 and token '*' resolved as shift ('+' < '*').
+
+
+State 12
+
+    4 expr: expr • '+' expr
+    5     | expr • '*' expr
+    5     | expr '*' expr •  [LF, '+', '*', ')']
+
+    $default  reduce using rule 5 (expr)
+
+    Conflict between rule 5 and token '+' resolved as reduce ('+' < '*').
+    Conflict between rule 5 and token '*' resolved as reduce (%left '*').
+
+

data/doc/development/compressed_state_table/parse.y

@@ -0,0 +1,22 @@
+%union {
+    int val;
+}
+%token LF
+%token <val> NUM
+%type <val> expr
+%left '+'
+%left '*'
+
+%%
+
+program : /* empty */
+        | expr LF { printf("=> %d\n", $1); }
+        ;
+
+expr    : NUM
+        | expr '+' expr { $$ = $1 + $3; }
+        | expr '*' expr { $$ = $1 * $3; }
+        | '(' expr ')'  { $$ = $2; }
+        ;
+
+%%

data/doc/development/compressed_state_table/parser.rb

@@ -0,0 +1,282 @@
+class Parser
+  YYNTOKENS = 9
+  YYLAST = 13
+  YYTABLE_NINF = -1
+  YYTABLE = [   5,   6,   7,   9,   8,   9,  11,  12,   8,   9,   1,  10,   0,   2]
+  YYCHECK = [   2,   0,   3,   6,   5,   6,   8,   9,   5,   6,   4,   8,  -1,   7]
+
+  YYPACT_NINF = -4
+  YYPACT = [   6,  -4,   6,   1,  -1,   3,  -4,  -4,   6,   6,  -4,  -3,  -4]
+  YYPGOTO = [  -4,  -4,  -2]
+
+  YYDEFACT = [   2,   4,   0,   0,   0,   0,   1,   3,   0,   0,   7,   5,   6]
+  YYDEFGOTO = [   0,   3,   4]
+
+  YYR1 = [   0,   9,  10,  10,  11,  11,  11,  11]
+  YYR2 = [   0,   2,   0,   2,   1,   3,   3,   3]
+
+  YYFINAL = 6
+
+  # Symbols
+  SYM_EMPTY   = -2
+  SYM_EOF     =  0 # "end of file"
+  SYM_ERROR   =  1 # error
+  SYM_UNDEF   =  2 # Invalid Token
+  SYM_LF      =  3 # LF
+  SYM_NUM     =  4 # NUM
+  SYM_PLUS    =  5 # '+'
+  SYM_ASTER   =  6 # '*'
+  SYM_LPAREN  =  7 # '('
+  SYM_RPAREN  =  8 # ')'
+  # Start of nonterminal
+  SYM_ACCEPT  =  9 # $accept
+  SYM_PROGRAM = 10 # program
+  SYM_EXPR    = 11 # expr
+
+  def initialize(debug = false)
+    @debug = debug
+  end
+
+  def parse(lexer)
+    state = 0
+    stack = []
+    yytoken = SYM_EMPTY
+    parser_action = :push_state
+    next_state = nil
+    rule = nil
+
+    while true
+      _parser_action = parser_action
+      parser_action = nil
+
+      case _parser_action
+      when :syntax_error
+        debug_print("Entering :syntax_error")
+
+        return 1
+      when :accept
+        debug_print("Entering :accept")
+
+        return 0
+      when :push_state
+        # Precondition: `state` is set to new state
+        debug_print("Entering :push_state")
+
+        debug_print("Push state #{state}")
+        stack.push(state)
+        debug_print("Current stack #{stack}")
+
+        if state == YYFINAL
+          parser_action = :accept
+          next
+        end
+
+        parser_action = :decide_parser_action
+        next
+      when :decide_parser_action
+        debug_print("Entering :decide_parser_action")
+
+        offset = yypact[state]
+        if offset == YYPACT_NINF
+          parser_action = :yydefault
+          next
+        end
+
+        # Ensure next token
+        if yytoken == SYM_EMPTY
+          debug_print("Reading a token")
+
+          yytoken = lexer.next_token
+        end
+
+        case yytoken
+        when SYM_EOF
+          debug_print("Now at end of input.")
+        when SYM_ERROR
+          parser_action = :syntax_error
+          next
+        else
+          debug_print("Next token is #{yytoken}")
+        end
+
+        idx = offset + yytoken
+        if idx < 0 || YYLAST < idx
+          debug_print("Decide next parser action as :yydefault")
+
+          parser_action = :yydefault
+          next
+        end
+        if yycheck[idx] != yytoken
+          debug_print("Decide next parser action as :yydefault")
+
+          parser_action = :yydefault
+          next
+        end
+
+        action = yytable[idx]
+        if action == YYTABLE_NINF
+          parser_action = :syntax_error
+          next
+        end
+        if action > 0
+          # Shift
+          debug_print("Decide next parser action as :yyshift")
+
+          next_state = action
+          parser_action = :yyshift
+          next
+        else
+          # Reduce
+          debug_print("Decide next parser action as :yyreduce")
+
+          rule = -action
+          parser_action = :yyreduce
+          next
+        end
+      when :yyshift
+        # Precondition: `next_state` is set
+        debug_print("Entering :yyshift")
+        raise "next_state is not set" unless next_state
+
+        yytoken = SYM_EMPTY
+        state = next_state
+        next_state = nil
+        parser_action = :push_state
+        next
+      when :yydefault
+        debug_print("Entering :yydefault")
+
+        rule = yydefact[state]
+        if rule == 0
+          parser_action = :syntax_error
+          next
+        end
+
+        parser_action = :yyreduce
+        next
+      when :yyreduce
+        # Precondition: `rule`, used for reduce, is set
+        debug_print("Entering :yyreduce")
+        raise "rule is not set" unless rule
+
+        rhs_length = yyr2[rule]
+        lhs_nterm = yyr1[rule]
+        lhs_nterm_id = lhs_nterm - YYNTOKENS
+
+        text = "Execute action for Rule (#{rule}) "
+        case rule
+        when 1
+          text << "$accept: program \"end of file\""
+        when 2
+          text << "program: ε"
+        when 3
+          text << "program: expr LF"
+        when 4
+          text << "expr: NUM"
+        when 5
+          text << "expr: expr '+' expr"
+        when 6
+          text << "expr: expr '*' expr"
+        when 7
+          text << "expr: '(' expr ')'"
+        end
+        debug_print(text)
+
+        debug_print("Pop #{rhs_length} elements")
+        debug_print("Stack before pop: #{stack}")
+        stack.pop(rhs_length)
+        debug_print("Stack after pop: #{stack}")
+        state = stack[-1]
+
+        # "Shift" LHS nonterminal
+        offset = yypgoto[lhs_nterm_id]
+        if offset == YYPACT_NINF
+          state = yydefgoto[lhs_nterm_id]
+        else
+          idx = offset + state
+          if idx < 0 || YYLAST < idx
+            state = yydefgoto[lhs_nterm_id]
+          elsif yycheck[idx] != state
+            state = yydefgoto[lhs_nterm_id]
+          else
+            state = yytable[idx]
+          end
+        end
+
+        rule = nil
+        parser_action = :push_state
+        next
+      else
+        raise "Unknown parser_action: #{parser_action}"
+      end
+    end
+  end
+
+  private
+
+  def debug_print(str)
+    if @debug
+      $stderr.puts str
+    end
+  end
+
+  def yytable
+    YYTABLE
+  end
+
+  def yycheck
+    YYCHECK
+  end
+
+  def yypact
+    YYPACT
+  end
+
+  def yypgoto
+    YYPGOTO
+  end
+
+  def yydefact
+    YYDEFACT
+  end
+
+  def yydefgoto
+    YYDEFGOTO
+  end
+
+  def yyr1
+    YYR1
+  end
+
+  def yyr2
+    YYR2
+  end
+end
+
+class Lexer
+  def initialize(tokens)
+    @tokens = tokens
+    @index = 0
+  end
+
+  def next_token
+    if @tokens.length > @index
+      token = @tokens[@index]
+      @index += 1
+      return token
+    else
+      return Parser::SYM_EOF
+    end
+  end
+end
+
+lexer = Lexer.new([
+  # 1 + 2 + 3 LF
+  Parser::SYM_NUM,
+  Parser::SYM_PLUS,
+  Parser::SYM_NUM,
+  Parser::SYM_PLUS,
+  Parser::SYM_NUM,
+  Parser::SYM_LF,
+])
+Parser.new(debug: true).parse(lexer)

data/lib/lrama/bitmap.rb

@@ -1,7 +1,9 @@
+# rbs_inline: enabled
 # frozen_string_literal: true
 
 module Lrama
   module Bitmap
+    # @rbs (Array[Integer] ary) -> Integer
     def self.from_array(ary)
       bit = 0
 
@@ -12,8 +14,9 @@ module Lrama
       bit
     end
 
+    # @rbs (Integer int) -> Array[Integer]
     def self.to_array(int)
-      a = []
+      a = [] #: Array[Integer]
       i = 0
 
       while int > 0 do

data/lib/lrama/command.rb

@@ -19,7 +19,7 @@ module Lrama
       text = options.y.read
       options.y.close if options.y != STDIN
       begin
-        grammar = Lrama::Parser.new(text, options.grammar_file, options.debug).parse
+        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)
@@ -34,6 +34,7 @@ module Lrama
       end
       states = Lrama::States.new(grammar, trace_state: (options.trace_opts[:automaton] || options.trace_opts[:closure]))
       states.compute
+      states.compute_ielr if grammar.ielr_defined?
       context = Lrama::Context.new(states)
 
       if options.report_file

data/lib/lrama/context.rb

@@ -405,7 +405,7 @@ module Lrama
       @check = []
       # Key is froms_and_tos, value is index position
       pushed = {}
-      userd_res = {}
+      used_res = {}
       lowzero = 0
       high = 0
 
@@ -430,7 +430,7 @@ module Lrama
             end
           end
 
-          if ok && userd_res[res]
+          if ok && used_res[res]
             ok = false
           end
 
@@ -458,7 +458,7 @@ module Lrama
 
         @base[state_id] = res
         pushed[froms_and_tos] = res
-        userd_res[res] = true
+        used_res[res] = true
       end
 
       @yylast = high

data/lib/lrama/counterexamples/derivation.rb

@@ -18,7 +18,7 @@ module Lrama
       alias :inspect :to_s
 
       def render_strings_for_report
-        result = []
+        result = [] #: Array[String]
         _render_for_report(self, 0, result, 0)
         result.map(&:rstrip)
       end
@@ -44,18 +44,19 @@ module Lrama
           str << "#{item.next_sym.display_name}"
           length = _render_for_report(derivation.left, len, strings, index + 1)
           # I want String#ljust!
-          str << " " * (length - str.length)
+          str << " " * (length - str.length) if length > str.length
         else
           str << " • #{item.symbols_after_dot.map(&:display_name).join(" ")} "
           return str.length
         end
 
         if derivation.right&.left
-          length = _render_for_report(derivation.right.left, str.length, strings, index + 1)
-          str << "#{item.symbols_after_dot[1..-1].map(&:display_name).join(" ")} "
+          left = derivation.right&.left #: Derivation
+          length = _render_for_report(left, str.length, strings, index + 1)
+          str << "#{item.symbols_after_dot[1..-1].map(&:display_name).join(" ")} " # steep:ignore
           str << " " * (length - str.length) if length > str.length
         elsif item.next_next_sym
-          str << "#{item.symbols_after_dot[1..-1].map(&:display_name).join(" ")} "
+          str << "#{item.symbols_after_dot[1..-1].map(&:display_name).join(" ")} " # steep:ignore
         end
 
         return str.length

data/lib/lrama/counterexamples/example.rb

@@ -38,9 +38,10 @@ module Lrama
       private
 
       def _derivations(paths)
-        derivation = nil
+        derivation = nil #: Derivation
         current = :production
-        lookahead_sym = paths.last.to.item.end_of_rule? ? @conflict_symbol : nil
+        last_path = paths.last #: Path
+        lookahead_sym = last_path.to.item.end_of_rule? ? @conflict_symbol : nil
 
         paths.reverse_each do |path|
           item = path.to.item
@@ -57,12 +58,14 @@ module Lrama
             when ProductionPath
               derivation = Derivation.new(item, derivation)
               current = :production
+            else
+              raise "Unexpected. #{path}"
             end
 
             if lookahead_sym && item.next_next_sym && item.next_next_sym.first_set.include?(lookahead_sym)
               state_item = @counterexamples.transitions[[path.to, item.next_sym]]
               derivation2 = find_derivation_for_symbol(state_item, lookahead_sym)
-              derivation.right = derivation2
+              derivation.right = derivation2 # steep:ignore
               lookahead_sym = nil
             end
 
@@ -89,7 +92,7 @@ module Lrama
       end
 
       def find_derivation_for_symbol(state_item, sym)
-        queue = []
+        queue = [] #: Array[Array[StateItem]]
         queue << [state_item]
 
         while (sis = queue.shift)

data/lib/lrama/counterexamples/path.rb

@@ -20,6 +20,10 @@ module Lrama
         "#<Path(#{type})>"
       end
       alias :inspect :to_s
+
+      def type
+        raise NotImplementedError
+      end
     end
   end
 end