depager 0.1.9

data/data/depager/sample/extension/paction.dr

@@ -0,0 +1,15 @@
+%defext PseudoActionExtension
+%extend Lexer ('depager/lex.rb')
+%extend Action ('depager/action.rb')
+%decorate @Action ('depager/action.rb')
+#%decorate ShiftReducePrinter ('depager/srp.rb')
+%hook postrhs
+%%
+%LEX{
+  /\s/ { }
+  /./  { yield $&, $&, @lineno }
+%}
+ start:
+   '{' '}' { warn 'HIT' }
+ ;
+%%

data/data/depager/sample/extension/pactiontest.dr

@@ -0,0 +1,14 @@
+%class PseudoActionTest
+%extend PseudoAction ('paction.rb')
+%%
+#begin-rule
+  expr:
+      expr '+' fact { }
+  ;
+  fact:
+      ID { }
+  ;
+#end-rule
+%%
+p = PseudoActionTest.new()
+#p.yyparse(STDIN)

data/data/depager/sample/pl0d/pl0ds.dr

@@ -0,0 +1,334 @@
+%class PL0d
+%extend Lexer ('depager/lex.rb')
+%extend ASTBuilderLazy ('depager/astl.rb')
+%decorate @ASTBuilderLazy
+#%decorate ShiftReducePrinter ('depager/srp.rb')
+%%
+%LEX{
+  /\s+/     { }
+  ':='      { yield _Token(:COLOEQ, $&)    }
+  '<>'      { yield _Token(:NOTEQ, $&)     }
+  '<='      { yield _Token(:LE, $&)        }
+  '>='      { yield _Token(:GE, $&)        }
+  '='       { yield _Token(:EQ, $&)        }
+  '<'       { yield _Token(:LT, $&)        }
+  '>'       { yield _Token(:GT, $&)        }
+  'const'   { yield _Token(:CONST, $&)     }
+  'var'     { yield _Token(:VAR, $&)       }
+  'function'{ yield _Token(:FUNCTION, $&)  }
+  'begin'   { yield _Token(:BEGINN, $&)    }
+  'end'     { yield _Token(:END, $&)       }
+  'if'      { yield _Token(:IF, $&)        }
+  'then'    { yield _Token(:THEN, $&)      }
+  'while'   { yield _Token(:WHILE, $&)     }
+  'do'      { yield _Token(:DO, $&)        }
+  'return'  { yield _Token(:RETURN, $&)    }
+  'writeln' { yield _Token(:WRITELN, $&)   }
+  'write'   { yield _Token(:WRITE, $&)     }
+  'odd'     { yield _Token(:ODD, $&)       }
+  /[a-zA-Z][a-zA-Z0-9_]*/
+            { yield _Token(:IDENT, $&)       }
+  /[0-9]+/  { yield _Token(:NUMBER, $&.to_i) }
+  /./       { yield _Token($&, $&)           }
+%}
+
+%AST{
+  Node [value] { @value = nil }
+  Visitor
+  {
+    STEntry = Struct.new(:kind, :narg, :value)
+    def initialize
+      @global = {
+        '+'  => STEntry.new(:FUNC, 2, proc{|a| a[0] + a[1] }),
+        '-'  => STEntry.new(:FUNC, 2, proc{|a| a[0] - a[1] }),
+        '*'  => STEntry.new(:FUNC, 2, proc{|a| a[0] * a[1] }),
+        '/'  => STEntry.new(:FUNC, 2, proc{|a| a[0] / a[1] }),
+        '='  => STEntry.new(:FUNC, 2, proc{|a| a[0] == a[1] ? 1 : 0}),
+        '<>' => STEntry.new(:FUNC, 2, proc{|a| a[0] != a[1] ? 1 : 0}),
+        '<'  => STEntry.new(:FUNC, 2, proc{|a| a[0] <  a[1] ? 1 : 0}),
+        '>'  => STEntry.new(:FUNC, 2, proc{|a| a[0] >  a[1] ? 1 : 0}),
+        '<=' => STEntry.new(:FUNC, 2, proc{|a| a[0] <= a[1] ? 1 : 0}),
+        '>=' => STEntry.new(:FUNC, 2, proc{|a| a[0] >= a[1] ? 1 : 0}),
+        'odd'=> STEntry.new(:FUNC, 1, proc{|a| a[0] & 1 }),
+
+        'write'   => STEntry.new(:FUNC, 1, proc{|a| print "#{a[0]} "; 1}),
+        'writeln' => STEntry.new(:FUNC, 0, proc{|a| puts ''; 1}),
+      }
+      @env = [@global]
+    end
+    def lookup name
+      @env.reverse_each{|s| return s[name] if s[name]}
+      return nil
+    end
+    def dump_env n = 2
+      n = @env.size if n > @env.size
+      e = @env[n..-1].map{|i| Hash[* i.map{|k, v| [k, v.value]}.flatten ] }
+      warn e.pretty_inspect
+    end
+  }
+  program(block)
+  {
+    visit(~block)
+  }
+  block(decls, stmt)
+  {
+    @env.push({})
+    visit(~decls)
+    visit(~stmt)
+    @env.pop
+  }
+  var_decl(-idents)
+  {
+    ~idents.each do |ident|
+      if @env.last[ident.value]
+        warn "'#{ident.value}' already exist."; exit
+      else
+        @env.last[ident.value] = STEntry.new(:VAR, 0, 0)
+      end
+    end
+  }
+  const_decl(const_inits)
+  {
+    visit(~const_inits)
+  }
+  const_init(-ident, -number)
+  {
+    if @env.last[~ident.value]
+      warn "'#{~ident.value}' already exist."; exit
+    else
+      @env.last[~ident.value] = STEntry.new(:CONST, 0, ~number.value)
+    end
+  }
+  func_decl(-ident, -params, -block)
+  {
+    if @env[0][~ident.value]
+      warn "'#{~ident.value}' already exist."; exit
+    end
+    body = proc do |args|
+      value = 0
+      n = @env.size
+      @env.push({})
+      value = callcc do |c|
+        @env.last['return'] = STEntry.new(:VAR, 0, c)
+        ~params.each_with_index do |a, x|
+          @env.last[a.value] = STEntry.new(:VAR, 0, args[x])
+        end
+        visit(~block)
+      end
+      @env = @env[0, n]
+      value
+    end
+    @env.last[~ident.value] = STEntry.new(:FUNC, ~params.size, body)
+  }
+  nop_stmt(-nop)
+  {
+  }
+  assign_stmt(-ident, expr)
+  {
+    if ent = lookup(~ident.value)
+      unless ent.kind == :VAR
+        warn "'#{~ident.value}' not var."; exit
+      end
+      ent.value = visit(~expr).value
+    else
+      warn @env.pretty_inspect
+      warn "'#{~ident.value}' not found."; exit
+    end
+  }
+  begin_stmt(stmt, stmts)
+  {
+    visit(~stmt)
+    visit(~stmts)
+  }
+  if_stmt(cond, stmt)
+  {
+    if visit(~cond).value != 0
+      visit(~stmt)
+    end
+  }
+  while_stmt(cond, stmt)
+  {
+    while visit(~cond).value != 0
+      visit(~stmt)
+    end
+  }
+  return_stmt(expr)
+  {
+    ent = nil
+    @env.reverse_each{|s| break if ent = s['return'] }
+    unless ent
+      warn "'return' not in func."; exit
+    end
+    ent.value.call(visit(~expr).value)
+  }
+  apply(-ident, -args)
+  {
+    ent = nil
+    @env.reverse_each{|s| break if ent = s[~ident.value] }
+    unless ent
+      warn "'#{~ident.value}' not found."; exit
+    end
+    unless ent.kind == :FUNC
+      warn "'#{~ident.value}' not func."; exit
+    end
+
+    args = ~args.map{|a| visit(a).value } 
+    # warn "#{'  '*(@env.size-2)}|#{~ident.value} : #{args.inspect}"
+    unless ent.narg == args.size
+      warn "#{ent.narg} #{args.size} #{args.inspect}"
+      warn "'#{~ident.value}' unmatch args."; exit
+    end
+    ~value = ent.value.call(args)
+    # warn "#{'  '*(@env.size-2)}|-> #{~value} @ #{~ident.value}"
+  }
+  refv(-ident)
+  {
+    unless ent = lookup(~ident.value)
+      warn "'#{~ident.value}' not found."; exit
+    end
+    if ent.kind == :VAR || ent.kind == :CONST
+      ~value = ent.value
+    else
+      warn "'#{~ident.value}' not var."; exit
+    end
+  }
+  number(-n)
+  {
+    ~value = ~n.value
+  }
+%}
+#begin-rule
+  program:
+      block '.'
+      => program(block)
+  ;
+
+  block:
+      opt_decl_list statement
+      => block(opt_decl_list, statement)
+  ;
+
+  opt_decl_list:
+      => []
+    | opt_decl_list decl
+      => opt_decl_list << decl
+  ;
+
+  decl:
+      CONST const_init_list ';'
+      => const_decl(const_init_list)
+    | VAR ident_list ';'
+      => var_decl(ident_list)
+    | FUNCTION IDENT '(' ')' block ';'
+      => func_decl(IDENT, [], block)
+    | FUNCTION IDENT '(' ident_list ')' block ';'
+      => func_decl(IDENT, ident_list, block)
+  ;
+
+  const_init_list:
+      const_init
+      => [ const_init ]
+    | const_init_list ',' const_init
+      => const_init_list << const_init
+  ;
+
+  const_init:
+      IDENT EQ NUMBER
+      => const_init(IDENT, NUMBER)    
+  ;
+
+  ident_list: 
+      IDENT
+      => [ IDENT ]
+    | ident_list ',' IDENT
+      => ident_list << IDENT
+  ;
+
+  statement:
+      => nop_stmt([])
+    | IDENT COLOEQ expression
+      => assign_stmt(IDENT, expression)
+    | BEGINN statement opt_state_list END
+      => begin_stmt(statement, opt_state_list)
+    | IF condition THEN statement
+      => if_stmt(condition, statement)
+    | WHILE condition DO statement
+      => while_stmt(condition, statement)
+    | RETURN expression
+      => return_stmt(expression)
+    | WRITE expression
+      => apply('write', [expression])
+    | WRITELN
+      => apply('writeln', [])
+  ;
+
+  opt_state_list:
+      => []
+    | opt_state_list ';' statement
+      => opt_state_list << statement
+  ;
+
+  condition:
+      ODD expression
+      => apply('odd', [expression])
+    | expression-e0 EQ expression-e1
+      => apply('=', [e0, e1])
+    | expression-e0 NOTEQ expression-e1
+      => apply('<>', [e0, e1])
+    | expression-e0 LT expression-e1
+      => apply('<', [e0, e1])
+    | expression-e0 GT expression-e1
+      => apply('>', [e0, e1])
+    | expression-e0 LE expression-e1
+      => apply('<=', [e0, e1])
+    | expression-e0 GE expression-e1
+      => apply('>=', [e0, e1])
+  ;
+
+  expression:
+      expression '+' term
+      => apply('+', [expression, term])
+    | expression '-' term
+      => apply('-', [expression, term])
+    | term
+      => term
+    | '-' term
+      => apply('UMINUS', [term])
+  ;
+
+  term:
+      term '*' factor
+      => apply('*', [term, factor])
+    | term '/' factor
+      => apply('/', [term, factor])
+    | factor
+      => factor
+  ;
+
+  factor:
+      IDENT
+      => refv(IDENT)
+    | NUMBER
+      => number(NUMBER)
+    | IDENT '(' ')'
+      => apply(IDENT, [])
+    | IDENT '(' exp_list ')'
+      => apply(IDENT, exp_list)
+    | '(' expression ')'
+      => expression
+  ;
+
+  exp_list: 
+      expression
+      => [ expression ]
+    | exp_list ',' expression
+      => exp_list << expression
+  ;
+#end-rule
+%%
+require 'pp'
+psr = createDecoratedPL0d
+t, = psr.yyparse(STDIN)
+# pp t
+v = Visitor.new
+t.accept(v)

data/data/depager/sample/pl0d/pl0test.pl0

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

data/data/depager/sample/sample_calc/calc.action.dr

@@ -0,0 +1,33 @@
+%class TinyCalc
+%extend Lexer ('depager/lex.rb')
+%extend Action ('depager/action.rb')
+%decorate @Action
+#%decorate ShiftReducePrinter ('depager/srp.rb')
+%%
+
+%LEX{
+  /\s+/, /\#.*/ { }
+  /[1-9][0-9]*/ { yield _Token(:NUM, $&.to_i) }
+  /./           { yield _Token($&, $&) }
+%}
+
+#begin-rule
+  expr : 
+      expr '+' term { val[0] + val[2] }
+    | expr '-' term { val[0] - val[2] }
+    | term          { val[0] }
+  ;
+  term :
+      term '*' fact { val[0] * val[2] }
+    | term '/' fact { val[0] / val[2] }
+    | fact          { val[0] }
+  ;
+  fact :
+      NUM           { val[0].value }
+    | '(' expr ')'  { val[1] }
+  ;
+#end-rule
+%%
+parser = TinyCalc::createDecoratedParser
+r, = parser.yyparse(STDIN)
+puts r

data/data/depager/sample/sample_calc/calc.astdf.dr

@@ -0,0 +1,54 @@
+%class TinyCalc
+%extend Lexer ('depager/lex.rb')
+%extend ASTBuilderDepthFirst ('depager/astdf.rb')
+%decorate @ASTBuilderDepthFirst
+#%decorate ShiftReducePrinter ('depager/srp.rb')
+%%
+
+%LEX{
+  /\s+/, /\#.*/ { }
+  /[1-9][0-9]*/ { yield _Token(:NUM, $&.to_i) }
+  /./           { yield _Token($&, $&) }
+%}
+
+%AST{
+  Node [value]     { @value = nil }
+  Visitor          { }
+  add(left, right) { ~value = ~left.value + ~right.value }
+  sub(left, right) { ~value = ~left.value - ~right.value }
+  mul(left, right) { ~value = ~left.value * ~right.value }
+  div(left, right) { ~value = ~left.value / ~right.value }
+  literal(-n)      { ~value = ~n.value }
+%}
+
+#begin-rule
+  expr :
+      expr '+' term
+      => add(expr, term)
+    | expr '-' term
+      => sub(expr, term)
+    | term
+      => term
+  ;
+  term :
+      term '*' fact
+      => mul(term, fact)
+    | term '/' fact
+      => div(term, fact)
+    | fact
+      => fact
+  ;
+  fact :
+      NUM
+      => literal(NUM)
+    | '(' expr ')'
+      => expr
+  ;
+#end-rule
+%%
+require 'pp'
+parser = createDecoratedTinyCalc()
+t, = parser.yyparse(STDIN)
+v = Visitor.new
+pp t.accept(v).value
+pp t