depager 0.1.9

data/lib/depager/nvaction.rb

@@ -0,0 +1,21 @@
+require 'depager/action.rb'
+require 'depager/parser.rb'
+require 'depager/parse_action.rb'
+
+class NVActionExtension < ActionExtension #:nodoc:all
+  def modify_action_code code
+    let_code = ""
+    if @g_parser.rhsni.size > 0
+      rhs = @g_parser.rhsni.sort_by{|k,v| v}
+      let_code = rhs.map do |name, _|
+        if name =~ /[a-zA-Z][a-zA-Z0-9_]*/
+          "_#{name}"
+        else
+          '_'
+        end
+      end
+      let_code = "    #{let_code.join(', ')} = *val \n"
+    end
+    return let_code << code, 1
+  end
+end

data/lib/depager/parse_action.rb

@@ -0,0 +1,24 @@
+module Depager::ActionParser
+  require 'pp'
+  def parse_action
+    val = ''
+    start_lineno = lineno
+    if @line =~ /\A\{(.*)\}\s*(#.*)?\Z/
+      val = "    #{$1}\n"
+    else
+      val.concat @line.sub(/\A\s*\{/, '')
+      ind = @line0.match(/\A([ \t]*)/)[1]
+      until file.eof?
+        getline
+        break if line =~ /\A#{ind}\}\s*(#.*)?\Z/ 
+        val.concat line
+      end
+      if file.eof?
+        error_exit 'syntax error(parse_action).', start_lineno
+      end
+    end
+    @line = $'
+    #warn val
+    return val
+  end
+end

data/lib/depager/parser.rb

@@ -0,0 +1,248 @@
+require "depager/utils.rb"
+module Depager
+  #
+  # Token
+  # 
+  Token = Struct.new(:value, :lineno, :filename)
+
+  # = Parser Runtime
+  # == Stack
+  # s::  state
+  # la:: look ahead
+  # v::  value
+  #                                stack top->
+  #   [0, [la0, v0], s0, [la1, v1], s1, .....]
+  #
+  class Parser
+    def initialize
+    end
+
+    ACC = 0x03ffffff
+
+    #
+    # lexer
+    #
+    def lex
+    end
+
+    # parse method
+    def yyparse 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
+    def init_parser
+    end
+
+    # 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 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, 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
+      beforeAccept
+      @inside.accept
+      afterAccept
+    end
+    def error
+      beforeError
+      @inside.error
+      afterError
+    end
+    def shift
+      beforeShift
+      @inside.shift
+      afterShift
+    end
+    def reduce
+      beforeReduce
+      @inside.reduce
+      afterReduce
+    end
+
+    def beforeAccept
+    end
+    def afterAccept
+    end
+    def beforeError
+    end
+    def afterError
+    end
+    def beforeShift
+    end
+    def afterShift
+    end
+    def beforeReduce
+    end
+    def afterReduce
+    end
+  end
+
+  #
+  # Action Decorator Base class
+  #
+  class Action < AdvancedParser
+    def initialize inside, nparamkey=nil
+      super inside, nparamkey
+      @_yy_val_ = []
+    end
+    def beforeReduce
+      @_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 afterReduce
+      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

data/lib/depager/psrtmpl.rb

@@ -0,0 +1,33 @@
+class ShiftReducePrinter < AdvancedParser
+  def initialize inside
+    super
+  end
+  def beforeAccept
+  end
+  def afterAccept
+  end
+  def beforeError
+  end
+  def afterError
+  end
+  def beforeShift
+  end
+  def afterShift
+    super
+    st = _stack.last
+    sh = @i2t[_stack[_stack.size-2]]
+    la = @i2t[_lookahead]
+    warn "shift:<#{sh}> #{st} lookahead:<#{la}>"
+    warn _stack
+  end
+  def beforeReduce
+  end
+  def afterReduce
+    super
+    st = _stack.last
+    re = @i2nt[_stack[_stack.size-2]]
+    la = @i2t[_lookahead]
+    warn "reduse:<#{re}> #{st} lookahead:<#{la}>"
+    warn _stack
+  end
+end

data/lib/depager/slex.dr

@@ -0,0 +1,161 @@
+%defext StatefulLexerExtension
+%extend Lexer ('depager/lex.rb')
+%extend NVAction ('depager/nvaction.rb')
+%decorate @NVAction
+#%decorate ShiftReducePrinter ('depager/srp.rb')
+%inner{
+  attr_accessor :ins, :code, :optval
+  def init_parser
+    super
+    @ins = []
+    @optouter = []
+    @on_reduce = []
+    @addition = []
+  end
+  def postRuleList
+    @optouter << %{
+      def afterError
+        warn "StatefulLex: lex_state==\#{@basis.lex_state}" if $MP_DEBUG
+      end
+    }
+    g_parser.optouter <<
+      gen_action_decorator_code(target_name, paramkey,
+                                @on_reduce, @optouter)
+  end
+  def postRhs
+    j = 0
+    rhs = g_parser.rhs
+    @ins.each do |i, m|
+      state_name = "#{lhs_name}_#{nrhs}_#{i}"
+      if i != rhs.size
+        isym     = g_parser.add_nonterm("__#{state_name}__".intern)
+        new_rule = Rule[isym, []]
+        val      = ( ":_lex_#{state_name}" )
+        @addition << [ new_rule, rhs, val, i+j, isym ]
+        j += 1
+      else
+        @on_reduce[nrules] = ( ":_lex_#{state_name}" )
+      end
+      @optouter.push << %{
+        def _lex_#{lhs_name}_#{nrhs}_#{i} val
+          @basis.lex_state = #{m}
+        end
+      }
+    end
+    @ins.clear
+  end
+  def postRhsList
+    @addition.each do |new_rule, rhs, val, pos, isym|      
+      g_parser.g << new_rule
+      rhs.insert(pos, isym)
+      @on_reduce[nrules] = val
+    end
+    @addition.clear
+  end
+%}
+######################################################################
+# Define Tokens
+######################################################################
+%hook prerulelist /%LEX\{\s*\Z/ skip
+%mixin ActionParser ('depager/parse_action')
+%banner '%LEX{ ... }'
+%%
+%LEX{
+  /\s+/, /#.*\Z/           { }
+  /[A-Z]+/                 { yield _Token(:ID, $&) }
+  /\%\}\s*\Z/              { @line = $'; yield nil,nil }
+  /\/(([^\/\\]+|\\.)*)\//,
+  /'([^'\\]+|\\.)*\'/      { yield _Token(:LEX, "/\\A#{$1}/") }
+  /\{/                     { ln = lineno; yield :ACTION, Token[parse_action, ln]; //=~'' }
+  /./                      { yield _Token($&, $&) }
+%}
+#begin-rule
+  start:
+      mode_list
+      {
+        ll = ''
+        _mode_list.each do |m, s, l|
+          elsec = if s
+                    "_rest = lex_#{s}(&block)"
+                  else
+                    %!raise RuntimeError, "must not happen \#{@line}"!
+                  end
+          ll << %{
+            def lex_#{m}(&block)
+              _rest = ''
+              case @line
+                #{l.map{|i| ' '*4+i}}
+              else
+                #{elsec}
+              end
+              return _rest
+            end
+          }; #code
+        end
+        g_parser.optinner << ll << %{
+          attr_accessor :lex_state
+          def lex(&block)
+            @lex_state ||= :START
+            begin
+              until @line.empty?
+                @line = self.send "lex_\#{@lex_state}", &block
+              end
+            end while @line = getline
+            yield nil, nil
+          end
+        }; #code
+      }
+  ;
+  mode_list:
+                                  { [ ] }
+    | mode_list mode lexactlist   { _mode_list << [_mode[0], _mode[1], _lexactlist] }
+  ;
+  mode:
+      '<' ID opt_super '>'        { [ _ID.value, _opt_super ] }
+  ;
+  opt_super:
+                                  { nil }
+    | ':' ID                      { _ID.value }
+  ;
+  lexactlist:
+      lexact            { [ _lexact ] }
+    | lexactlist lexact { _lexactlist << _lexact }
+  ;
+  lexact:
+      lexlist ACTION
+      {
+        %{
+          when #{_lexlist.join(', ')}
+            _rest = $'
+            #{ _ACTION.value }
+        }; #code
+      }
+  ;
+  lexlist:
+      LEX               { [ _LEX.value ] }
+    | lexlist ',' LEX   { _lexlist.push _LEX }
+  ;
+#end-rule
+%%
+######################################################################
+# Change State
+######################################################################
+%hook prerhs postsymbol /\[/
+%banner '[> ...]'
+%%
+%LEX{
+  /\s+/         { }
+  /:[a-zA-Z_]+/ { yield _Token(:SYMBOL, $&) }
+  /\]/          { yield _Token($&, $&); @line = $'; yield nil, nil }
+  /./           { yield _Token($&, $&) }
+%}
+
+#begin-rule
+  start:
+      '[' '>' SYMBOL ']'
+      {
+        master.ins.push [g_parser.rhs.size, _SYMBOL.value]
+      }
+  ;
+#end-rule
+%%