depager 0.2.2 → 0.2.3

data/lib/depager/grammar.rb

@@ -2,8 +2,8 @@ module Depager::ParsingMethod
   class Grammar
     attr_accessor :rulelist, :lhs_to_rule, :syms, :nonterms, :terms
     attr_accessor :precs, :f0e, :first1
-    Eps = 0x3fffffff #epsilon
-    #Eps = []
+    Eps = 0x3fffffff #epsilon #Eps = []
+    def initialize_depend ; end # template method for inheritance
     def initialize rulelist, terms, nonterms, precs = nil
       @precs    = precs
       @nonterms = nonterms.invert
@@ -26,9 +26,6 @@ module Depager::ParsingMethod
       initialize_depend
     end
 
-    def initialize_depend
-    end
-
     def make_sym_mask
       @sym_mask, @mask_sym = {}, []
       @terms.sort_by{|a, b| a}.each_with_index do |i,x|
@@ -90,8 +87,8 @@ module Depager::ParsingMethod
         end
       end while changed
 
-      old_make_sym_first
 =begin
+      old_make_sym_first
       warn "check.."
       @first1.each do |k,v|
         old = @old_first1[k].sort
@@ -256,7 +253,6 @@ module Depager::ParsingMethod
       end
     end
   end
-  G = Grammar
 
   class Rule
     def self.[] l, r, prec = nil

data/lib/depager/lr.rb

@@ -1,5 +1,11 @@
 require 'pp'
 require 'depager/grammar.rb'
+
+module Depager::ParsingMethod
+  class Grammar
+  end
+end
+
 module Depager::LALR
   class SingleParserGenerator < Simple::SingleGenerator
     Tmplfile = 'single_lalr_parser.erb'
@@ -420,7 +426,6 @@ module Depager::LALR
       @warning_list.each{|i| dp.warning i }
 
       if $MP_DEBUG
-        require 'depager/lr_put_table.rb'
         gen_state_info
         verbose dp if $MP_VERBOSE
       end
@@ -455,3 +460,120 @@ module Depager::LALR
     end
   end
 end
+
+class Depager::LALR::Table
+  def state_info
+    @state_info
+  end
+
+  #puts grammar.closure.values.join("\n")
+  #puts "-----"
+  #puts grammar.memo_closure1.sort_by{|k,v| k}.map{|k,v| "#{k.inspect}:\n#{v.join("\n")}"}
+  #puts 'mk'; mk.each{|k, v| p "#{k}=>#{v}"}
+  #trn = trn.uniq
+  #puts 'trn',trn.map{|a| "<#{a[2].n}>#{a[0]} => <#{a[3].n}>#{a[1]}"}
+
+  def gen_state_info
+    g = grammar
+    @state_info = []
+    @action_table.each_with_index {|s,x|
+      shi, red, acc = "", "", ""
+      s.each_with_index {|t, y|
+        next unless t
+        hd = ("  %-15s" % g.symname(y + g.nonterms.size))
+        if t == 'ACC'
+          acc = "#{hd} accept\n\n"
+        elsif t < 0
+          red << "#{hd} reduce using rule #{-t} (#{g.symname g[-t].lhs})\n"            
+        else
+          shi << "#{hd} shift, and goto to state #{t}\n"
+        end
+      }
+      if t = @defred_table[x]
+        as = @defred_after_shift_table[x] ? " [after shift]" : ""
+        red << ("  %-15s" % '$default') <<
+          "reduce using rule #{-t} (#{g.symname g[-t].lhs}) #{as}\n"
+      end
+
+      @state_info << (@states[x].to_s << "\n\n#{shi}\n#{red}\n#{acc}")
+    }
+  end
+
+  def verbose dp
+    g, output = grammar, []
+
+    if $MP_DEBUG.match(/f/)
+      output << "** FIRST1 **"
+      str = g.first1.map{|k, v|
+        "#{g.symname k} => #{v.map{|i| g.symname i}.join(' ')}"
+      }.join("\n")
+      output << "#{str}\n\n"
+    end
+
+    if $MP_DEBUG.match(/e/)
+      output << "** Empty Reduction **"
+      str = g.f0e.map {|k, v| 
+        "#{g.symname k} =>\n" << v.map{|n, f|
+          "  #{rulelist[n]} ? #{f.map{|i| g.symname i}.join(' ')}"
+        }.join("\n")
+      }.join("\n")
+      output << "#{str}\n\n"
+    end
+
+    if $MP_DEBUG.match(/s/)
+      output << "** SYMBOLS **"
+      str = g.syms.map{|k,_| "#{"%03i" % k} #{ g.symname k}"}.sort.join("\n")
+      output << "#{str}\n\n"
+    end
+
+    if $MP_DEBUG.match(/g/)
+      output << "*** Grammar ***"
+      str = g.rulelist.join("\n")
+      output << "#{str}\n\n"
+    end
+
+    if $MP_DEBUG.match(/c/)
+      output << "*** States ***"
+      output << @state_info.to_s
+    end
+
+    nssize = g.nonterms.size
+    if $MP_DEBUG.match(/t/)
+      output << "*** Action Table ***"
+      ws = (nssize...g.syms.size).map{|i| j = g.symname(i).size; j < 6 ? 6 : j}
+      str = "   |"
+      (nssize...g.syms.size).each_with_index{|i, x|
+        str << ("%0#{ws[x]}s|" % g.symname(i))
+      }; str << " $default|\n"
+      
+      @action_table.each_with_index{|i,x|
+        str << ("%03i|" % x)
+        i.each_with_index{|j, y|
+          str << ("%0#{ws[y]}s|" % j)
+        }
+        str << ("%04s,%04s|\n" % [@defred_table[x], @defred_after_shift_table[x]])
+      }
+      output << "#{str}\n\n"
+
+      output <<  "*** Goto Table ***"
+      ws = (1...nssize).map{|i| j = g.symname(i).size; j < 6 ? 6 : j}
+      str = "   |"
+      (1...nssize).each_with_index{|i, x|
+        str << ("%0#{ws[x]}s|" % g.symname(i))
+      }; str << "\n"
+      
+      @goto_table.each_with_index{|i,x|
+        str << ("%03i|" % x)
+        i.each_with_index{|j, y|
+          str << ("%0#{ws[y]}s|" % j)
+        }
+        str << "\n"
+      }
+      output << "#{str}\n\n"
+    end
+
+    File.open("#{File.basename(dp.files.fname, '.dr')}.output", "w"){|f|
+      f.write output.join("\n") 
+    }
+  end
+end

data/lib/depager/parser.rb

@@ -40,19 +40,10 @@ module Depager::LALR
   #   [0, [la0, v0], s0, [la1, v1], s1, .....]
   #
   class Parser
-    def initialize
-    end
-
     ACC = 0x03ffffff
 
-    #
-    # lexer
-    #
-    def lex
-    end
-
     # parse method
-    def yyparse f
+    def parse f
       @basis.file = f
       @basis.la = [0, nil]
       @basis.lex do |sym, val|
@@ -63,9 +54,6 @@ module Depager::LALR
     end
 
     protected
-    def init_parser
-    end
-
     # driver method
     def driver
       while true
@@ -95,14 +83,6 @@ module Depager::LALR
         end
       end
     end
-    def accept
-    end
-    def error
-    end
-    def shift
-    end
-    def reduce
-    end
 
     def enable?(act, sym)
       case act
@@ -125,6 +105,14 @@ module Depager::LALR
       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
@@ -153,7 +141,7 @@ module Depager::LALR
         @t2i, @i2t, @nt2i, @i2nt = self.class::Tables
     end
 
-    def _Token sym, val=nil, lineno=nil
+    def token sym, val=nil, lineno=nil
       lineno ||= file.lineno
       return sym, Depager::Token[val, lineno, file.path]
     end
@@ -227,42 +215,35 @@ module Depager::LALR
     end
 
     def accept
-      beforeAccept
+      before_accept
       @inside.accept
-      afterAccept
+      after_accept
     end
     def error
-      beforeError
+      before_error
       @inside.error
-      afterError
+      after_error
     end
     def shift
-      beforeShift
+      before_shift
       @inside.shift
-      afterShift
+      after_shift
     end
     def reduce
-      beforeReduce
+      before_reduce
       @inside.reduce
-      afterReduce
+      after_reduce
     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
+    # 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
 
   #
@@ -273,7 +254,7 @@ module Depager::LALR
       super inside, nparamkey
       @_yy_val_ = []
     end
-    def beforeReduce
+    def before_reduce
       @_yy_val_ = []
       n = @reduce_table[-_actvalue][1]
       n.times do |i|
@@ -281,7 +262,7 @@ module Depager::LALR
         @_yy_val_[n-i-1] = x[1] == :NT ? x[@nparam] : x[1]
       end
     end
-    def afterReduce
+    def after_reduce
       mes = @on_reduce[-_actvalue]
       r = mes ? self.send(mes, @_yy_val_) : nil
       _stack[_stack.size-2][@nparam] = r

data/lib/depager/{template/ast.erbs → ruby/plugins/_ast_tmpl.rb}

@@ -1,7 +1,8 @@
-===:defnode
+class ASTBuilderExtension
+  TMPL_NODE_BASE = <<EOS
 class Node
   attr_accessor :lineno
-  attr_accessor <%= _opt_attr.map{|i| ":#{i}" }.join(', ') %>
+  attr_accessor <%= _opt_attr.map{|i| ":\#{i}" }.join(', ') %>
   <%= ini %>
   def self.[] lineno, *args
     self.new lineno, *args
@@ -43,22 +44,23 @@ class NodeList < Node
 end
 class NilNode
   attr_accessor :lineno
-  attr_accessor <%= _opt_attr.map{|i| ":#{i}" }.join(', ') %>
+  attr_accessor <%= _opt_attr.map{|i| ":\#{i}" }.join(', ') %>
   def initialize(lineno, *args)
     @lineno = lineno
   end
   def accept v
   end
 end
+EOS
 
-===:node
+  TMPL_NODE = <<EOS
 class Node_<%= name %> < Node
-  attr_accessor <%= nodes.map{|i| ":#{i}" }.join(', ') %>
-  attr_accessor <%= attrs.map{|i| ":#{i}" }.join(', ') %>
+  attr_accessor <%= nodes.map{|i| ":\#{i}" }.join(', ') %>
+  attr_accessor <%= attrs.map{|i| ":\#{i}" }.join(', ') %>
   def initialize <%= nodes.unshift('lineno').join(', ') %>
     super()
     @lineno = lineno
-    <%= nodes.inject(''){|r,i| r << "    @#{i} = #{i}\n"} %>
+    <%= nodes.inject(''){|r,i| r << "    @\#{i} = \#{i}\n"} %>
   end
   def accept v
     warn @lineno.to_s+':'+self.class.to_s if $DEBUG
@@ -67,3 +69,5 @@ class Node_<%= name %> < Node
     self
   end
 end
+EOS
+end

data/lib/depager/{action.rb → ruby/plugins/action.rb}

@@ -1,9 +1,7 @@
 require 'depager/parser.rb'
-require 'depager/parse_action.rb'
 
 class ActionExtension #:nodoc:all
   include Depager::ExtensionUtils
-  include Depager::ActionParser
   def initialize
     @line0 = @line = @oldline = ''
     @optouter = []
@@ -14,31 +12,29 @@ class ActionExtension #:nodoc:all
     return code, 0
   end
 
-  def preRuleList
+  def pre_rule_list
     if g_parser.line0 =~ /^%ACTION\{\s*$/
       while line = getline
         break if line =~ /^%\}\s*$/
         @optouter.push line
       end
-      fixline ''
-      gettoken
+      g_parser.update_context ''
     end
   end
 
-  def postRhs
-    if token[0] == '{'
-      @line0, @line = g_parser.line0, g_parser.oldline
+  def post_rhs
+    if g_parser.line =~ /\s*\{/
+      @line0, @line = g_parser.line0, g_parser.line
       lineno = g_parser.lineno
       code, d = modify_action_code(parse_action)
       @optouter <<
         gen_defm_code("_act_#{nrules} val", code, lineno, d)
-      fixline @line
-      gettoken
+      g_parser.update_context @line
       @on_reduce[nrules] = ":_act_#{nrules}"
     end
   end
 
-  def postRuleList
+  def post_rule_list
     g_parser.optouter <<
       gen_action_decorator_code(
         target_name, paramkey,

data/lib/depager/{ast.dr → ruby/plugins/ast.dr}

@@ -1,9 +1,10 @@
 %defext ASTBuilderExtension
-%extend Lexer ('depager/lex.rb')
-%extend NVAction ('depager/nvaction.rb')
+%extend Lexer ('plugins/lex.rb')
+%extend NVAction ('plugins/nvaction.rb')
 %decorate @NVAction
-#%decorate ShiftReducePrinter ('depager/srp.rb')
+#%decorate ShiftReducePrinter ('plugins/srp.rb')
 %inner{
+  require 'plugins/_ast_tmpl'
   attr_accessor :optouter, :on_reduce, :visitor
   def init_parser
     super
@@ -12,13 +13,12 @@
     @on_reduce = []
     @output_file_name = nil
   end
-  def postRuleList
+  def post_rule_list
     g_parser.optouter <<
       gen_action_decorator_code(target_name, paramkey,
                                 @on_reduce, @optouter)
   end
 
-  Template = CodeUtils::make_tmpl("#{Depager::Tmpldir}/ast.erbs")
   def modify_action_code code, nodes=[]
     code = code.gsub(/\$\.([a-z_])/, 'node.\1')
     code << %{
@@ -37,19 +37,18 @@
     @output_file_name = ofname
   end
 %}
-%hook prerulelist /%AST\{\s*\Z/ skip
+%hook pre_rule_list /%AST\{\s*\Z/ skip
 %banner '%AST{ ... }'
-%mixin ActionParser ('depager/parse_action')
 %%
 
 %LEX{
   /\s+/, /#.*/            { }
   /%\}\s*\Z/              { @line = $'; yield nil,nil }
-  'Node'                  { yield _Token(:NODE, $&) }
-  'Visitor'               { yield _Token(:VISITOR, $&) }
-  /[a-zA-Z][a-zA-Z0-9_]*/ { yield _Token(:ID, $&) }
-  '{' !                   { ln = lineno; yield _Token(:ACTION, parse_action, ln) }
-  /./                     { yield _Token($&, $&) }
+  'Node'                  { yield token(:NODE, $&) }
+  'Visitor'               { yield token(:VISITOR, $&) }
+  /[a-zA-Z][a-zA-Z0-9_]*/ { yield token(:ID, $&) }
+  '{' !                   { ln = lineno; yield token(:ACTION, parse_action, ln) }
+  /./                     { yield token($&, $&) }
 %}
 
 #begin-rule
@@ -92,7 +91,7 @@
             #{_ACTION.value}
           end
         };#code
-        master.gen_tmpl_code(:defnode, binding)
+        ERB.new(master.class::TMPL_NODE_BASE).result(binding)
       }
   ;
   opt_defvis:
@@ -131,7 +130,7 @@
             master.gen_defm_code("visit_Node_#{name} node",
                                  vis_code, act.lineno)
         end
-        master.gen_tmpl_code(:node, binding)
+        ERB.new(master.class::TMPL_NODE).result(binding)
       }
   ;
   defnode_header:
@@ -173,7 +172,7 @@
   ;
 #end-rule
 %%
-%hook postrhs /=>/ skip
+%hook post_rhs /=>/ skip
 %banner '=>...'
 %prec{
   left LL '@'
@@ -191,17 +190,17 @@
 %LEX{
   /[ \t]+/                { }
   /\r?\n/               { yield nil, nil                 }
-  /<</                    { yield _Token(:LL, $&)          }
+  /<</                    { yield token(:LL, $&)          }
   /%([a-zA-Z0-9_]+)((::[a-zA-Z0-9_]+)*)/
-                          { yield _Token(:CONST, $1+$2)    }
-  /%\((.+)\)%/            { yield _Token(:EMBED, $1)       }
-  'nil'                   { yield _Token(:NIL, $&)         }
-  'NilNode'               { yield _Token(:NILNODE, $&)     }
-  /[0-9]+/                { yield _Token(:NUMBER, $&.to_i) }
-  /:[a-zA-Z0-9_]+/        { yield _Token(:SYMBOL, $&)      }
-  /[a-zA-Z][a-zA-Z0-9_]*/ { yield _Token(:ID, $&)          }
-  /'(.+)'/                { yield _Token(:STR, $1)         }
-  /./                     { yield _Token($&, $&)           }
+                          { yield token(:CONST, $1+$2)    }
+  /%\((.+)\)%/            { yield token(:EMBED, $1)       }
+  'nil'                   { yield token(:NIL, $&)         }
+  'NilNode'               { yield token(:NILNODE, $&)     }
+  /[0-9]+/                { yield token(:NUMBER, $&.to_i) }
+  /:[a-zA-Z0-9_]+/        { yield token(:SYMBOL, $&)      }
+  /[a-zA-Z][a-zA-Z0-9_]*/ { yield token(:ID, $&)          }
+  /'(.+)'/                { yield token(:STR, $1)         }
+  /./                     { yield token($&, $&)           }
 %}
 #begin-rule
   start: