razyk 0.0.0

data/lib/razyk/parser.y

@@ -0,0 +1,227 @@
+class RazyK::Parser
+
+token I K S
+token SMALL_I
+token BACKSLASH
+token ASTAR
+token LPAR RPAR
+token ZERO ONE
+token LITERAL STRING
+
+start program
+
+rule
+
+program :   ccexpr
+        {
+          result = val[0] || Combinator.new(:I)
+        }
+        ;
+
+ccexpr  :   /* epsilon */
+        {
+          result = nil
+        }
+        |   ccexpr expr
+        {
+          if val[0].nil?
+            result = val[1]
+          else
+            result = Pair.new(val[0], val[1])
+          end
+        }
+        ;
+
+expr    :   SMALL_I
+        {
+          result = Combinator.new(:I)
+        }
+        |   expr2
+        ;
+
+iotaexpr:   SMALL_I
+        {
+          result = Combinator.new(:IOTA)
+        }
+        |   expr2
+        ;
+
+expr2   :   I
+        {
+          result = Combinator.new(:I)
+        }
+        |   K
+        {
+          result = Combinator.new(:K)
+        }
+        |   S
+        {
+          result = Combinator.new(:S)
+        }
+        |   no_empty_jot_expr
+        {
+          comb = Combinator.new(:I)
+          @jot.reverse_each do |i|
+            case i
+            when 0
+              comb = Pair.new(Pair.new(comb, :S), :K)
+            when 1
+              comb = Pair.new(:S, Pair.new(:K, comb))
+            end
+          end
+          @jot.clear
+          result = comb
+        }
+        |   BACKSLASH expr expr
+        {
+          result = Pair.new(val[1], val[2])
+        }
+        |   ASTAR iotaexpr iotaexpr
+        {
+          result = Pair.new(val[1], val[2])
+        }
+        |   LPAR ccexpr RPAR
+        {
+          result = val[1]
+        }
+        |   LITERAL
+        {
+          result = Combinator.new(val[0].to_sym)
+        }
+        | STRING
+        {
+          result = str2list(val[0])
+        }
+        ;
+
+no_empty_jot_expr   :   ZERO jot_expr
+                    { @jot.push(0) }
+                    |   ONE jot_expr
+                    { @jot.push(1) }
+                    ;
+
+jot_expr:   no_empty_jot_expr
+        |   /* epsilon */
+        ;
+
+end
+
+---- header
+
+require "razyk/node"
+
+---- inner
+
+def str2list(str)
+  # (K 256) means End-of-stream. RazyK String adopt it as null terminator
+  head = Pair.new(:K, 256)
+  str.unpack("C*").reverse_each do |ch|
+    head = Pair.new(Pair.new(:CONS, ch), head)
+  end
+  head
+end
+
+def scan
+  # state : EXPR/IN_COMMENT/IN_LIRETAL/IN_STRING/IN_STRING_ESC
+  state = :EXPR
+  literal = []
+  @lineno = 1
+  @buf.each_char do |ch|
+    @lineno += 1 if ch == "\n"
+    case state
+    when :IN_COMMENT
+      state = :EXPR if ch == "\n"
+      next
+    when :IN_LITERAL
+      if /[\w.-]/ =~ ch
+        literal.push(ch)
+        next
+      else
+        raise "empty literal at line.#{@lineno}" if literal.empty?
+        name = literal.join
+        literal.clear
+        yield [:LITERAL, name]
+        state = :EXPR
+        # through down
+      end
+    when :IN_STRING
+      if "\\" == ch
+        state = :IN_STRING_ESC
+      elsif '"' == ch
+        yield [:STRING, literal.join]
+        literal.clear
+        state = :EXPR
+      else
+        literal.push(ch)
+      end
+      next
+    when :IN_STRING_ESC
+      case ch
+      when "n"
+        literal.push("\n")
+      when "t"
+        literal.push("\t")
+      when "r"
+        literal.push("\r")
+      when "b"
+        literal.push("\b")
+      when "f"
+        literal.push("\f")
+      else
+        literal.push(ch)
+      end
+      state = :IN_STRING
+      next
+    end
+
+    tok = case ch
+    when "#"
+      state = :IN_COMMENT
+      nil
+    when "$"
+      state = :IN_LITERAL
+      nil
+    when "\""
+      state = :IN_STRING
+      nil
+    when "I"
+      [:I, ch]
+    when "i"
+      [:SMALL_I, ch]
+    when "K", "k"
+      [:K, ch]
+    when "S", "s"
+      [:S, ch]
+    when "`"
+      [:BACKSLASH, ch]
+    when "*"
+      [:ASTAR, ch]
+    when "("
+      [:LPAR, ch]
+    when ")"
+      [:RPAR, ch]
+    when "0"
+      [:ZERO, ch]
+    when "1"
+      [:ONE, ch]
+    end
+    yield tok if tok
+  end
+  if state == :IN_LITERAL and not literal.empty?
+    name = literal.join
+    literal.clear
+    yield [:LITERAL, name]
+    state = :EXPR
+  end
+  yield [false, nil]
+end
+
+def parse(str, opt={})
+  @buf = str
+  @jot = []
+  yyparse self, :scan
+end
+
+def self.parse(str, opt={})
+  self.new.parse(str)
+end

data/lib/razyk/vm.rb

@@ -0,0 +1,212 @@
+
+require "enumerator"
+
+if not(defined?(Enumerator)) and defined?(Enumerable::Enumerator)
+  # for 1.8
+  Enumerator = Enumerable::Enumerator
+end
+
+require "razyk/node"
+
+module RazyK
+  class VM
+    class StackUnderflow < StandardError; end
+
+    def initialize(tree, input=$stdin, output=$stdout, recursive=false)
+      @root = Node.new(:root, [], [tree])
+      @generator = nil
+      @input = input
+      @output = output
+      @recursive = recursive
+    end
+
+    def tree
+      @root.to[0]
+    end
+
+    # Pop num of Pairs nodes from stack.
+    # Each Pair node is destroyed if it isn't referenced from other parent node
+    # Return value is [<root Pair node for replace>, cdr1, cdr2, ...]
+    def pop_pairs(stack, num)
+      raise StackUnderflow if stack.size < num
+      pairs = stack.pop(num)
+      root = pairs.first
+      root.cut_car if num <= 1
+      cdrs = [ root.cut_cdr ]
+      shared = false
+      pairs.inject do |parent, child|
+        parent.cut_car unless shared
+        if child.from.size != 0
+          shared = true
+          cdrs.unshift(child.cdr)
+        else
+          cdrs.unshift(child.cut_cdr)
+        end
+        child
+      end
+      cdrs.unshift(root)
+      cdrs
+    end
+
+    # replace old_root Pair with new_root Pair and push new_root to stack
+    def replace_root(stack, old_root, new_root)
+      old_root.replace(new_root)
+      stack.push(new_root)
+    end
+
+    def evaluate(root, gen=nil)
+      stack = [root]
+      until step(stack, gen).nil?
+        if gen
+          gen.yield(self)
+        end
+      end
+      if @recursive and stack.last.is_a?(Pair)
+        evaluate(stack.last.cdr, gen)
+      end
+      nil
+    end
+
+    def step(stack, gen=nil)
+      return nil if stack.empty?
+      while stack.last.is_a?(Pair)
+        stack.push(stack.last.car)
+      end
+      comb = stack.pop
+      case comb.label
+      when :I
+        # (I x) -> x
+        root, x = pop_pairs(stack, 1)
+        replace_root(stack, root, x)
+      when :K
+        # (K x y) -> x
+        root, x, y = pop_pairs(stack, 2)
+        replace_root(stack, root, x)
+      when :S
+        # (S x y z) -> ((x z) (y z))
+        root, x, y, z = pop_pairs(stack, 3)
+        new_root = Pair.new(Pair.new(x, z), Pair.new(y, z))
+        replace_root(stack, root, new_root)
+      when :IOTA
+        #  (IOTA x) -> ((x S) K)
+        root, x = pop_pairs(stack, 1)
+        new_root = Pair.new(Pair.new(x, :S), :K)
+        replace_root(stack, root, new_root)
+      when Integer
+        # (<N> f x) -> x               (N == 0)
+        #           -> (f (<N-1> f x)) (N > 0)
+        root, f, x = pop_pairs(stack, 2)
+        num = comb.label
+        if num == 0
+          replace_root(stack, root, x)
+        else
+          # shortcut
+          if f.label == :INC and x.label.is_a?(Integer)
+            replace_root(stack, root, Combinator.new(num + x.label))
+          else
+            dec_pair = Pair.new(Combinator.new(num-1), f)
+            new_root = Pair.new(f, Pair.new(dec_pair, x))
+            replace_root(stack, root, new_root)
+          end
+        end
+      when :CONS
+        # (CONS a d f) -> (f a d)
+        root, a, d, f = pop_pairs(stack, 3)
+        new_root = Pair.new(Pair.new(f, a), d)
+        replace_root(stack, root, new_root)
+      when :IN
+        # (IN f) -> (CONS <CH> IN f) where <CH> is a byte from stdin
+        ch = @input.read(1)
+        if ch.nil?
+          ch = 256
+        else
+          ch = ch.ord
+        end
+        new_root = Pair.new(Pair.new(:CONS, Combinator.new(ch)),
+                            :DUMMY) # reuse :IN combinator
+        comb.replace(new_root)
+        new_root.cdr = comb
+        stack.push(new_root)
+      when :CAR
+        # (CAR x) -> (x K)       (CAR = (Lx.x TRUE), TRUE = (Lxy.x) = K)
+        root, x = pop_pairs(stack, 1)
+        new_root = Pair.new(x, :K)  # K means TRUE
+        replace_root(stack, root, new_root)
+      when :CDR
+        # (CDR x) -> (x (K I))  (CDR = (Lx.x FALSE), FALSE = (Lxy.y) = (K I)
+        root, x = pop_pairs(stack, 1)
+        new_root = Pair.new(x, Pair.new(:K, :I)) # (K I) means FALSE
+        replace_root(stack, root, new_root)
+      when :OUT
+        # (OUTPUT f) -> ((PUTC ((CAR f) INC <0>) (OUTPUT (CDR f)))
+        root, f = pop_pairs(stack, 1)
+        new_root = Pair.new(
+                     Pair.new(:PUTC,
+                       Pair.new(Pair.new(Pair.new(:CAR, f), :INC), 0)),
+                     Pair.new(comb, # reuse :OUT combinator
+                              Pair.new(:CDR, f)))
+        replace_root(stack, root, new_root)
+      when :INC
+        # (INC n) -> n+1 : increment church number
+        raise StackUnderflow if stack.empty?
+        evaluate(stack.last.cdr, gen)
+        root, n = pop_pairs(stack, 1)
+        unless n.label.is_a?(Integer)
+          begin
+            msg = "argument of INC combinator is not a church number but #{n.inspect}"
+          rescue
+            msg = "argument of INC combinator is not a church number (too large combinator tree)"
+          end
+          raise msg
+        end
+        replace_root(stack, root, Combinator.new(n.label + 1))
+      when :PUTC
+        # (PUTC x y) -> y : evaluate x and putchar it
+        raise StackUnderflow if stack.size < 2
+        x = stack.pop
+        evaluate(x.cdr, gen)
+        unless x.cdr.label.is_a?(Integer)
+          begin
+            msg = "output is not church number but #{x.cdr.inspect}"
+          rescue
+            msg = "output is not church number (too large combinator tree)"
+          end
+          raise msg
+        end
+        num = x.cdr.label
+        if num >= 256
+          return nil
+        end
+        @output.write([num].pack("C"))
+        root = stack.pop
+        y = root.cut_cdr
+        replace_root(stack, root, y)
+      else # unknown combinator... treat as combinator without enough arguments
+        raise StackUnderflow
+      end
+      true
+    rescue StackUnderflow
+      return nil
+    end
+
+    def reduce
+      @generator ||= Enumerator.new{|e| evaluate(self.tree, e) }
+      begin
+        @generator.next
+        self
+      rescue StopIteration
+        nil
+      end
+    end
+
+    def run(&blk)
+      if blk
+        while reduce
+          blk.call(self)
+        end
+      else
+        evaluate(self.tree, nil)
+      end
+    end
+  end
+end

data/lib/razyk/webapp/templates/main.html

@@ -0,0 +1,69 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+<html>
+<head>
+  <title>RazyK</title>
+  <script type="text/javascript" src="http://ajax.googleapis.com/ajax/libs/jquery/1.3.2/jquery.min.js"></script>
+  <script type="text/javascript">
+    function update() {
+      if ($("#program_mode").is(":checked")) {
+        $("#output_buffer").load("/stdout");
+      }
+      $("#expression").load("/expression");
+      $("#graph").attr("src", "/graph");
+    }
+    function set_program() {
+      $.post("/set_program",
+             {
+               program: $("#program").val(),
+               mode: $("#program_mode").is(":checked"),
+               stdin: $("#input_buffer").val()
+             },
+             function() {
+               update();
+             }, "json");
+    }
+
+    function step_reduction() {
+      $.get("/step", {},
+            function() {
+               update();
+            });
+    }
+
+    function toggle_mode() {
+      if ($("#program_mode").is(":checked")) {
+        $("#inout_pane").show("fast");
+      } else {
+        $("#inout_pane").hide("fast");
+      }
+    }
+  </script>
+</head>
+<body>
+  <p><div>enter program</div>
+  <textarea id="program" cols="100">skki</textarea>
+  </p>
+  <p>
+  <input type="checkbox" id="program_mode" onchange="toggle_mode();" />
+  <span>LazyK application mode</span>
+  </p>
+  <p>
+  <input type="button" value="set program" onclick="set_program();" />
+  <input type="button" value="step" onclick="step_reduction();" />
+  </p>
+  <span id="inout_pane" style="display: none">
+    <div>stdin</div>
+    <textarea id="input_buffer" cols="100"></textarea>
+    <div>stdout</div>
+    <div id="output_buffer"></div>
+  </span>
+  <p>
+    <div>combinator expression</div>
+    <div id="expression"> </div>
+  </p>
+  <p>graph expression</p>
+  <iframe id="graph" height="1000" width="100%">
+    using iframe.
+  </iframe>
+</body>
+</html>

data/lib/razyk/webapp.rb

@@ -0,0 +1,161 @@
+
+require "rack"
+require "tempfile"
+require "thread"
+require "stringio"
+
+require "razyk/graph"
+
+module RazyK
+  class WebApp
+    def initialize
+      reset
+    end
+
+    def reset
+      @vm = nil
+      @graph = 0
+      @step = 0
+      @thread = nil
+      @port_in = StringIO.new
+      @port_out = StringIO.new
+      @queue = Queue.new
+    end
+
+    def template(name)
+      File.join(File.dirname(File.expand_path(__FILE__)), "webapp", "templates", name)
+    end
+
+    def main_page(req)
+      reset
+      res = Rack::Response.new
+      res.status = 200
+      res.write File.read(template("main.html"))
+      res
+    end
+
+    def not_found(req)
+      res = Rack::Response.new
+      res.status = 404
+      res.write(<<-EOF)
+        <html><head><title>#{req.path} is not found</title></head>
+        <body>#{req.path} is not found</body></html>
+      EOF
+      res
+    end
+
+    def reduce_thread(vm)
+      while q = @queue.pop
+        begin
+          q.push(vm.reduce)
+        rescue
+          q.push($!)
+        end
+      end
+    end
+
+    def set_program(req)
+      res = Rack::Response.new
+      begin
+        tree = RazyK::Parser.parse(req.params["program"])
+        if req.params["mode"] == "true"
+          root = Pair.new(:OUT, Pair.new(tree, :IN))
+          @port_in = StringIO.new(req.params["stdin"] || "")
+          recursive = false
+        else
+          root = tree
+          recursive = true
+        end
+        # discard previous vm and thread
+        if @thread
+          @thread.kill
+          @thread = nil
+        end
+        @vm = VM.new(root, @port_in, @port_out, recursive)
+        # start Thread for reduction
+        @thread = Thread.start do reduce_thread(@vm) end
+      rescue
+        res.status = 501
+        puts $!.message, $@
+        return res
+      end
+      res.header["Content-Type"] = "text/json"
+      res.write('{"status":"success"}')
+      res
+    end
+
+    def step(req)
+      res = Rack::Response.new
+      res.header["Content-Type"] = "text/plain"
+      if @thread
+        rep = Queue.new
+        @queue.push(rep)
+        ret = rep.pop
+        if ret.is_a?(Exception)
+          raise ret
+        end
+        if ret
+          @step += 1
+        end
+        res.write("OK")
+      else
+        res.write("enter program first")
+      end
+      res
+    end
+
+    def stdout(req)
+      res = Rack::Response.new
+      res.header["Content-Type"] = "text/plain"
+      res.write(@port_out.string.inspect)
+      res
+    end
+
+    def expression(req)
+      res = Rack::Response.new
+      res.header["Content-Type"] = "text/plain"
+      if @vm
+        res.write(@vm.tree.inspect)
+      else
+        res.write("enter program first")
+      end
+      res
+    end
+
+    def graph(req)
+      res = Rack::Response.new
+      if @vm
+        res.header["Content-Type"] = "image/svg+xml"
+        tmpfile = Tempfile.new("razyk_graph")
+        RazyK::Graph.graph(@vm.tree, :style => :dag).output(:svg => tmpfile.path)
+        res.write(tmpfile.read)
+        tmpfile.unlink
+      else
+        res.header["Content-Type"] = "text/plain"
+        res.write("enter program first")
+      end
+      res
+    end
+
+    def call(env)
+      req = Rack::Request.new(env)
+      case req.path
+      when "/"
+        res = main_page(req)
+      when "/set_program"
+        res = set_program(req)
+      when "/step"
+        res = step(req)
+      when "/stdout"
+        res = stdout(req)
+      when "/expression"
+        res = expression(req)
+      when "/graph"
+        res = graph(req)
+      else
+        res = not_found(req)
+      end
+      res.finish
+    end
+  end
+end

data/lib/razyk.rb

@@ -0,0 +1,20 @@
+
+require "razyk/node"
+require "razyk/parser"
+require "razyk/vm"
+
+module RazyK
+  def self.run(program, opt={}, &blk)
+    opt[:input] ||= $stdin
+    opt[:output] ||= $stdout
+    tree = Parser.parse(program, opt)
+    root = Pair.new(:OUT, Pair.new(tree, :IN))
+    vm = VM.new(root, opt[:input], opt[:output])
+
+    if blk
+      vm.run(&blk)
+    else
+      vm.run
+    end
+  end
+end