depager 0.2.3 → 0.3.0.b20250423

data/README.ja

@@ -1,127 +1,47 @@
 Depager README
 ==============
 
-  Deager�ϼ��ʳ�ĥ��ǽ�ʹ�ʸ���ϴ������ϤǤ���
+  Deagerは自己拡張可能な構文解析器生成系です。
 
 
-ɬ�״Ķ�
+必要環境
 --------
 
-  * Ruby 1.8
+  * Ruby 3.0
 
 
-���󥹥ȡ�����ˡ(gem)
+インストール方法(gem)
 ---------------------
 
-  gem��depager�򤪻Ȥ��Υ����ƥ�˥��󥹥ȡ��뤹���硢
-  ���ޥ�ɥ饤��ǰʲ��Τ褦���Ǥ�����Ǥ���������
+    $ sudo gem install depager
 
-    # sudo gem install depager
 
+簡単な使い方
+------------
 
-���󥹥ȡ�����ˡ(tgz)
----------------------
-
-  tgz��depager�򤪻Ȥ��Υ����ƥ�˥��󥹥ȡ��뤹���硢
-  ���ޥ�ɥ饤��ǰʲ��Τ褦���Ǥ�����Ǥ���������
-  UNIX �� OS �ǤϤ����餯 root ���¤�ɬ�פˤʤ�ޤ���
-
-   ($ su)
-    # ruby setup.rb
-
-  �ĿͤΥۡ���ǥ��쥯�ȥ�ʲ��˥��󥹥ȡ��뤹���硢
-  ���ޥ�ɥ饤��ǰʲ��Τ褦���Ǥ�����Ǥ���������
-
-    # ruby setup.rb all --installdirs=home
-
-  �ĿͤΥۡ���ǥ��쥯�ȥ�ʲ��˥��󥹥ȡ��뤷����硢
-  �Ķ��ѿ�RUBYLIB�˥ǥ��쥯�ȥ���ɲä��Ƥ���������
-  (�����餯 $HOME/lib/ruby �Ǥ�)
+    $ depager -o 出力ファイル 入力ファイル
 
-    $ RUBYLIB=$RUBYLIB:$HOME/lib/ruby
-    $ export RUBYLIB
+  例:
 
-  ���󥹥ȡ�������ѹ������ꤹ�뤳�Ȥ�Ǥ��ޤ���
-  ���ξ��� ruby setup.rb --help ��¹Ԥ��ƤߤƤ���������
+    $ depager -o calc.tab.rb calc.dr
 
-  ����˾ܤ���setup.rb�λȤ����ˤĤ��Ƥϡ�
-    setup.rb ( LoveRubyNet )
-    http://i.loveruby.net/ja/projects/setup/
-  �򻲾Ȥ��Ƥ���������
+  詳しくは -h オプションをご利用ください。
 
 
-��ñ�ʻȤ���
-------------
-
-    # depager -o ���ϥե����� ���ϥե�����
-
-  ��.
-
-    # depager -o calc.tab.rb calc.dr
-
-  �ܤ����� -h ���ץ��������Ѥ���������
-
-
-�ե�����δ�ñ������
---------------------
-
-  /bin
-        depager           �¹���
-  /lib
-        depager.rb        �����ϥᥤ��
-    /depager
-        lr.rb             LRɽ������
-        grammar.rb        ���ϼ�ˡ���
-        utils.rb          ����⥸�塼�뷲
-        version.rb        ����������
-        parser.rb         ��󥿥���饤�֥��
-      /ruby
-        /plugins
-          action.rb       ����������ĥ
-          ast.rb          AST��ĥ
-          astdf.rb        ����ͥ��õ��AST��ĥ
-          atree.rb        ����ˤ���ڹ��۳�ĥ
-          cst.rb          CST��ĥ
-          lex.rb          ������ϳ�ĥ
-          nvaction.rb     ̾���ե���������ĥ
-          srp.rb          �����å�ɽ���ǥ��졼��
-          slex.rb         �����ջ�����ϳ�ĥ
-        /templetes
-          extension_lalr_master.erb 
-                          ��ĥ�ޥ����ƥ�ץ졼��
-          extension_lalr_slave.erb
-                          ��ĥ���졼�֥ƥ�ץ졼��
-          simple.rb
-                          ����ץ�ƥ�ץ졼��
-          single_lalr_parser.erb
-                          ɸ��LR�ѡ����ƥ�ץ졼��
-  /data
-    /depager
-      /misc
-        depager-mode.el   Emacs��depager-mode
-  /examples
-    /c89                  c89�ѡ���
-    /pl0d                 PL0���󥿥ץ꥿
-    /extension            ��ĥ����ץ�
-    /samlpe_calc          ���������������ץ�
-    /slextest             �����ջ�����ϳ�ĥ����ץ�
-
-
-�饤����
+ライセンス
 ----------
 
-  GPL�˽��ä����ۤ��ޤ���
+  GNU GPL Version 2 に従って配布します。
 
 
-����¾
+その他
 ------
 
-  Depager�������δ��ĤΤ�ȡ�maita��������
-  ���漼�ˤ�äƳ�ȯ����ޤ�����
-  
-  Depager�δ�Ȥʤä�Depage��Ʊ���漼�κ����ϻ�ˤ�ä�
-  ��ȯ����ޤ�����
+  Depagerは中井央の監督のもと、maitaおよび中井
+  研究室によって開発されました。
+
+  Depagerの基となったDepageは同研究室の佐竹力氏によって
+  開発されました。
 
 
 maita <maita@fujiyama.slis.tsukuba.ac.jp>
-��渦�漼 http://nakai2.slis.tsukuba.ac.jp/hiki/

data/Rakefile

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rubocop/rake_task"
+require "minitest/test_task"
+
+RuboCop::RakeTask.new
+
+Minitest::TestTask.create(:test) do |t|
+  t.test_prelude = "require \"simplecov\""
+end
+
+desc "Build plugins"
+task :build_plugins do
+  plugins = %w[lex ast cst rie slex]
+  plugins.each do |i|
+    input_path = "lib/depager/plugins/#{i}.dr"
+    output_path = "lib/depager/plugins/#{i}.rb"
+    ruby "bin/depager", "-o", output_path, input_path
+  end
+end
+
+desc "Update Manifest.txt"
+task :update_manifest do
+  files = `git ls-files -z`.split("\x0").reject do |f|
+    f.end_with?(".gemspec") || f.match(%r{\A(?:(?:test|spec|features)/|\.(?:git|travis|circleci)|appveyor)})
+  end
+  File.open("Manifest.txt", "w") { |f| f.puts(files.sort.join("\n")) }
+end
+
+task default: :test

data/bin/depager

@@ -1,45 +1,7 @@
-#!/usr/local/bin/ruby
-require 'depager'
-require 'optparse'
-
-include Depager
-begin
-  $MP_VERBOSE = nil
-  $MP_DEBUG   = nil
-  dp = nil
-  output_file_name = nil
-  ARGV.options do |opt|
-    opt.on('-v')         { $MP_VERBOSE = true }
-    opt.on('-g[FLAGS]')  {|flags| $MP_DEBUG = flags || 'sgc' }
-    opt.on('-o OUTPUT')  {|ofn| output_file_name = ofn }
-    opt.parse!
-  end
-
-  f = ARGV[0] ? File.open(ARGV[0]) : STDIN
-  begin
-    dp = DeclParser.new
-    res = dp.parse(f, ARGV[0])
-    if output_file_name
-      File.open(output_file_name, "w"){|o| o.write res }
-    else
-      print res
-    end
-  rescue Exception
-    lineno = dp.files.lineno rescue '?'
-    raise
-  end
-rescue SystemExit
-  raise
-rescue Exception
-  warn "#{File.basename $0}: fatal error."
-  warn "| #{$!}"
-  warn "| - #{dp.files.path}:#{lineno}" if dp
-  $@[0].match(/^(.+):(\d+)(:.+)?$/)
-  warn "| ( #{File.basename $1}:#{$2} )"
-  if $MP_DEBUG
-    warn "#{File.basename $0}: #{$@.unshift($!).join("\n")}"
-  else
-    warn "Try -g option if you want to see more error infomation."
-  end
-  exit 1
-end
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
+
+require "depager/cli"
+
+exit Depager::CLI.new.run(ARGV.dup)

data/examples/action_pl0d/pl0d.action.dr

@@ -0,0 +1,421 @@
+%class Pl0d::Parser
+%extend Depager::Lexer ('depager/plugins/lex.rb')
+%extend Depager::Action ('depager/plugins/action.rb')
+%decorate @Action
+#%decorate Depager::LALR::ShiftReducePrinter ('depager/plugins/srp.rb')
+%inner {
+  KEYWORDS = {
+    'const'    => :CONST,
+    'var'      => :VAR,
+    'function' => :FUNCTION,
+    'begin'    => :BEGINN,
+    'end'      => :END,
+    'if'       => :IF,
+    'then'     => :THEN,
+    'while'    => :WHILE,
+    'do'       => :DO,
+    'return'   => :RETURN,
+    'writeln'  => :WRITELN,
+    'write'    => :WRITE,
+    'odd'      => :ODD,
+  }
+%}
+%%
+%LEX{
+  /\s+/                   { }
+  ':='                    { yield token(:COLOEQ, $&) }
+  '<>'                    { yield token(:NOTEQ, $&) }
+  '<='                    { yield token(:LE, $&) }
+  '>='                    { yield token(:GE, $&) }
+  '='                     { yield token(:EQ, $&) }
+  '<'                     { yield token(:LT, $&) }
+  '>'                     { yield token(:GT, $&) }
+  /[a-zA-Z][a-zA-Z0-9_]*/ { yield token(KEYWORDS[$&] || :IDENT, $&) }
+  /[0-9]+/                { yield token(:NUMBER, $&.to_i) }
+  /./                     { yield token($&, $&)           }
+%}
+
+#begin-rule
+  program:
+      block '.'
+      {
+        debug{ warn _block.pretty_inspect }
+        execute(linearize_codes(_block))
+      }
+  ;
+
+  block:
+      opt_decl_list statement
+      {
+        func = env.lookup('#FUNC#')
+        [
+          [ :O_JMP, 0, func.value ],
+          _opt_decl_list,
+          [ :O_LAB, 0, func.value ],
+          [ :O_INT, 0, env.max_addr-2 ],
+          _statement,
+          [ :O_RET, 0, func.argc ]
+        ]
+      }
+  ;
+
+  opt_decl_list:
+      { [] }
+    | opt_decl_list decl
+      { _opt_decl_list.concat _decl }
+  ;
+
+  decl:
+      CONST const_init_list ';'
+      { [ ] }
+    | VAR ident_list ';'
+      {
+        _ident_list.each do |ident|
+          not env.lookup( ident, 1 ) or
+            error_exit "redeclaration of variable '%s'", ident
+          env.install :VARIABLE, ident, nil
+        end
+        [ ] 
+      }
+    | func_head block ';'
+      { env.leave ; _block }
+  ;
+
+  func_head:
+      FUNCTION IDENT '(' opt_ident_list ')'
+      {
+        argc = _opt_ident_list.size
+        lab  = env.genlab
+        not env.lookup( _IDENT.value, 1 ) or
+          error_exit "redeclaration of function '%s'", _IDENT.value
+        env.install :FUNCTION, _IDENT.value, lab, argc
+        env.enter
+        env.install :INFO, '#FUNC#', lab, argc
+        _opt_ident_list.each_with_index do |ident, x|
+          env.install :VARIABLE, ident, x-argc
+        end
+      }
+  ;
+
+  const_init_list:
+      const_init
+      { }
+    | const_init_list ',' const_init
+      { }
+  ;
+
+  const_init:
+      IDENT EQ NUMBER
+      {
+        not env.lookup( _IDENT.value, 1 ) or
+          error_exit "redeclaration of constant '%s'", _IDENT.value
+        env.install :CONSTANT, _IDENT.value, _NUMBER.value
+      }
+  ;
+
+  opt_ident_list:
+      { [] }
+    | ident_list
+      { _ident_list }
+  ;
+
+  ident_list: 
+      IDENT
+      { [ _IDENT.value ] }
+    | ident_list ',' IDENT
+      { _ident_list << _IDENT.value }
+  ;
+
+  statement:
+      { [] }
+    | IDENT COLOEQ expression
+      {
+        entry = env.lookup( _IDENT.value )
+        entry or
+          error_exit "undeclared identifier %s", _IDENT.value        
+        entry.kind == :VARIABLE or
+          error_exit "assignment to constant/procedure is not allowed"
+        [
+          _expression,
+          [ :O_STO, env.level - entry.level, entry.value ]
+        ]
+      }
+    | BEGINN state_list END
+      {
+        _state_list
+      }
+    | IF condition THEN statement
+      {
+        lab = env.genlab();
+        [
+          _condition,
+          [ :O_JPC, 0, lab ],
+          _statement,
+          [ :O_LAB, 0, lab ]
+        ]
+      }
+    | WHILE condition DO statement
+      {
+        lab1 = env.genlab()
+        lab2 = env.genlab()
+        [
+          [ :O_LAB, 0, lab1 ],
+          _condition,
+          [ :O_JPC, 0, lab2 ],
+          _statement,
+          [ :O_JMP, 0, lab1 ],
+          [ :O_LAB, 0, lab2 ]
+        ]
+      }
+    | RETURN expression
+      {
+        [
+          _expression,
+          [ :O_RET, 0, env.lookup('#FUNC#').argc ]
+        ]
+      }
+    | WRITE expression
+      {
+        [
+          _expression,
+          [ :O_OPR, 0, :P_WRI ]
+        ]
+      }
+    | WRITELN
+      { [ [ :O_OPR, 0, :P_WRL ] ] }
+  ;
+
+  state_list:
+      statement
+      { [ _statement ] }
+    | state_list ';' statement
+      { _state_list << _statement }
+  ;
+
+  condition:
+      ODD expression
+      { [ _expression, [ :O_OPR, 0, :P_ODD ] ] }
+    | expression-e0 EQ expression-e1
+      { [ _e0, _e1, [ :O_OPR, 0, :P_EQ ] ] }
+    | expression-e0 NOTEQ expression-e1
+      { [ _e0, _e1, [ :O_OPR, 0, :P_NE ] ] }
+    | expression-e0 LT expression-e1
+      { [ _e0, _e1, [ :O_OPR, 0, :P_LT ] ] }
+    | expression-e0 GT expression-e1
+      { [ _e0, _e1, [ :O_OPR, 0, :P_GT ] ] }
+    | expression-e0 LE expression-e1
+      { [ _e0, _e1, [ :O_OPR, 0, :P_LE ] ] }
+    | expression-e0 GE expression-e1
+      { [ _e0, _e1, [ :O_OPR, 0, :P_GE ] ] }
+  ;
+
+  expression:
+      expression '+' term
+      { [ _expression, _term, [ :O_OPR, 0, :P_ADD ] ] }
+    | expression '-' term
+      { [ _expression, _term, [ :O_OPR, 0, :P_SUB ] ] }
+    | term
+      { _term }
+    | '-' term
+      { [ _term, [ :O_OPR, 0, :P_NEG ] ] }
+  ;
+
+  term:
+      term '*' factor
+      { [ _term, _factor, [ :O_OPR, 0, :P_MUL ] ] }
+    | term '/' factor
+      { [ _term, _factor, [ :O_OPR, 0, :P_DIV ] ] }
+    | factor
+      { _factor }
+  ;
+
+  factor:
+      IDENT
+      {
+        entry = env.lookup( _IDENT.value )
+        entry or
+          error_exit "undeclared identifier %s", _IDENT.value
+        entry.kind != :FUNCTION or
+          error_exit "expression must not contain a procedure identifier"
+        entry.kind == :CONSTANT ?
+          [ :O_LIT, 0, entry.value ] :
+          [ :O_LOD, env.level - entry.level, entry.value ]
+      }
+    | NUMBER
+      { [ :O_LIT, 0, _NUMBER.value ] }
+    | IDENT '(' opt_exp_list ')'
+      {
+        entry = env.lookup( _IDENT.value )
+        entry or
+          error_exit "undeclared identifier %s", _IDENT.value
+        entry.kind == :FUNCTION or
+          error_exit "call of a constant or a variable is meaningless"
+        entry.argc == _opt_exp_list.size or
+          error_exit "wrong number of arguments %i for %i", _opt_exp_list.size, entry.argc
+        [
+          _opt_exp_list,
+          [ :O_CAL, env.level - entry.level, entry.value ]
+        ]
+      }
+    | '(' expression ')'
+      { _expression }
+  ;
+
+  opt_exp_list:
+      { [] }
+    | exp_list
+      { _exp_list }
+  ;    
+
+  exp_list: 
+      expression
+      { [ _expression ] }
+    | exp_list ',' expression
+      { _exp_list << _expression }
+  ;
+#end-rule
+%%
+
+class Pl0d::Action
+  class Entry
+    attr_accessor :kind, :name, :value, :argc, :level
+
+    def initialize k, n, v, c, l
+      @kind, @name, @value, @argc, @level = k, n, v, c, l
+    end
+    def inspect
+      "(#{@name}.#{@level}:#{@kind.to_s[0,1]}[#{@argc}]/#{@value})"
+    end
+  end
+
+  class Env
+    def initialize
+      @stack, @label = [], 0
+    end
+    def enter
+      @stack.push({})
+    end
+    def leave
+      @stack.pop
+    end
+    def level
+      @stack.size-1
+    end
+    def install k, n, v, c = 0
+      v ||= max_addr+1
+      @stack.last[n] = Entry.new(k, n, v, c, level)
+    end
+    def lookup name, n = nil
+      return nil if @stack.empty?
+      n ||= @stack.size
+      (1 .. n).each do |x|
+        result = @stack[-x][name] and
+          return result
+      end
+      return nil
+    end
+    def max_addr
+      # 3 local variables are reserved(BP+0,BP+1,BP+2).
+      max = @stack.last.select{|k,v| v.kind==:VARIABLE }.map{|k,v| v.value}.max.to_i
+      max < 2 ? 2 : max
+    end
+    def genlab
+      @label += 1
+    end
+    def inspect
+      result = "LEVEL:#{level}\n"
+      @stack.reverse.each_with_index do |i,x|
+        result << "(#{level-x}):#{i.inspect}\n"
+      end
+      result
+    end
+  end
+
+  attr_reader :env
+  def initialize inside
+    super
+    @env = Env.new
+    env.enter ; env.install :CONSTANT, "#FUNC#", env.genlab, 0
+  end
+  def error_exit *args
+    print("#{basis.file.lineno}:")
+    printf(*args); print "\n"; exit
+  end
+  def debug 
+    yield if $DEBUG
+  end
+  def linearize_codes codes, res=[], labs={}
+    codes.each do |i|
+      i.is_a? Array or 
+        raise "invalid code"
+      case i[0]
+      when :O_LAB
+        lab, addr = i[2], res.size
+        debug{ warn "LABEL: L#{lab}->##{addr} BACKPATCH: #{labs[lab].inspect}" }
+        labs[lab] and labs[lab].each{|i| res[i][2] = addr }
+        labs[lab] = res.size
+      when :O_JMP, :O_JPC, :O_CAL
+        lab, addr = i[2], labs[i[2]]
+        if addr.is_a? Integer
+          i[2] = addr
+        else
+          labs[lab] ||= []
+          labs[lab] << res.size
+        end
+        res << i
+      when Symbol
+        res << i
+      else
+        linearize_codes i, res, labs
+      end
+    end ; res
+  end
+  # *STACK*     :-3(BP)       :-2     :-1
+  # {...args...}[lexical base][old BP][old PC]{...vars...}
+  def execute codes
+    debug{
+      warn "\n** CODES **"
+      codes.each_with_index{|i,x| warn "#{'% 4i'%x} #{i.inspect}"}
+      warn "\n** EXEC **"
+    }
+    pc, bp, s = 0, 1, [0, 0, 0, 0]
+    begin
+      pc < codes.size or
+        raise "ADDRESS ERROR(PC:#{pc})."
+      op, l, a = codes[pc] ; pc += 1
+      debug{ warn "  #{s.inspect}\nPC:#{pc-1} BP:#{bp} CODE:[#{op}, #{l}, #{a}]" }
+      case op
+      when :O_LIT; s.push a
+      when :O_OPR;
+        case a
+        when :P_NEG; s.push(-s.pop)
+        when :P_ODD; s.push s.pop % 2
+        when :P_ADD; r=s.pop; s.push s.pop + r
+        when :P_SUB; r=s.pop; s.push s.pop - r
+        when :P_MUL; r=s.pop; s.push s.pop * r
+        when :P_DIV; r=s.pop; s.push s.pop / r
+        when :P_EQ ; r=s.pop; s.push( s.pop == r ? 1 : 0 )
+        when :P_NE ; r=s.pop; s.push( s.pop != r ? 1 : 0 )
+        when :P_LT ; r=s.pop; s.push( s.pop <  r ? 1 : 0 )
+        when :P_GE ; r=s.pop; s.push( s.pop >= r ? 1 : 0 )
+        when :P_GT ; r=s.pop; s.push( s.pop >  r ? 1 : 0 )
+        when :P_LE ; r=s.pop; s.push( s.pop <= r ? 1 : 0 )
+        when :P_RDI; print "?"; s.push Integer(STDIN.gets)
+        when :P_WRI; printf( "\t%10d", s.pop )
+        when :P_WRL; puts ""
+        end
+      when :O_INT; s.fill(0, s.size, a)
+      when :O_LOD; x=bp;l.times{x=s[x]}; s.push s[x+a];
+      when :O_STO; x=bp;l.times{x=s[x]}; s[x+a] = s.pop;
+      when :O_CAL; x=bp;l.times{x=s[x]}; s.push x, bp, pc; bp, pc = s.size-3, a;
+      when :O_RET; r=s.pop; _, bp, pc, = s.slice!(bp..-1); s.slice!(-a, a) ; s.push r
+      when :O_JMP; pc = a
+      when :O_JPC; pc = a if s.pop == 0
+      end
+    end while pc != 0
+  end
+end
+
+require 'pp'
+parser = Pl0d.create_decorated_parser
+r, = parser.parse(ARGF)

data/examples/action_pl0d/test.pl0ds

@@ -0,0 +1,48 @@
+const m = 7, n = 85;
+var x,y;
+
+function puts_ntimes(x, n)
+    var i;
+begin
+    i := 0;
+    while i < n do
+      begin
+        write x; writeln;
+        i := i + 1;
+      end;
+    return i
+end;
+
+function fact(x)
+begin
+    write x; writeln;
+    if x = 0 then return 1;
+    return x * fact(x - 1)
+end;
+
+function outer(x, z)
+    function inner(x)
+    begin
+        write x; write y; write z; writeln;
+        return outer(x + 1, z - 1)
+    end;
+begin
+    if z = 0 then return 0;
+    return inner(x)
+end;
+
+
+begin
+    x := m; y := n;
+    write x; write y; writeln;
+    x := 84; y := 36;
+    write x; write y; writeln;
+
+    y := puts_ntimes(5, 10);
+    write y; writeln;
+
+    y := fact(5);
+    write y; writeln;
+
+    y := outer(5, 5);
+end.