faultier-esoteric 0.0.1 → 0.0.2

data/lib/esoteric/parser.rb

@@ -0,0 +1,149 @@
+# coding: utf-8
+
+require 'logger'
+
+module Esoteric
+  class ProcessInterrapt < StandardError; end
+  class LoopInterrapt < StandardError; end
+
+  class Parser
+    def self.parse(src, logger = nil)
+      new(src, logger).parse
+    end
+
+    def initialize(src, logger = nil)
+      @src    = normalize(src)
+      @ast    = []
+      unless @logger = logger
+        @logger = Logger.new(STDOUT)
+        @logger.level = Logger::ERROR
+      end
+    end
+
+    def parse
+      while exp = process
+        if exp.first == :defn
+          @ast.unshift exp
+        else
+          @ast.push exp
+        end
+      end
+      @ast.unshift :block
+      @ast
+    end
+
+    private 
+
+    def normalize(src)
+      src
+    end
+
+    def next_token
+      nil
+    end
+
+    def process
+      next_token
+    end
+
+    def process_until(terminate_expr)
+      block = [:block]
+      begin
+        until terminate_expr.call(next_token)
+          block << process 
+          break if block.last.nil?
+        end
+      rescue LoopInterrapt
+      end
+      block
+    end
+
+    def exp_arglist(args=[])
+      _arglist = [:arglist]
+      _arglist += args unless args.empty?
+      _arglist
+    end
+
+    def exp_defn_arglist(args=[])
+      _arglist = [:args]
+      _arglist += args unless args.empty?
+      _arglist
+    end
+
+    def exp_defn(name, *args)
+      [:defn, name, [:scope, [:block, exp_defn_arglist(args), yield]]]
+    end
+
+    def exp_mcall(receiver, name, *args)
+      [:call, receiver, name, exp_arglist(args)]
+    end
+
+    def exp_fcall(name, *args)
+      exp_mcall(nil, name, *args)
+    end
+
+    def exp_variable(scope, name)
+      [scope, name]
+    end
+
+    def exp_gvar(name)
+      exp_variable :gvar, "$#{name}".intern
+    end
+
+    def exp_gvarcall(name, *args)
+      exp_mcall exp_gvar(name), *args
+    end
+
+    def exp_lvar(name)
+      exp_variable :lvar, name
+    end
+
+    def exp_lvarcall(name, *args)
+      exp_mcall exp_lvar(name), *args
+    end
+
+    def exp_assign(scope, name, value)
+      [scope, name, value]
+    end
+
+    def exp_gasgn(name, value)
+      exp_assign :gasgn, "$#{name}".intern, value
+    end
+
+    def exp_opgasgn(name, operator, value)
+      exp_gasgn name, exp_gvarcall(name, operator, value)
+    end
+
+    def exp_lasgn(name, value)
+      exp_assign :lasgn, name, value
+    end
+
+    def exp_oplasgn(name, operator, value)
+      exp_lasgn name, exp_lvarcall(name, operator, value)
+    end
+
+    def exp_literal(value)
+      [:lit, value]
+    end
+
+    def exp_condition(name, cond, tblock, fblock=nil)
+      [name, cond, tblock, fblock]
+    end
+
+    def exp_if(cond, tblock, fblock=nil)
+      exp_condition :if, cond, tblock, fblock
+    end
+
+    def exp_block(*args)
+      [:block, *args]
+    end
+
+    def numeric(value)
+      value.to_i
+    end
+
+    def string(value)
+      value.to_s
+    end
+  end
+end

data/lib/esoteric/runner.rb

@@ -4,35 +4,36 @@ require 'logger'
 
 module Esoteric
   class Runner
-    def self.run(source, compiler, vm, options={}, logger=nil)
+    def self.parse_option
+      require 'optparse'
+      source   = nil
+      options  = {}
+      OptionParser.new {|opt|
+        opt.on('-e EXPR') {|v| source = v }
+        opt.on('-i','--interactive') { options[:interactive] = true }
+        opt.on('-c','--check-only') { options[:checkonly] = true }
+        opt.on('-d','--debug') { options[:loglevel] = Logger::DEBUG }
+        opt.on('-w','--warning') { options[:loglevel] ||= Logger::WARN }
+        opt.on('-v','--version') { puts $esoteric_bin_version; exit 0 }
+        opt.parse!(ARGV)
+      }
+      source = ARGF.read unless source
+      return source, options
+    end
+
+    def self.run(source, parser, vm, options={}, logger=nil)
       logger ||= Logger.new(STDOUT)
       logger.level = options[:loglevel] if !!options[:loglevel]
       if options[:interactive]
         raise NotImplementedError
       else
-        esm = !!compiler ? compiler.compile(source) : source
+        ast = parser.parse(source)
         if options[:checkonly]
           puts 'Syntax OK'
         else
-          vm.run esm, logger
+          vm.run ast, logger
         end
       end
     end
   end
 end
-
-if defined?(ESOTERIC_BIN_VERSION)
-  require 'optparse'
-  $source   = nil
-  $options  = {}
-  OptionParser.new {|opt|
-    opt.on('-e EXPR') {|v| $source = v }
-    opt.on('-i','--interactive') { $options[:interactive] = true }
-    opt.on('-c','--check-only') { $options[:checkonly] = true }
-    opt.on('-d','--debug') { $options[:loglevel] = Logger::DEBUG }
-    opt.on('-w','--warning') { $options[:loglevel] ||= Logger::WARN }
-    opt.on('-v','--version') { puts ESOTERIC_BIN_VERSION; exit 0 }
-    opt.parse!(ARGV)
-  }
-  $source = ARGF.read unless $source
-end

data/lib/esoteric/tetete.rb

@@ -0,0 +1,10 @@
+# coding: utf-8
+
+require 'esoteric'
+require 'esoteric/tetete/parser'
+
+module Esoteric
+  module Tetete
+    VERSION = '0.0.1'
+  end
+end

data/lib/esoteric/tetete/parser.rb

@@ -0,0 +1,87 @@
+# coding: utf-8
+
+if RUBY_VERSION =~ /^1\.8\./
+  $KCODE = 'u'
+  require 'jcode'
+end
+
+require 'strscan'
+
+module Esoteric
+  module Tetete
+    class Parser < Esoteric::Parser
+      def initialize(src, logger = nil)
+        super
+        @s = StringScanner.new(@src)
+        @ast = [
+          exp_gasgn(:P, exp_literal(0)),
+          exp_gasgn(:B, [:array]),
+          exp_defn(:get_value) {
+            [:op_asgn1, exp_gvar(:B), exp_arglist([exp_gvar(:P)]), :"||", exp_literal(0)]
+          },
+          exp_defn(:set_value, :val) { exp_gvarcall(:B, :[]=, exp_gvar(:P), exp_lvar(:val)) }
+        ]
+      end
+
+      def parse
+        begin
+          loop do
+            exp = process
+            next unless !!exp
+            case exp.first
+            when :defn  then @ast.unshift exp
+            when :block then @ast += exp[1..-1]
+            else             @ast.push exp
+            end
+          end
+        rescue ProcessInterrapt
+          # do nothing
+        end
+        @ast.unshift :block
+#       require 'pp'; pp @ast
+        @ast
+      end
+
+      private
+
+      def normalize(src)
+        src.gsub! /\{.*\}/, ''
+        src
+      end
+
+      def process
+        case
+        when @s.eos?
+          raise ProcessInterrapt
+        when @s.scan(/ー(.+?)てー/m)
+          @s[1].split(//).inject([:block]) { |block, c| 
+            block << exp_fcall(:set_value, exp_literal(c))
+            block << exp_opgasgn(:P, :+, exp_literal(1))
+          }
+        when @s.scan(/ててー/)
+          exp_fcall :set_value, exp_mcall(exp_fcall(:get_value), :+, exp_literal(1))
+        when @s.scan(/てっー/)
+          exp_fcall :set_value, exp_mcall(exp_fcall(:get_value), :+, exp_literal(-1))
+        when @s.scan(/てってー/)
+          exp_opgasgn :P, :+, exp_literal(1)
+        when @s.scan(/てっててー/)
+          exp_opgasgn :P, :+, exp_literal(-1)
+        when @s.scan(/てってっー/)
+          [:block, exp_fcall(:print, exp_fcall(:get_value)), exp_opgasgn(:P, :+, exp_literal(1))]
+        when @s.scan(/てってってー/)
+          [:block, exp_fcall(:set_value, exp_fcall(:getc)), exp_opgasgn(:P, :+, exp_literal(1))]
+        when @s.scan(/てってっててー/)
+          [:until,
+            exp_mcall(exp_fcall(:get_value), :==, exp_literal(0)),
+            process_until(lambda { |*args| @s.eos? || !!@s.match?(/てってってっー/) }),
+            nil
+          ]
+        when @s.scan(/てってってっー/)
+          raise LoopInterrapt
+        when @s.scan(/.[^てっー]*/m)
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/esoteric/vm.rb

@@ -3,21 +3,13 @@
 require 'logger'
 
 module Esoteric
-  class ProgramInterrapt < StandardError; end
-
   class VM
-    def self.run(esm, logger=nil)
-      new(esm,logger).run
+    def self.run(ast, logger=nil)
+      new(ast, logger).run
     end
 
-    def initialize(esm, logger=nil)
-      @insns    = parse(esm)
-      @stack    = []
-      @heap     = Hash.new { raise RuntimeError, 'can not read uninitialized heap value' }
-      @pc       = 0
-      @labels   = {}
-      @skip_to  = nil
-      @caller   = []
+    def initialize(ast, logger=nil)
+      @ast = ast
       unless @logger = logger
         @logger = Logger.new(STDOUT)
         @logger.level = Logger::ERROR
@@ -25,73 +17,13 @@ module Esoteric
     end
 
     def run
-      step while @pc < @insns.size
-      raise RuntimeError, ':exit missing'
-    rescue ProgramInterrapt => e
-      # successfully exit
+      raise NotImplementedError
     end
 
     private
 
-    def parse(asm)
-      asm.split(/\n/).map {|line|
-        next unless line =~ /([a-z]+)(?:[\s]+([\w]+))?/
-        cmd, arg = $1.intern, $2
-        arg ? [cmd, (arg =~ /\A[\d]+\z/ ? arg.to_i : arg)] : [cmd]
-      }.compact
-    end
-
     def step
-      insn, arg = *@insns[@pc]
-#     puts "@pc => #{@pc}, insn => #{insn}, @stack => #{@stack.inspect}, @heap => #{@heap.inspect}, @skip_to => #{@skip_to}, @labels => #{@labels.inspect}, @caller => #{@caller.inspect}"
-      if @skip_to.nil? || insn == :label
-        case insn
-        when :push    then push arg
-        when :dup     then value = pop; push value; push value
-        when :copy    then push @stack[-arg-1]
-        when :swap    then push *[pop, pop]
-        when :discard then pop
-        when :slide   then top = pop; arg.times { pop }; push top
-        when :add     then y, x = pop, pop; push x + y
-        when :sub     then y, x = pop, pop; push x - y
-        when :mul     then y, x = pop, pop; push x * y
-        when :div     then y, x = pop, pop; push (x / y).to_i
-        when :mod     then y, x = pop, pop; push x % y
-        when :hwrite  then value, address = pop, pop; @heap[address] = value
-        when :hread   then address = pop; push @heap[address]
-        when :label   then @labels[arg] ||= @pc; @skip_to = nil if @skip_to == arg
-        when :call    then @caller.push @pc; jump_to arg
-        when :jump    then jump_to arg
-        when :jumpz   then jump_to arg if pop == 0
-        when :jumpn   then jump_to arg if pop < 0
-        when :return  then raise RuntimeError, 'invalid return' if @caller.empty?; @pc = @caller.pop
-        when :exit    then raise ProgramInterrapt
-        when :cout    then print pop.chr
-        when :nout    then print pop
-        when :cin     then address = pop; @heap[address] = $stdin.getc.ord
-        when :nin     then address = pop; @heap[address] = $stdin.getc.to_i
-        end
-      end
-      @pc += 1
-    end
-
-    def push(value)
-      @stack.push value
-    end
-
-    def pop
-      @stack.pop
-    end
-
-    def jump_to(label)
-      unless @labels[label]
-        @skip_to = label
-        while @skip_to
-          raise RuntimeError, "label '#{label}' is missing" unless @pc < @insns.size
-          step
-        end
-      end
-      @pc = @labels[label]
+      raise NotImplementedError
     end
   end
 end

data/lib/esoteric/whitespace.rb

@@ -0,0 +1,10 @@
+# coding: utf-8
+
+require 'esoteric'
+require 'esoteric/whitespace/parser'
+
+module Esoteric
+  module Whitespace
+    VERSION = '0.0.2'
+  end
+end

data/lib/esoteric/whitespace/parser.rb

@@ -0,0 +1,139 @@
+# coding: utf-8
+
+require 'strscan'
+
+module Esoteric
+  module Whitespace
+    class Parser < Esoteric::Parser
+      NVAL    = /([ \t]+)\n/
+      LVAL    = NVAL
+      PUSH    = /  #{NVAL}/
+      DUP     = / \n /
+      COPY    = / \t #{NVAL}/
+      SWAP    = / \n\t/
+      DISCARD = / \n\n/
+      SLIDE   = / \t\n#{NVAL}/
+      ADD     = /\t   /
+      SUB     = /\t  \t/
+      MUL     = /\t  \n/
+      DIV     = /\t \t /
+      MOD     = /\t \t\t/
+      HWRITE  = /\t\t /
+      HREAD   = /\t\t\t/
+      LABEL   = /\n  #{LVAL}/
+      CALL    = /\n \t#{LVAL}/
+      JUMP    = /\n \n#{LVAL}/
+      JUMPZ   = /\n\t #{LVAL}/
+      JUMPN   = /\n\t\t#{LVAL}/
+      RETURN  = /\n\t\n/
+      EXIT    = /\n\n\n/
+      COUT    = /\t\n  /
+      NOUT    = /\t\n \t/
+      CIN     = /\t\n\t /
+      NIN     = /\t\n\t\t/
+
+      def initialize(src,logger=nil)
+        super
+        @s = StringScanner.new(@src)
+        @ast = [
+          [:gasgn, :$stack, [:array]],
+          [:gasgn, :$heap, [:hash]],
+        ]
+      end
+
+      def parse
+        begin
+          loop do
+            exp = process
+            next unless !!exp
+            if exp.first == :defn
+              @ast.unshift exp
+            else
+              @ast.push exp
+            end
+          end
+        rescue ProcessInterrapt
+          # do nothing
+        end
+        @ast.unshift :block
+#       require 'pp'; pp @ast
+        @ast
+      end
+
+      private
+
+      def normalize(src)
+        src.gsub(/[^ \t\n]/, '')
+      end
+
+      def process
+        case
+        when @s.eos?          then raise ProcessInterrapt
+        when @s.scan(PUSH)    then exp_push exp_literal(numeric(@s[1]))
+        when @s.scan(DUP)     then exp_push exp_gvarcall(:stack, :last)
+        when @s.scan(COPY)    then exp_push exp_gvarcall(:stack, :[], exp_literal(-(numeric(@s[1]))-1))
+        when @s.scan(SWAP)    then exp_push exp_pop, exp_pop
+        when @s.scan(DISCARD) then exp_pop
+        when @s.scan(SLIDE)   then
+          exp_block exp_lasgn(:top, exp_gvarcall(:stack, :pop)), exp_mcall(exp_literal(numeric(@s[1])), :times, exp_pop), exp_push(exp_lvar(:top))
+        when @s.scan(ADD)     then
+          exp_block exp_lasgn(:y, exp_pop), exp_lasgn(:x, exp_pop), exp_mcallpush(exp_lvar(:x), :+, exp_lvar(:y))
+        when @s.scan(SUB)     then
+          exp_block exp_lasgn(:y, exp_pop), exp_lasgn(:x, exp_pop), exp_mcallpush(exp_lvar(:x), :-, exp_lvar(:y))
+        when @s.scan(MUL)     then
+          exp_block exp_lasgn(:y, exp_pop), exp_lasgn(:x, exp_pop), exp_mcallpush(exp_lvar(:x), :*, exp_lvar(:y))
+        when @s.scan(DIV)     then
+          exp_block exp_lasgn(:y, exp_pop), exp_lasgn(:x, exp_pop), exp_mcallpush(exp_lvar(:x), :/, exp_lvar(:y))
+        when @s.scan(MOD)     then
+          exp_block exp_lasgn(:y, exp_pop), exp_lasgn(:x, exp_pop), exp_mcallpush(exp_lvar(:x), :%, exp_lvar(:y))
+        when @s.scan(HWRITE)  then
+          exp_block exp_lasgn(:val, exp_pop), exp_lasgn(:addr, exp_pop), exp_gvarcall(:heap, :[]=, exp_lvar(:addr), exp_lvar(:val))
+        when @s.scan(HREAD)   then
+          exp_block exp_lasgn(:addr, exp_pop), exp_push(exp_gvarcall(:heap, :[], exp_lvar(:addr)))
+        when @s.scan(LABEL)   then
+          defn(string(@s[1]).intern) { process_until( lambda {|*args| @s.eos? || !!@s.match?(RETURN)} ) }
+        when @s.scan(CALL)    then exp_fcall(string(@s[1]).intern)
+        when @s.scan(JUMP)
+          exp_if exp_literal(true), exp_fcall(string(@s[1]).intern), process_until( lambda {|*args| @s.eos? || !!@s.match?(RETURN)} )
+        when @s.scan(JUMPZ)
+          exp_if exp_mcall(pop, :==, exp_literal(0)), exp_fcall(string(@s[1]).intern), process_until( lambda {|*args| @s.eos? || !!@s.match?(RETURN)} )
+        when @s.scan(JUMPN)
+          exp_if exp_mcall(pop, :<, exp_literal(0)), exp_fcall(string(@s[1]).intern), process_until( lambda {|*args| @s.eos? || !!@s.match?(RETURN)} )
+        when @s.scan(RETURN)  then nil
+        when @s.scan(EXIT)    then exp_fcall :exit, exp_literal(0)
+        when @s.scan(COUT)    then exp_gvarcall :stdout, :print, exp_mcall(exp_pop, :chr)
+        when @s.scan(NOUT)    then exp_gvarcall :stdout, :print, exp_mcall(exp_pop, :to_i)
+        when @s.scan(CIN)     then exp_mcallpush exp_gvarcall(:stdin, :getc), :ord
+        when @s.scan(NIN)     then exp_mcallpush exp_gvarcall(:stdin, :getc), :to_i
+        else raise SyntaxError
+        end
+      end
+
+      def exp_pop
+        exp_gvarcall :stack, :pop
+      end
+
+      def exp_push(value)
+        exp_gvarcall :stack, :push, value
+      end
+
+      def exp_mcallpush(receiver, method, *args)
+        exp_push exp_mcall(receiver, method, *args)
+      end
+
+      def numeric(value)
+        raise ArgumentError if "#{value}\n" !~ /\A#{NVAL}\z/
+        n = value.sub(/\A /, '+').
+                  sub(/\A\t/, '-').
+                  gsub(/ /, '0').
+                  gsub(/\t/, '1')
+        n.to_i(2)
+      end
+
+      def string(value)
+        raise ArgumentError if "#{value}\n" !~ /\A#{LVAL}\z/
+        value.gsub(/ /, 's').gsub(/\t/, 't')
+      end
+    end
+  end
+end