eleetscript 0.0.2a

data/lib/lang/runtime/array.rb

@@ -0,0 +1,23 @@
+module EleetScript
+  class EleetScriptArray < EleetScriptClass
+    attr_reader :hash, :array
+
+    def initialize(memory, super_class = nil)
+      super(memory, super_class)
+      @hash = {}
+      @array = []
+    end
+
+    def to_s
+      str = "<EleetScriptArray"
+      hash_data = @hash.map do |key, value|
+        "#{key}=#{value}"
+      end
+      data = @array.dup.concat(hash_data)
+      if data.length > 0
+        str += "[" + data.join(", ") + "]"
+      end
+      str + ">"
+    end
+  end
+end

data/lib/lang/runtime/base_classes.rb

@@ -0,0 +1,31 @@
+module EleetScript
+  class ListBase
+    attr_reader :array_value, :hash_value
+
+    def initialize(nil_val)
+      @array_value = []
+      @hash_value = Hash.new(nil_val)
+    end
+
+    def merge!(o)
+      @array_value.concat(o.array_value)
+      @hash_value.merge!(o.hash_value)
+    end
+
+    def clone
+      dup
+    end
+
+    def dup
+      lst = ListBase.new
+      lst.array_value = @array_value.dup
+      lst.hash_value = @hash_value.dup
+      lst
+    end
+
+    def clear
+      @array_value.clear
+      @hash_value.clear
+    end
+  end
+end

data/lib/lang/runtime/bootstrap.rb

@@ -0,0 +1,3 @@
+module EleetScript
+
+end

data/lib/lang/runtime/class.rb

@@ -0,0 +1,113 @@
+require "lang/runtime/class_skeleton"
+require "lang/runtime/class_instance"
+require "lang/runtime/method_hash"
+require "util/processed_key_hash"
+
+module EleetScript
+  class EleetScriptClass < EleetScriptClassSkeleton
+    attr_accessor :methods, :class_vars, :context, :name
+    attr_reader :super_class
+    set_is_class
+
+    class << self
+      def create(namespace, name, super_class = nil)
+        cls = EleetScriptClass.new(namespace, super_class)
+        cls.name = name
+        cls
+      end
+    end
+
+    def initialize(namespace, super_class = nil)
+      @methods = MethodHash.new
+      @class_vars = ProcessedKeyHash.new
+      @class_vars.set_key_preprocessor do |key|
+        key[0..1] == "@@" ? key[2..-1] : key
+      end
+      @context = namespace.new_class_context(self, self)
+      @super_class = super_class
+      @ruby_value = self
+    end
+    alias :class_name :name
+
+    def call(method_name, arguments = [])
+      method = lookup(method_name.to_s)
+      if method
+        if method.arity == 3
+          method.call(self, arguments, @context)
+        else
+          method.call(self, arguments)
+        end
+      else
+        es_method_name = @context["String"].new_with_value(method_name.to_s)
+        call(NO_METHOD, arguments.dup.unshift(es_method_name))
+      end
+    end
+
+    def lookup(method_name)
+      method_name = method_name[0..1] == "@@" ? method_name : "@@#{method_name}"
+      method = @methods[method_name]
+      if method.nil? && has_super_class?
+        return super_class.lookup(method_name)
+      end
+      method
+    end
+
+    def instance_lookup(method_name)
+      method = @methods[method_name]
+      if method.nil? && has_super_class?
+        return super_class.instance_lookup(method_name)
+      end
+      method
+    end
+
+    def super_class
+      @super_class || @context["Object"]
+    end
+
+    def def(method_name, es_block = nil, &block)
+      method_name = method_name.to_s
+      if block_given?
+        @methods[method_name] = block
+      else
+        @methods[method_name] = es_method
+      end
+    end
+
+    def class_def(method_name, es_block = nil, &block)
+      method_name = "@@#{method_name}"
+      if block_given?
+        @methods[method_name] = block
+      else
+        @methods[method_name] = es_method
+      end
+    end
+
+    def new
+      EleetScriptClassInstance.new(@context, self)
+    end
+
+    def new_with_value(value)
+      cls = EleetScriptClassInstance.new(@context, self)
+      cls.ruby_value = value
+      cls
+    end
+
+    def to_s
+      "<EleetScriptClass \"#{name || "Unnamed"}\">"
+    end
+
+    def inspect
+      to_s[0..-2] + " @methods(#{@methods.keys.join(", ")})>"
+    end
+
+    def is_a?(value)
+      false
+    end
+
+    private
+
+    def has_super_class?
+      @super_class || (@super_class.nil? && name != "Object")
+    end
+  end
+end

data/lib/lang/runtime/class_instance.rb

@@ -0,0 +1,53 @@
+module EleetScript
+  class EleetScriptClassInstance < EleetScriptClassSkeleton
+    attr_accessor :instance_vars, :runtime_class, :context
+    set_is_instance
+
+    def initialize(class_context, runtime_class)
+      @instance_vars = ProcessedKeyHash.new
+      @instance_vars.set_key_preprocessor do |key|
+        key[0] == "@" ? key[1..-1] : key
+      end
+      @runtime_class = runtime_class
+      @context = class_context.new_instance_context(self)
+      @ruby_value = self
+    end
+
+    def call(method_name, arguments = [])
+      # puts "Calling #{method_name} on #{self}"
+      method = @runtime_class.instance_lookup(method_name.to_s)
+      if method
+        if method.arity == 3
+          method.call(self, arguments, @context)
+        else
+          method.call(self, arguments)
+        end
+      else
+        es_method_name = @context["String"].new_with_value(method_name.to_s)
+        call(NO_METHOD, arguments.dup.unshift(es_method_name))
+      end
+    end
+
+    def to_s
+      "<EleetScriptClassInstance @instance_of=\"#{runtime_class.name || "Unnamed"}\">"
+    end
+
+    def inspect
+      to_s
+    end
+
+    def is_a?(value)
+      names = ["Object", runtime_class.name]
+      cur_class = runtime_class
+      while cur_class.super_class.name != "Object"
+        names << cur_class.super_class.name
+        cur_class = cur_class.super_class
+      end
+      names.include?(value)
+    end
+
+    def class_name
+      @runtime_class.name
+    end
+  end
+end

data/lib/lang/runtime/class_skeleton.rb

@@ -0,0 +1,57 @@
+module EleetScript
+  NO_METHOD = "no_method"
+
+  class EleetScriptClassSkeleton
+    attr_accessor :ruby_value
+    attr_reader :memory
+
+    class << self
+      def set_is_instance
+        self.class_eval do
+          def instance?
+            true
+          end
+        end
+      end
+
+      def set_is_class
+        self.class_eval do
+          def class?
+            true
+          end
+        end
+      end
+    end
+
+    def instance?
+      false
+    end
+
+    def class?
+      false
+    end
+
+    def is_a?(name)
+      false
+    end
+
+    def hash
+      if instance?
+        ruby_value.hash
+      else
+        name.hash
+      end
+    end
+
+    def eql?(other)
+      if other.kind_of?(EleetScriptClassSkeleton)
+        if instance?
+          return call(:is, [other]).ruby_value
+        elsif class? && other.class?
+          return name == other.name
+        end
+      end
+      false
+    end
+  end
+end

data/lib/lang/runtime/context.rb

@@ -0,0 +1,263 @@
+require "util/processed_key_hash"
+
+module EleetScript
+  class BaseContext
+    @@_init_funcs = []
+
+    attr_reader :constants, :local_vars, :global_vars, :namespaces
+    attr_accessor :current_self, :current_class
+
+    class << self
+      def init_with(*func_symbols)
+        @@_init_funcs += func_symbols
+      end
+    end
+
+    def initialize(*args)
+      init(args)
+      self
+    end
+
+    def es_nil
+      @_es_nil ||= self["nil"]
+    end
+
+    def root_ns
+      @parent_context ? @parent_context.root_ns : nil
+    end
+
+    def namespaces
+      @parent_context ? @parent_context.namespaces : {}
+    end
+
+    def global_vars
+      @parent_context ? @parent_context.global_vars : {}
+    end
+
+    def instance_vars
+      @current_self.instance_vars
+    end
+
+    def class_vars
+      @current_self.class_vars
+    end
+
+    def local_var(name, value = nil)
+      if value
+        local_vars[name] = value
+      else
+        local_vars[name] || es_nil
+      end
+    end
+
+    def [](key)
+      store = fetch_var_store(key)
+      if store[key]
+        store[key]
+      elsif @parent_context
+        @parent_context[key]
+      else
+        es_nil
+      end
+    end
+
+    def []=(key, value)
+      store = fetch_var_store(key)
+      store[key] = value
+    end
+
+    def respond_to_missing?(name, incl_priv = false)
+      @parent_context && @parent_context.respond_to?(name, incl_priv)
+    end
+
+    def method_missing(name, *args)
+      if @parent_context && @parent_context.respond_to?(name)
+        @parent_context.send(name, *args)
+      else
+        super(name, *args)
+      end
+    end
+
+    protected
+
+    def fetch_var_store(key)
+      if key[0] =~ /[A-Z]/
+        constants
+      elsif key[0] =~ /[a-z_]/
+        local_vars
+      elsif key[0] == "$"
+        global_vars
+      elsif key[0..1] == "@@"
+        class_vars
+      elsif key[0] == "@"
+        instance_vars
+      else
+        {}
+      end
+    end
+
+    def parent_context=(context)
+      @parent_context = context
+    end
+
+    private
+
+    def init(args)
+      throw "Arguments for new context should contain a current self and current class (even if both are nil)." if args.length < 2
+      @current_self = args.shift
+      cc = if args.length > 0
+        args.shift
+      else
+        nil
+      end
+      @current_class = if cc.nil?
+        if @current_self
+          if @current_self.class?
+            @current_self
+          else
+            @current_self.runtime_class
+          end
+        else
+          nil
+        end
+      else
+        cc
+      end
+      @parent_context = nil
+      @local_vars = ProcessedKeyHash.new
+      @constants = ProcessedKeyHash.new
+      @global_vars = {}
+      @namespaces = {}
+      @@_init_funcs.each do |symbol|
+        send(symbol, *args) if respond_to?(symbol, true)
+      end
+    end
+  end
+
+  class NamespaceContext < BaseContext
+    attr_reader :global_vars
+
+    init_with :init_namespace
+
+    def namespace(name)
+      ns = @namespaces[name]
+      if ns.nil? && @parent_context
+        ns = @parent_context.namespaces[ns]
+      end
+      ns
+    end
+
+    def add_namespace(name, value)
+      @namespaces[name] = value
+    end
+
+    def global_vars
+      if @root_ns == self
+        @global_vars
+      else
+        @root_ns.global_vars
+      end
+    end
+
+    def es_nil
+      @root_ns["nil"]
+    end
+
+    def root_ns
+      @root_ns
+    end
+
+    def new_class_context(current_self, current_class = nil)
+      ctx = ClassContext.new(current_self, current_class)
+      ctx.parent_context = self
+      ctx
+    end
+
+    def new_namespace_context
+      ctx = NamespaceContext.new(@current_self, @current_class, @root_ns)
+      ctx.parent_context = self
+      ctx
+    end
+
+    private
+
+    def init_namespace(root = nil)
+      if @root_ns == nil
+        @root_ns = self
+        @global_vars = ProcessedKeyHash.new
+        @global_vars.set_key_preprocessor do |key|
+          key[0] == "$" ? key[1..-1] : key
+        end
+      else
+        @root_ns = root
+      end
+    end
+  end
+
+  class ClassContext < BaseContext
+    def class_vars
+      @current_class.class_vars
+    end
+
+    def instance_vars
+      @parent_context ? @parent_context.instance_vars : {}
+    end
+
+    def new_instance_context(instance_self)
+      ctx = ClassInstanceContext.new(instance_self, current_class)
+      ctx.parent_context = self
+      ctx
+    end
+
+    def new_method_context(lambda_context = nil)
+      ctx = MethodContext.new(current_self, current_class, lambda_context)
+      ctx.parent_context = self
+      ctx
+    end
+  end
+
+  class ClassInstanceContext < BaseContext
+    def current_class
+      @parent_context.current_class
+    end
+
+    def local_vars
+      {}
+    end
+
+    def new_method_context(lambda_context = nil)
+      ctx = MethodContext.new(current_self, current_class, lambda_context)
+      ctx.parent_context = self
+      ctx
+    end
+  end
+
+  class MethodContext < BaseContext
+    init_with :handle_lambda_context
+
+    def local_var(name, value = nil)
+      if value
+        if @lambda_context && (val = @lambda_context.local_var(name))
+          @lambda_context.local_var(name, value)
+        else
+          local_vars[name] = value
+        end
+      else
+        val = super
+        if val == es_nil && @lambda_context
+          @lambda_context.local_var(name)
+        elsif val
+          val
+        else
+          es_nil
+        end
+      end
+    end
+
+    private
+
+    def handle_lambda_context(lambda_context)
+      @lambda_context = lambda_context
+    end
+  end
+end

data/lib/lang/runtime/eleetscript/enumerable.es

@@ -0,0 +1,36 @@
+class Enumerable
+  [] do |name|
+    cname = class_name
+    Errors < "Class %cname has not implemented [] which is required for Enumerable"
+  end
+
+  []= do |name, value|
+    cname = class_name
+    Errors < "Class %cname has not implemented []= which is required for Enumerable"
+  end
+
+  length do |name, value|
+    cname = class_name
+    Errors < "Class %cname has not implemented length which is required for Enumerable"
+  end
+
+  each do |iter|
+    if lambda? and iter.kind_of?(Lambda)
+      i = 0
+      while i < self.length
+        iter.call(self[i], i)
+        i += 1
+      end
+    end
+  end
+
+  map do |iter|
+    if lambda? and iter.kind_of?(Lambda)
+      arr = []
+      each -> { |item, key|
+        arr < iter.call(item, key)
+      }
+    end
+    arr
+  end
+end

data/lib/lang/runtime/eleetscript/falseclass.es

@@ -0,0 +1,25 @@
+class FalseClass
+  to_string do
+    "false"
+  end
+
+  not do
+    true
+  end
+
+  and do
+    false
+  end
+
+  or do |o|
+    if o
+      o
+    else
+      false
+    end
+  end
+
+  to_string do
+    "false"
+  end
+end

data/lib/lang/runtime/eleetscript/integer.es

@@ -0,0 +1,11 @@
+class Integer
+  times do |iter|
+    if lambda? and iter.kind_of?(Lambda)
+      i = 0
+      while i < self
+        iter.call(i)
+        i += 1
+      end
+    end
+  end
+end

data/lib/lang/runtime/eleetscript/list.es

@@ -0,0 +1,44 @@
+class List
+  < do |value|
+    self.push(value)
+  end
+
+  + do |other|
+    if other.kind_of?(List)
+      self.merge!(other)
+    else
+      self
+    end
+  end
+
+  each do
+    if lambda?
+      keys = self.keys
+      i = 0
+      while i < keys.length
+        key = keys[i]
+        lambda.call(self[key], key)
+        i += 1
+      end
+    end
+  end
+
+  inject do |val, iter|
+    if lambda?
+      self.each -> { |item, key|
+        val = lambda.call(val, item, key)
+      }
+    end
+    val
+  end
+
+  sum do
+    inject(0) -> { |sum, val|
+      if val.kind_of?(Number)
+        sum + val
+      else
+        sum
+      end
+    }
+  end
+end

data/lib/lang/runtime/eleetscript/nilclass.es

@@ -0,0 +1,5 @@
+class NilClass
+  to_string do
+    "nil"
+  end
+end

data/lib/lang/runtime/eleetscript/number.es

@@ -0,0 +1,13 @@
+class Number
+  isnt do |val|
+    not self is val
+  end
+
+  >= do |val|
+    self > val or self is val
+  end
+
+  <= do |val|
+    self < val or self is val
+  end
+end