AmberVM 0.0.19

data/lib/amber/fukubukuro.rb

@@ -0,0 +1,866 @@
+# Define true? and false? methods on Ruby classes that behaves like JavaScript's truthyness.
+class Object
+  def false?; false; end
+  def true?; !false?; end
+end
+class TrueClass
+  def true?; true; end
+  def false?; false; end
+end
+class Symbol
+  def false?; self == :undefined; end
+end
+[FalseClass, NilClass].each do |klass|
+  klass.class_eval do
+    def false?; true; end
+    def true?; false; end
+  end
+end
+[Fixnum, Bignum, Float].each do |klass|
+  klass.class_eval do
+    alias false? zero?
+  end
+end
+[Array, Hash, String].each do |klass|
+  klass.class_eval do
+    alias false? empty?
+  end
+end
+
+class Numeric
+  def inc; self + 1; end
+  def dec; self - 1; end
+end
+
+class Integer
+  def logical_shift_right positions = 1, bit_size = 32
+    raise ArgumentError, 'negative argument for logical_shift_right' if positions < 0
+    positions = positions.to_i if positions.is_a? Float
+    positions = bit_size if positions > bit_size
+    bits = (0...bit_size).map { |i| self[i] }.reverse
+    bits = [0] * positions + bits[0, bit_size - positions]
+    bits.join.to_i(2)
+  end
+  alias lsr logical_shift_right
+end
+class Float
+  def logical_shift_right positions = 1, bit_size = 32
+    (to_i % 2 ** bit_size).logical_shift_right positions, bit_size
+  end
+  alias lsr logical_shift_right
+end
+
+# automatic type cast for JavaScript
+class Float
+  def to_str
+    to_s.chomp('.0')
+  end
+end
+
+unless defined? define_singleton_method()
+  module Kernel
+    def define_singleton_method name, &block
+      (class << self; self; end).send :define_method, name, &block
+    end
+  end
+end
+
+module Fukubukuro
+  
+  module VM
+    class << self
+      def print *args
+        $stdout.print(*args)
+      end
+      def new_array
+        []
+      end
+      def sin a
+        Math.sin a
+      end
+      def cos a
+        Math.cos a
+      end
+      def power base, exp
+        base ** exp
+      end
+    end
+  end
+  
+  class Sequence < Array
+    def call
+      for statement in self
+        value = statement.call
+      end
+      value
+    end
+    alias value call
+    def inspect
+      self.class.inspect + super
+    end
+    def pretty_print q
+      q.text self.class.inspect
+      super
+    end
+    def self.inspect
+      'Sequence'
+    end
+  end
+  
+  class Environment < Hash
+    def self.new
+      super do |h, k|
+        h[k] = Variable.new
+      end
+    end
+  end
+  
+  class Program < Sequence
+    attr_accessor :environment
+    def initialize statements = Sequence[], environment = Environment.new
+      super(statements)
+      self.environment = environment
+    end
+    def self.inspect
+      'Program'
+    end
+    def ruby_to_amber object
+      raise NotImplementedError
+    end
+    def amber_to_ruby container
+      if container.respond_to? :to_ruby
+        container.to_ruby
+      else
+        container
+      end
+    end
+    def execute env
+      if env.is_a? Hash
+        for name in env.keys
+          environment[name.to_sym].value = ruby_to_amber env[name]
+        end
+      else
+        raise 'Expected Hash as environment, got %p' % [env]
+      end
+      result = call
+      if env.is_a? Hash
+        for name, variable in environment
+          env[name] = env[name.to_s] = amber_to_ruby(variable.value)
+        end
+      end
+      amber_to_ruby result
+    end
+    def optimize
+      self
+    end
+  end
+  
+  class Statement < Proc
+    alias value call
+  end
+  
+  # class MathStatement < Statement
+  #   def self.new method, *args
+  #     if args.size == 1
+  #       arg = args.first
+  #       super() do
+  #         ::Math.send method, arg.value
+  #       end
+  #     else
+  #       super() do
+  #         ::Math.send method, *args.map { |a| a.value }
+  #       end
+  #     end
+  #   end
+  # end
+  
+  # class DebugStatement < Statement
+  #   def self.new *args
+  #     super() do
+  #       puts 'fuku-debug: ' + args.map { |a| a.value }.join(', ')
+  #     end
+  #   end
+  # end
+  
+  # def debug *args
+  #   DebugStatement.new(*args)
+  # end
+  
+  class CoreCall < Statement
+    def self.new method, *args
+      super() do
+        ECMA.make_core_object_from VM.send(method, *args.map { |arg| arg.value.to_ruby })
+      end
+    end
+  end
+  
+  class IfCondition < Statement
+    def self.new condition, true_block, false_block = nil
+      if true_block && false_block
+        super() do
+          if condition.call.true?
+            true_block.call
+          else
+            false_block.call
+          end
+        end
+      elsif true_block
+        super() do
+          true_block.call if condition.call.true?
+        end
+      elsif false_block
+        super() do
+          false_block.call if condition.call.false?
+        end
+      else
+        super() do
+          condition.call
+        end
+      end
+    end
+  end
+  
+  class ShortCircuitAnd < Statement
+    def self.new first, second
+      super() do
+        if (first_value = first.value).true?
+          if (second_value = second.value).true?
+            second_value
+          else
+            first_value
+          end
+        else
+          first_value
+        end
+      end
+    end
+  end
+  
+  class ShortCircuitOr < Statement
+    def self.new first, second
+      super() do
+        if (first_value = first.value).true?
+          value
+        else
+          second.value
+        end
+      end
+    end
+  end
+  
+  class ConditionalLoop < Statement
+    attr_accessor :condition, :block
+    def inspect
+      self.class.inspect + '(%p) {}' % [condition, block]
+    end
+    def pretty_print q
+      q.text self.class.inspect
+      q.group 2, '(', ')' do
+        q.pp condition
+      end
+      q.group 2, ' { ', ' }' do
+        q.pp block
+      end
+    end
+  end
+  
+  class WhileLoop < ConditionalLoop
+    def self.new condition, block
+      if block.is_a? Sequence
+        case block.size
+        when 0
+          loop = super() do
+            until condition.call.false?
+            end
+          end
+        when 1
+          statement = block[0]
+          loop = super() do
+            until condition.call.false?
+              statement.call
+            end
+          end
+        when 2
+          statement1 = block[0]
+          statement2 = block[1]
+          loop = super() do
+            until condition.call.false?
+              statement1.call
+              statement2.call
+            end
+          end
+        else
+          loop = super() do
+            until condition.call.false?
+              for statement in block
+                statement.call
+              end
+            end
+          end
+        end
+      else
+        loop = super() do
+          until condition.call.false?
+            block.call
+          end
+        end
+      end
+      loop.condition = condition
+      loop.block = block
+      loop
+    end
+    def self.inspect
+      'WhileLoop'
+    end
+  end
+  
+  class DoWhileLoop < ConditionalLoop
+    def self.new condition, block
+      loop = super() do
+        if block.is_a? Sequence
+          begin
+            for statement in block
+              statement.call
+            end
+          end until condition.call.false?
+        else
+          raise 'Expected Sequence, got %p' % block
+          begin
+            block.call
+          end until condition.call.false?
+        end
+      end
+      loop.condition = condition
+      loop.block = block
+      loop
+    end
+    def self.inspect
+      'DoWhileLoop'
+    end
+  end
+  
+  # Just for convenience. Call like this:
+  # 
+  #  ForLoop.new(
+  #    Assignment.new(i, 1),
+  #    MethodCall.new(i, :<=, n),
+  #    Assignment.new(i, MethodCall.new(i, :+, C(1)))),
+  #    Sequence[
+  #      ...
+  #    ]
+  class ForLoop
+    def self.new start, condition, increment, block
+      Sequence[
+        start,
+        WhileLoop.new(condition,
+          Sequence[
+            block,
+            increment
+          ]
+        )
+      ]
+    end
+  end
+  
+  class Assignment < Statement
+    attr_accessor :receiver, :statement
+    def self.new receiver, statement
+      if receiver.is_a? MethodCall
+        if receiver.meth == :[]
+          index = receiver.args.first
+          MethodCall.new(receiver.object, :[]=, index, statement)
+        elsif receiver.meth == :fuku_send
+          getter = receiver.args.first.value
+          setter = Constant.new(:"#{getter}=")
+          MethodCall.new(receiver.object, :fuku_send, setter, statement)
+        else
+          raise 'Cannot assign to method calls.'
+        end
+      elsif statement.is_a? MethodCall
+        MethodCallAssignment.new receiver, statement.object, statement.meth, *statement.args
+      else
+        assignment = super() do
+          receiver.value = statement.call
+        end
+        assignment.receiver = receiver
+        assignment.statement = statement
+        assignment
+      end
+    end
+    def inspect
+      'Assignment(%p = %p)' % [receiver, statement]
+    end
+    def pretty_print q
+      q.group 2, 'Assignment(', ')' do
+        q.pp receiver
+        q.text ' = '
+        q.pp statement
+      end
+    end
+  end
+  
+  def ass *args
+    Assignment.new(*args)
+  end
+  
+  VARIABLE_IMPLEMENTATION_METHOD = ENV.fetch 'fuku_container', 'object'
+  # puts "using #{VARIABLE_IMPLEMENTATION_METHOD} for variable containers"
+  
+  case VARIABLE_IMPLEMENTATION_METHOD
+  when 'object'
+    class Variable
+      attr_accessor :value
+      def initialize value = nil
+        @value = value
+      end
+    end
+  when 'container'
+    class Variable < Container
+    end
+  when 'array'
+    class Variable < Array
+      class << self
+        alias new []
+      end
+      alias value first
+      if false && [].respond_to?(:first=)
+        puts 'using Array#first='
+        alias value= first=
+      else
+        def value= value
+          self[0] = value
+        end
+      end
+    end
+  else
+    raise
+  end
+  
+  class Variable
+    class << self
+      attr_reader :running_numbers
+    end
+    running_number = 0
+    @running_numbers = Hash.new do |h, k|
+      h[k] = running_number += 1
+    end
+    alias call value
+    def inspect
+      'Variable%p(%p)' % [
+        name ? name.to_sym : Variable.running_numbers[self],
+        value
+      ]
+    end
+    def pretty_print q
+      q.text inspect
+    end
+    attr_accessor :name
+  end
+  
+  def Variables count
+    # Array.new(count) { StackVariable[nil] }
+    Array.new(count) { Variable.new nil }
+  end
+  
+  def var
+    Variable.new
+  end
+  
+  class Constant < Variable
+    def inspect
+      'Constant(' + value.inspect + ')'
+    end
+  end
+  
+  class CastException < ::RuntimeError
+    attr_accessor :new_value, :result
+    def initialize new_value, result
+      self.new_value = new_value
+      self.result = result
+    end
+  end
+  
+  class MethodCall < Statement
+    attr_accessor :object, :meth, :args
+    def self.new object, method, *args
+      if method == :fuku_call && object.is_a?(MethodCall) && object.meth == :fuku_send
+        return new(object.object, :fuku_method_call, object.args.first, *args)
+      end
+      method_call =
+        if args.empty?
+          super() do
+            begin
+              object.value.send method
+            rescue CastException => boom
+              object.value = boom.new_value
+              boom.result
+            end
+          end
+        elsif args.all? { |arg| arg.is_a? Constant }
+          if args.size == 1
+            arg = args.first.value
+            super() do
+              begin
+                object.value.send method, arg
+              rescue ::NoMethodError
+                if object.value == nil
+                  raise 'Variable %s not defined' % object.name
+                else
+                  raise
+                end
+              end
+            end
+          else
+            args = args.map { |a| a.value }
+            super() do
+              object.value.send method, *args
+            end
+          end
+        else
+          if args.size == 1
+            arg = args.first
+            super() do
+              object.value.send method, arg.value
+            end
+          else
+            super() do
+              object.value.send method, *args.map { |a| a.value }
+            end
+          end
+        end
+      method_call.object = object
+      method_call.meth = method
+      method_call.args = args
+      method_call
+    end
+    alias value call
+    def inspect
+      'MethodCall:%p.%p(%p)' % [object, meth, args.join(', ')]
+    end
+    def pretty_print q
+      q.text 'MethodCall:'
+      q.pp object
+      q.text '.'
+      q.pp meth
+      q.group 2, '(', ')' do
+        q.pp args
+      end
+    end
+  end
+  
+  def meth *args
+    MethodCall.new(*args)
+  end
+  
+  class MethodCallAssignment < Statement
+    attr_accessor :receiver, :object, :meth, :args
+    def self.new receiver, object, meth, *args
+      method_call_assignment = if args.empty?
+        super() do
+          receiver.value = object.value.send meth
+        end
+      elsif args.all? { |arg| arg.is_a? Constant }
+        if args.size == 1
+          value = args.first.value
+          super() do
+            receiver.value = object.value.send meth, value
+          end
+        else
+          raise
+          args = args.map(&:value)
+          super() do
+            receiver.value = object.value.send meth, *args
+          end
+        end
+      else
+        if args.size == 1
+          arg = args.first
+          super() do
+            receiver.value = object.value.send meth, arg.value
+          end
+        else
+          super() do
+            receiver.value = object.value.send meth, *args.map { |a| a.value }
+          end
+        end
+      end
+      method_call_assignment.receiver = receiver
+      method_call_assignment.object = object
+      method_call_assignment.meth = meth
+      method_call_assignment.args = args
+      method_call_assignment
+    end
+    alias value call
+    def inspect
+      'MethodCallAssignment(%p = %p.%p(%p))' % [receiver, object, meth, args]
+    end
+    def pretty_print q
+      q.group 2, 'MethodCallAssignment(', ')' do
+        q.pp receiver
+        q.text ' = '
+        q.pp object
+        q.text '.'
+        q.pp meth
+        q.group 2, '(', ')' do
+          q.pp args
+        end
+      end
+    end
+  end
+  
+  class FunctionDefinition < Statement
+    attr_accessor :signature, :block
+    def self.new signature, block
+      function_definition = super() do
+        Function.new signature, block
+      end
+      function_definition.signature = signature
+      function_definition.block = block
+      function_definition
+    end
+    def inspect
+      'FunctionDefintion(%p) { %p }' % [signature, block]
+    end
+    def pretty_print q
+      q.group 2, 'FunctionDefintion(', ')' do
+        q.pp signature
+      end
+      q.group 2, ' { ', ' }' do
+        q.pp block
+      end
+    end
+  end
+  
+  class Function < Statement
+    def self.new signature, block
+      case signature.size
+      when 0
+        super() do
+          catch :return do
+            block.call
+            raise 'no return'
+          end
+        end
+      when 1
+        param = signature.first
+        super() do |arg|
+          param.value = arg
+          catch :return do
+            block.call
+            raise 'no return'
+          end
+        end
+      else
+        super() do |*arguments|
+          for i in 0...signature.size
+            signature[i].value = arguments[i]
+          end
+          catch :return do
+            block.call
+            raise 'no return'
+          end
+        end
+      end
+    end
+    alias fuku_call call
+    def to_ruby
+      function = self
+      proc do |*args|
+        function.call(*args).to_ruby
+      end
+    end
+  end
+  
+  # class CachingFunction < Statement
+  #   def self.new signature, block
+  #     raise
+  #     case signature.size
+  #     when 0
+  #       cache = nil
+  #       super() do
+  #         cache ||= block.call
+  #       end
+  #     when 1
+  #       signature_first = signature.first
+  #       cache = {}
+  #       super() do |value|
+  #         cache.delete cache.first.first if cache.size >= 16
+  #         cache[value] ||= begin
+  #           signature_first.value = value
+  #           block.call
+  #         end
+  #       end
+  #     else
+  #       cache = {}
+  #       super() do |values|
+  #         cache.delete cache.first.first if cache.size >= 16
+  #         cache[values] ||= begin
+  #           for i in 0...signature.size
+  #             signature[i].value = values[i]
+  #           end
+  #           block.call
+  #         end
+  #       end
+  #     end
+  #   end
+  # end
+  
+  # class StackVariable < Array
+  #   alias value last
+  #   def value= value
+  #     self[-1] = value
+  #   end
+  #   alias call value
+  # end
+  
+  # class RecursiveFunction
+  #   attr_accessor :signature
+  #   def initialize signature, block = nil
+  #     @signature = signature
+  #     self.block = block
+  #   end
+  #   def block= block
+  #     case signature.size
+  #     when 0
+  #       define_singleton_method :call do
+  #         block.call
+  #       end
+  #     when 1
+  #       param = signature.first
+  #       define_singleton_method :call do |value|
+  #         param.push value
+  #         result = block.call
+  #         param.pop
+  #         result
+  #       end
+  #     else
+  #       raise
+  #       define_singleton_method :call do |values|
+  #         for i in 0...signature.size
+  #           signature[i].push values[i]
+  #         end
+  #         result = block.call
+  #         for var in signature
+  #           var.pop
+  #         end
+  #         result
+  #       end
+  #     end
+  #   end
+  # end
+  
+  # class CachingRecursiveFunction
+  #   attr_accessor :signature
+  #   def initialize signature
+  #     @signature = signature
+  #   end
+  #   def block= block
+  #     case signature.size
+  #     when 0
+  #       raise
+  #       cache = nil
+  #       define_singleton_method :call do
+  #         cache ||= block.call
+  #       end
+  #     when 1
+  #       signature_first = signature.first
+  #       cache = {}
+  #       define_singleton_method :call do |value|
+  #         value = cache[value] ||= begin
+  #           signature_first.push value
+  #           result = block.call
+  #           signature_first.pop
+  #           result
+  #         end
+  #         cache.delete cache.first.first if cache.size >= 8
+  #         value
+  #       end
+  #     else
+  #       cache = {}
+  #       define_singleton_method :call do |values|
+  #         values = cache[values] ||= begin
+  #           for i in 0...signature.size
+  #             signature[i].push values[i]
+  #           end
+  #           result = block.call
+  #           for var in signature
+  #             var.pop
+  #           end
+  #           result
+  #         end
+  #         cache.delete cache.first.first if cache.size >= 8
+  #         values
+  #       end
+  #     end
+  #   end
+  # end
+  
+  # class FunctionCall < Statement
+  #   def self.new function, *arguments
+  #     if false  # cacheable?
+  #       case arguments.size
+  #       when 0
+  #         raise
+  #         cache = nil
+  #         super() do
+  #           cache ||= function.call
+  #         end
+  #       when 1
+  #         arg = arguments.first
+  #         super() do
+  #           function.call(arg.value)
+  #         end
+  #       else
+  #         raise
+  #         cache = {}
+  #         super() do
+  #           cache.delete cache.first.first if cache.size >= 16
+  #           values = arguments.map { |a| a.value }
+  #           cache[values] ||= function.call(values)
+  #         end
+  #       end
+  #     else
+  #       case arguments.size
+  #       when 0
+  #         super() do
+  #           function.call
+  #         end
+  #       when 1
+  #         arg = arguments.first
+  #         super() do
+  #           function.call(arg.value)
+  #         end
+  #       else
+  #         super() do
+  #           function.call(*arguments.map { |a| a.value })
+  #         end
+  #       end
+  #     end
+  #   end
+  # end
+  
+  class ReturnStatement < Statement
+    def self.new result
+      super() do
+        throw :return, result.value
+      end
+    end
+  end
+  
+  class << CurrentReceiver = Object.new
+    attr_accessor :value
+    def set value
+      # puts 'CurrentReceiver set to %p.' % [value]
+      self.value = value
+    end
+    def inspect
+      'CurrentReceiver(%p)' % [
+        value
+      ]
+    end
+    def pretty_print q
+      q.text inspect
+    end
+  end
+  
+end