depager 0.2.3 → 0.3.0.b20160729

data/lib/depager/parser.rb

@@ -1,277 +1,282 @@
-module Depager; end
-#
-# Token
-# 
-class Depager::Token
-  def self.[] *args
-    self.new(*args)
-  end
-  attr_accessor :value, :lineno, :filename
-  def initialize value, lineno=nil, filename=nil
-    @value = value
-    @lineno = lineno
-    @filename = filename
-  end
-  def [](n)
-    case n
-    when 0 ; @value
-    when 1 ; @lineno
-    when 2 ; @filename
-    else   ; nil
-    end
-  end
-  def to_s
-    "#{@value.inspect}:#{@lineno}@#{@filename}"
-  end
-  def inspect
-    "#<#{self.class.name}:0x#{object_id.to_s(16)}" <<
-      " #{@value.inspect}:#{@lineno}@#{@filename}>"
-  end
-end
-
-# LALR runtime
-module Depager::LALR
-  # = Parser runtime
-  # == Stack
-  # s::  state
-  # la:: look ahead
-  # v::  value
-  #                                stack top->
-  #   [0, [la0, v0], s0, [la1, v1], s1, .....]
-  #
-  class Parser
-    ACC = 0x03ffffff
-
-    # parse method
-    def parse f
-      @basis.file = f
-      @basis.la = [0, nil]
-      @basis.lex do |sym, val|
-        @basis.la = [@basis.t2i[sym] || @basis.t2i[false], val]
-        break if driver
-      end
-      @basis.stack[1][2..(@basis.params.size+1)]
-    end
-
-    protected
-    # driver method
-    def driver
-      while true
-        @basis.val = @basis.action_table[@basis.stack.last][@basis.la[0]]
-        @basis.val ||= @basis.defred_table[@basis.stack.last]
-        
-        if @basis.val == nil
-          #warn "#{@basis.stack}#{@basis.la[0]}"
-          error
-          exit 1
-        elsif @basis.val == ACC
-          if @i2t[@basis.la[0]] == nil
-            accept
-          else
-            error          
-          end
-          return true
-        elsif @basis.val > 0
-          shift
-          while val = @basis.defred_after_shift_table[@basis.stack.last]
-            @basis.val = val
-            reduce
-          end
-          return false
-        else
-          reduce
-        end
-      end
-    end
-
-    def enable?(act, sym)
-      case act
-      when :shift
-        la = @basis.t2i[sym] || @basis.t2i[false]
-        val = @basis.action_table[@basis.stack.last][la]
-      else
-      end
-    end
-
-    def enables(act, sym)
-      case act
-      when :shift
-        la = @basis.t2i[sym] || @basis.t2i[false]
-        res = []
-        @basis.action_table.each_with_index{|i, x|
-          i[la] and res.push(x)
-        }
-        return res
-      else
-      end
-    end
-
-    # template methods
-    def init_parser ; end
-    def lex ; end
-    def accept ; end
-    def error  ; end
-    def shift  ; end
-    def reduce ; end
-  end
-
-  class Basis < Parser
-    attr_accessor :state, :stack, :laq, :la, :val, :basis, :params
-    attr_accessor :file, :oldline, :lineno, :line, :line0
-    attr_reader :action_table, :defred_table, :defred_after_shift_table
-    attr_reader :goto_table, :reduce_table
-    attr_reader :i2t, :t2i, :nt2i, :i2nt
-
-    private
-    def __init_parser__
-      @state = 0
-      @stack = [@state]
-      @laq = []
-      @la = nil
-      @val = nil
-      @line0 = @line = ''
-    end
-
-    def initialize
-      __init_parser__
-      @file = nil
-      @basis = self
-      @reduce_table, @params, @action_table,
-        @defred_table, @defred_after_shift_table, @goto_table,
-        @t2i, @i2t, @nt2i, @i2nt = self.class::Tables
-    end
-
-    def token sym, val=nil, lineno=nil
-      lineno ||= file.lineno
-      return sym, Depager::Token[val, lineno, file.path]
-    end
-
-    public
-    def banner
-      self.class.name
-    end
-
-    def getline
-      @file.gets unless @file.eof?
-    end
-
-    def accept
-      #warn "acc."
-    end
-    def error
-      fname = @file.respond_to?(:path) ? @file.path : '-'
-      exp = []
-      @action_table[@stack.last].each_with_index do |i, x|
-        exp << @i2t[x] if i
-      end
-      la  = @la[1].value rescue @la[1]
-      la  = (@i2t[@la[0]] || la).inspect
-      exp = exp.map{|i| i ? i.inspect : '$' }.join(', ')
-      warn "#{fname}:#{@file.lineno}: syntax error(#{self.banner}), " <<
-        "unexpected #{la}, expecting #{exp}."
-      warn @stack.pretty_inspect if $MP_DEBUG
-    end
-    def shift
-      @stack.push(@la).push(@val)
-    end
-    def reduce
-      (@reduce_table[-@val][1] * 2).times{@stack.pop}
-      r = @reduce_table[-@val][0]
-      cs = @goto_table[@stack.last][r]
-      @stack.push([r, :NT]).push(cs)
-    end
-  end
-
-  #
-  # Decorator Base class
-  #
-  class AdvancedParser < Parser
-    attr_reader :basis
-    attr_reader :action_table, :goto_table, :reduce_table
-    attr_reader :i2t, :t2i, :nt2i, :i2nt
-    def initialize inside, paramkey = nil
-      @inside = inside
-      @basis = @inside.basis
-      @reduce_table, @params, @action_table, @defred_table, @goto_table, 
-        @t2i, @i2t, @nt2i, @i2nt = @basis.class::Tables
-      @nparam = @params[paramkey]
-    end
-
-    protected
-    def _state
-      @basis.state
-    end
-    def _stack
-      @basis.stack
-    end
-    def _lookaheadque
-      @basis.laq
-    end
-    def _lookahead
-      @basis.la
-    end
-    def _actvalue
-      @basis.val
-    end
-
-    def accept
-      before_accept
-      @inside.accept
-      after_accept
-    end
-    def error
-      before_error
-      @inside.error
-      after_error
-    end
-    def shift
-      before_shift
-      @inside.shift
-      after_shift
-    end
-    def reduce
-      before_reduce
-      @inside.reduce
-      after_reduce
-    end
-
-    # template methods
-    def before_accept ; end
-    def after_accept  ; end
-    def before_error  ; end    
-    def after_error   ; end
-    def before_shift  ; end
-    def after_shift   ; end
-    def before_reduce ; end
-    def after_reduce  ; end
-  end
-
-  #
-  # Action Decorator Base class
-  #
-  class Action < AdvancedParser
-    def initialize inside, nparamkey=nil
-      super inside, nparamkey
-      @_yy_val_ = []
-    end
-    def before_reduce
-      @_yy_val_ = []
-      n = @reduce_table[-_actvalue][1]
-      n.times do |i|
-        x = _stack[_stack.size-2*(i+1)]
-        @_yy_val_[n-i-1] = x[1] == :NT ? x[@nparam] : x[1]
-      end
-    end
-    def after_reduce
-      mes = @on_reduce[-_actvalue]
-      r = mes ? self.send(mes, @_yy_val_) : nil
-      _stack[_stack.size-2][@nparam] = r
-    end
-  end
-end
-
-class IO
-  def path
-    self.to_s
-  end
-end
+# -*- coding: utf-8 -*-
+lib = File.expand_path("../ruby", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+module Depager
+  class Token
+    attr_accessor :value, :lineno, :filename
+
+    def initialize value, lineno=nil, filename=nil
+      @value = value
+      @lineno = lineno
+      @filename = filename
+    end
+
+    def to_s
+      "#{@value.inspect}:#{@lineno}@#{@filename}"
+    end
+
+    def inspect
+      "<#{@value.inspect}:#{@lineno}>"
+    end
+  end
+
+  module LALR
+    # = Parser runtime
+    # == Stack
+    # s::  state
+    # la:: look ahead
+    # v::  value
+    #                                stack top->
+    #   [0, [la0, v0], s0, [la1, v1], s1, .....]
+    #
+    class Parser
+      ACC = 0x03ffffff
+
+      attr_reader :action_table, :defred_table, :defred_after_shift_table
+      attr_reader :goto_table, :reduce_table
+      attr_reader :int_to_term, :term_to_int, :nonterm_to_int, :int_to_nonterm
+
+      def initialize
+        @reduce_table,
+        @action_table,
+        @defred_table,
+        @defred_after_shift_table,
+        @goto_table,
+        @term_to_int,
+        @int_to_term,
+        @nonterm_to_int,
+        @int_to_nonterm = basis.class::Tables
+      end
+
+      def parse f, line = ''
+        basis.__send__ :internal_initialize, f, line, [0, nil]
+
+        do_hook :before_parse
+        lex do |sym, val|
+          basis.lookahead = [term_to_int[sym] || term_to_int[false], val]
+          break if driver
+        end
+        do_hook :after_parse
+
+        stack[1][2..basis.parser_size]
+      end
+
+      def accept
+      end
+
+      def error
+      end
+
+      def shift
+      end
+
+      def reduce
+      end
+
+      def stack
+        basis.stack
+      end
+
+      def lookahead
+        basis.lookahead
+      end
+
+      def action_value
+        basis.action_value
+      end
+
+      protected
+      def lex &block
+        basis.lex &block
+      end
+
+      def driver
+        while true
+          basis.action_value = action_table[stack.last][lookahead[0]] || defred_table[stack.last]
+
+          if action_value == nil
+            error
+            exit 1
+          elsif action_value == ACC
+            if int_to_term[lookahead[0]] == nil
+              accept
+            else
+              error
+            end
+            return true
+          elsif action_value > 0
+            shift
+            while v = defred_after_shift_table[stack.last]
+              basis.action_value = v
+              reduce
+            end
+            return false
+          else
+            reduce
+          end
+        end
+      end
+
+      def do_hook hook
+        if @basis == self
+          send hook
+        elsif hook.to_s.match(/^before_/)
+          send hook
+          @inside.do_hook hook
+        else
+          @inside.do_hook hook
+          send hook
+        end
+      end
+
+      private
+      def before_parse
+      end
+
+      def after_parse
+      end
+    end
+
+    class Basis < Parser
+      attr_reader   :basis, :file, :line, :parser_size
+      attr_accessor :lookahead, :action_value, :stack
+
+      def initialize
+        @basis = self
+        @parser_size = 1
+        super()
+      end
+
+      def banner
+        self.class.name
+      end
+
+      def get_decorator_index
+        @parser_size += 1
+      end
+
+      def accept
+      end
+
+      def error
+        path = file.respond_to?(:path) ? file.path : '-'
+        exp  = []
+        action_table[stack.last].each_with_index do |i, x|
+          exp << int_to_term[x] if i
+        end
+        la  = lookahead[1].value rescue lookahead[1]
+        la  = (int_to_term[lookahead[0]] || la).inspect
+        exp = exp.map{|i| i ? i.inspect : '$' }.join(', ')
+        warn "#{path}:#{file.lineno}: syntax error(#{banner}), unexpected #{la}, expecting #{exp}."
+        warn @stack.pretty_inspect if Depager.debug_mode?
+      end
+
+      def shift
+        stack << lookahead << action_value
+      end
+
+      def reduce
+        r, x = reduce_table[-action_value]
+        (x * 2).times{ stack.pop }
+        v = goto_table[stack.last][r]
+        stack << [r, :NT] << v
+      end
+
+      private
+      def internal_initialize file, line, lookahead
+        @stack, @action_value, @file, @line, @lookahead =
+          [0], nil, file, line, lookahead
+      end
+
+      def token sym, value = nil, lineno = nil
+        lineno ||= file.lineno
+        path     = file.respond_to?(:path) ? file.path : '-'
+        return sym, Depager::Token.new(value, lineno, path)
+      end
+    end
+
+    class AdvancedParser < Parser
+      attr_reader :basis, :decorator_index
+
+      def initialize inside
+        @inside          = inside
+        @basis           = inside.basis
+        @decorator_index = @basis.get_decorator_index
+        super()
+      end
+
+      def accept
+        before_accept
+        @inside.accept
+        after_accept
+      end
+
+      def error
+        before_error
+        @inside.error
+        after_error
+      end
+
+      def shift
+        before_shift
+        @inside.shift
+        after_shift
+      end
+
+      def reduce
+        before_reduce
+        @inside.reduce
+        after_reduce
+      end
+
+      private
+      def before_accept
+      end
+
+      def after_accept
+      end
+
+      def before_error
+      end
+
+      def after_error
+      end
+
+      def before_shift
+      end
+
+      def after_shift
+      end
+
+      def before_reduce
+      end
+
+      def after_reduce
+      end
+    end
+
+    class Action < AdvancedParser
+      def initialize inside
+        super inside
+        @_arguments = []
+        @on_reduce, = self.class::Tables
+      end
+
+      def before_reduce
+        @_arguments = []
+        n = reduce_table[-action_value][1]
+        n.times do |i|
+          v = stack[stack.size - 2 * (i + 1)]
+          @_arguments[n - i - 1] = v[1] == :NT ? v[decorator_index] : v[1]
+        end
+      end
+
+      def after_reduce
+        method = @on_reduce[-action_value]
+        result = method ? send(method, @_arguments) : nil
+        stack[stack.size - 2][decorator_index] = result
+      end
+    end
+  end
+end