lrama 0.6.10 → 0.6.11

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

@@ -13,7 +13,7 @@ module Lrama
     end
 
     def self.to_array(int)
-      a = []
+      a = [] #: Array[Integer]
       i = 0
 
       while int > 0 do

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

data/lib/lrama/counterexamples.rb

@@ -32,8 +32,10 @@ module Lrama
       conflict_state.conflicts.flat_map do |conflict|
         case conflict.type
         when :shift_reduce
+          # @type var conflict: State::ShiftReduceConflict
           shift_reduce_example(conflict_state, conflict)
         when :reduce_reduce
+          # @type var conflict: State::ReduceReduceConflict
           reduce_reduce_examples(conflict_state, conflict)
         end
       end.compact
@@ -48,7 +50,7 @@ module Lrama
       @reverse_transitions = {}
 
       @states.states.each do |src_state|
-        trans = {}
+        trans = {} #: Hash[Grammar::Symbol, State]
 
         src_state.transitions.each do |shift, next_state|
           trans[shift.next_sym] = next_state
@@ -66,6 +68,7 @@ module Lrama
 
             @transitions[[src_state_item, sym]] = dest_state_item
 
+            # @type var key: [StateItem, Grammar::Symbol]
             key = [dest_state_item, sym]
             @reverse_transitions[key] ||= Set.new
             @reverse_transitions[key] << src_state_item
@@ -82,7 +85,7 @@ module Lrama
 
       @states.states.each do |state|
         # LHS => Set(Item)
-        h = {}
+        h = {} #: Hash[Grammar::Symbol, Set[States::Item]]
 
         state.closure.each do |item|
           sym = item.lhs
@@ -97,6 +100,7 @@ module Lrama
 
           sym = item.next_sym
           state_item = StateItem.new(state, item)
+          # @type var key: [State, Grammar::Symbol]
           key = [state, sym]
 
           @productions[state_item] = h[sym]
@@ -109,6 +113,7 @@ module Lrama
 
     def shift_reduce_example(conflict_state, conflict)
       conflict_symbol = conflict.symbols.first
+      # @type var shift_conflict_item: ::Lrama::States::Item
       shift_conflict_item = conflict_state.items.find { |item| item.next_sym == conflict_symbol }
       path2 = shortest_path(conflict_state, conflict.reduce.item, conflict_symbol)
       path1 = find_shift_conflict_shortest_path(path2, conflict_state, shift_conflict_item)
@@ -153,12 +158,14 @@ module Lrama
         prev_state_item = prev_path&.to
 
         if target_state_item == state_item || target_state_item.item.start_item?
-          result.concat(reversed_reduce_path[_j..-1].map(&:to))
+          result.concat(
+            reversed_reduce_path[_j..-1] #: Array[StartPath|TransitionPath|ProductionPath]
+              .map(&:to))
           break
         end
 
         if target_state_item.item.beginning_of_rule?
-          queue = []
+          queue = [] #: Array[Array[StateItem]]
           queue << [target_state_item]
 
           # Find reverse production
@@ -174,15 +181,17 @@ module Lrama
             end
 
             if si.item.beginning_of_rule?
+              # @type var key: [State, Grammar::Symbol]
               key = [si.state, si.item.lhs]
               @reverse_productions[key].each do |item|
                 state_item = StateItem.new(si.state, item)
                 queue << (sis + [state_item])
               end
             else
+              # @type var key: [StateItem, Grammar::Symbol]
               key = [si, si.item.previous_sym]
               @reverse_transitions[key].each do |prev_target_state_item|
-                next if prev_target_state_item.state != prev_state_item.state
+                next if prev_target_state_item.state != prev_state_item&.state
                 sis.shift
                 result.concat(sis)
                 result << prev_target_state_item
@@ -195,9 +204,10 @@ module Lrama
           end
         else
           # Find reverse transition
+          # @type var key: [StateItem, Grammar::Symbol]
           key = [target_state_item, target_state_item.item.previous_sym]
           @reverse_transitions[key].each do |prev_target_state_item|
-            next if prev_target_state_item.state != prev_state_item.state
+            next if prev_target_state_item.state != prev_state_item&.state
             result << prev_target_state_item
             target_state_item = prev_target_state_item
             i = j
@@ -224,9 +234,9 @@ module Lrama
 
     def shortest_path(conflict_state, conflict_reduce_item, conflict_term)
       # queue: is an array of [Triple, [Path]]
-      queue = []
-      visited = {}
-      start_state = @states.states.first
+      queue = [] #: Array[[Triple, Array[StartPath|TransitionPath|ProductionPath]]]
+      visited = {} #: Hash[Triple, true]
+      start_state = @states.states.first #: Lrama::State
       raise "BUG: Start state should be just one kernel." if start_state.kernels.count != 1
 
       start = Triple.new(start_state, start_state.kernels.first, Set.new([@states.eof_symbol]))