eleetscript 0.0.2a

data/lib/lang/interpreter.rb

@@ -0,0 +1,400 @@
+require "lang/parser"
+require "lang/runtime/memory"
+
+module EleetScript
+  class Interpreter
+    attr_reader :memory
+    def initialize(memory = nil)
+      @parser = Parser.new
+      @memory = memory || Memory.new
+      @memory.bootstrap(self)
+    end
+
+    def eval(code, show_nodes = false)
+      nodes = @parser.parse(code)
+      puts nodes if show_nodes
+      nodes.eval(@memory.root_namespace)
+    end
+
+    def load(file_name)
+      if File.exists?(file_name)
+        eval(File.read(file_name))
+      end
+    end
+  end
+
+  module Helpers
+    def self.throw_eleet_error(context, error)
+      context["Errors"].call("<", [context["String"].new_with_value(error)])
+    end
+  end
+
+  module Returnable
+    def returned
+      @returned = true
+    end
+
+    def returned?
+      @returned
+    end
+
+    def reset_returned
+      @returned = false
+    end
+  end
+
+  module Nextable
+    def nexted
+      @nexted = true
+    end
+
+    def nexted?
+      @nexted
+    end
+
+    def reset_nexted
+      @nexted = false
+    end
+  end
+
+  module NodeMethods
+    def returnable?
+      self.class.included_modules.include?(Returnable)
+    end
+
+    def nextable?
+      self.class.included_modules.include?(Nextable)
+    end
+  end
+
+  class Nodes
+    include Returnable
+    include Nextable
+
+    def eval(context)
+      return_value = nil
+      nodes.each do |node|
+        if node.kind_of?(ReturnNode)
+          returned
+          break return_value = node.eval(context)
+        elsif node.kind_of?(NextNode)
+          nexted
+          break
+        else
+          return_value = node.eval(context)
+        end
+        if node.returnable? && node.returned?
+          returned
+          node.reset_returned
+          break
+        elsif node.nextable? && node.nexted?
+          node.reset_nexted
+          nexted
+          break
+        end
+      end
+      return_value || context.es_nil
+    end
+  end
+
+  class StringNode
+    INTERPOLATE_RX = /[\\]?%(?:@|@@|\$)?[\w]+?(?=\W|$)/
+
+    def eval(context)
+      context["String"].new_with_value(interpolate(context))
+    end
+
+    def interpolate(context)
+      new_val = value.dup
+      matches = value.scan(INTERPOLATE_RX)
+      matches.each do |match|
+        next if match.nil? || match == "%" || match == ""
+        if match.start_with?("\\")
+          next new_val.sub!(match, match[1..-1])
+        end
+        var = match[1..-1]
+        new_val.sub!(match, context[var].call(:to_string).ruby_value)
+      end
+      new_val
+    end
+  end
+
+  class IntegerNode
+    def eval(context)
+      context["Integer"].new_with_value(value)
+    end
+  end
+
+  class FloatNode
+    def eval(context)
+      context["Float"].new_with_value(value)
+    end
+  end
+
+  class SetGlobalNode
+    def eval(context)
+      context[name] = value.eval(context)
+    end
+  end
+
+  class GetGlobalNode
+    def eval(context)
+      context[name]
+    end
+  end
+
+  class GetLocalNode
+    def eval(context)
+      val = context.local_var(name)
+      val != context.es_nil ? val : context.current_self.call(name, [])
+    end
+  end
+
+  class SetLocalNode
+    def eval(context)
+      if Lexer::RESERVED_WORDS.include?(name)
+        context["Errors"].call("<", [context["String"].new_with_value("Cannot assign a value to reserved word \"name\"")])
+      else
+        context.local_var(name, value.eval(context))
+      end
+    end
+  end
+
+  class GetConstantNode
+    def eval(context)
+      context.constants[name] || context[name]
+    end
+  end
+
+  class SetConstantNode
+    def eval(context)
+      if !context.constants.has_key?(name)
+        context[name] = value.eval(context)
+      else
+        Helpers.throw_eleet_error(context, "Cannot reassign constant \"#{name}\" after it's already been defined!")
+      end
+    end
+  end
+
+  class SetInstanceVarNode
+    def eval(context)
+      context.instance_vars[name] = value.eval(context)
+    end
+  end
+
+  class GetInstanceVarNode
+    def eval(context)
+      context.current_self.instance_vars[name]
+    end
+  end
+
+  class SetClassVarNode
+    def eval(context)
+      context.current_class.class_vars[name] = value.eval(context)
+    end
+  end
+
+  class GetClassVarNode
+    def eval(context)
+      context.current_class.class_vars[name]
+    end
+  end
+
+  class TrueNode
+    def eval(context)
+      context["true"]
+    end
+  end
+
+  class FalseNode
+    def eval(context)
+      context["false"]
+    end
+  end
+
+  class NilNode
+    def eval(context)
+      context.es_nil
+    end
+  end
+
+  class ClassNode
+    def eval(context)
+      cls = context[name]
+      if cls == context.es_nil
+        cls = if parent
+          parent_cls = context[parent]
+          throw "Cannot extend undefined class \"#{parent}\"." if parent_cls == context.es_nil
+          EleetScriptClass.create(context, name, parent_cls)
+        else
+          EleetScriptClass.create(context, name)
+        end
+        context[name] = cls
+      end
+
+      body.eval(cls.context)
+      cls
+    end
+  end
+
+  class PropertyNode
+    def eval(context)
+      cls = context.current_class
+      properties.each do |prop_name|
+        cls.def "#{prop_name}=" do |receiver, arguments|
+          receiver.instance_vars[prop_name] = arguments.first
+        end
+
+        cls.def prop_name do |receiver, arguments|
+          receiver.instance_vars[prop_name]
+        end
+      end
+    end
+  end
+
+  class CallNode
+    def eval(context)
+      value = if receiver
+        receiver.eval(context)
+      else
+        context.current_self
+      end
+      evaled_args = arguments.map { |a| a.eval(context) }
+      evaled_args << lambda.eval(context) if lambda
+      value.call(method_name, evaled_args)
+    end
+  end
+
+  class LambdaNode
+    def eval(context)
+      context["Lambda"].new_with_value(EleetScriptMethod.new(params, body, context))
+    end
+  end
+
+  class DefMethodNode
+    def eval(context)
+      method_obj = EleetScriptMethod.new(method.params, method.body)
+      context.current_class.methods[method_name] = method_obj
+      context.es_nil
+    end
+  end
+
+  class SelfNode
+    def eval(context)
+      context.current_self
+    end
+  end
+
+  class IfNode
+    include Returnable
+    include Nextable
+
+    def eval(context)
+      cond = condition.eval(context)
+      cond = (cond.class? ? cond : cond.ruby_value)
+      if cond
+        ret = body.eval(context)
+        if body.returnable? && body.returned?
+          body.reset_returned
+          returned
+        elsif body.nextable? && body.nexted?
+          body.reset_nexted
+          nexted
+          return context.es_nil
+        end
+        ret
+      else
+        unless else_node.nil?
+          ret = else_node.eval(context)
+          if else_node.returned?
+            else_node.reset_returned
+            returned
+          elsif else_node.nexted?
+            else_node.reset_nexted
+            nexted
+            return context.es_nil
+          end
+          ret
+        end
+      end
+    end
+  end
+
+  class ElseNode
+    include Returnable
+    include Nextable
+
+    def eval(context)
+      ret = body.eval(context)
+      if body.returnable? and body.returned?
+        body.reset_returned
+        returned
+      elsif body.nextable? && body.nexted?
+        body.reset_nexted
+        nexted
+        return context.es_nil
+      end
+      ret
+    end
+  end
+
+  class ReturnNode
+    def eval(context)
+      if expression
+        expression.eval(context)
+      else
+        context.es_nil
+      end
+    end
+  end
+
+  class WhileNode
+    include Returnable
+
+    def eval(context)
+      val = condition.eval(context)
+      ret = nil
+      while val.ruby_value
+        ret = body.eval(context)
+        if body.returnable? && body.returned?
+          body.reset_returned
+          returned
+          return ret
+        elsif body.nextable? && body.nexted?
+          body.reset_nexted
+          next
+        end
+        val = condition.eval(context)
+      end
+      ret || context.es_nil
+    end
+  end
+
+  class NamespaceNode
+    def eval(context)
+      ns_ctx = context.namespace(name)
+      if ns_ctx
+        body.eval(ns_ctx)
+      else
+        ns_ctx = context.new_namespace_context
+        context.add_namespace(name, ns_ctx)
+        body.eval(ns_ctx)
+      end
+    end
+  end
+
+  class NamespaceAccessNode
+    def eval(context)
+      ns_ctx = if namespace.nil?
+        context.root_ns
+      else
+        context.namespace(namespace)
+      end
+      if ns_ctx
+        expression.eval(ns_ctx)
+      else
+        Helpers.throw_eleet_error(context, "Namespace \"#{namespace}\" does not exist.")
+      end
+    end
+  end
+end

data/lib/lang/lexer.rb

@@ -0,0 +1,92 @@
+require "eleetscript"
+
+module EleetScript
+  class Lexer
+    RESERVED_WORDS = [
+      "lambda?", "lambda", "self", "nil", "true", "yes", "on", "false", "no",
+      "off", "next", "break", "return"
+    ]
+
+    KEYWORDS = [
+      "do", "end", "class", "load", "if", "while", "namespace", "else", "elsif",
+      "return", "break", "next", "true", "yes", "on", "false", "no", "off",
+      "nil", "self", "defined?", "property"
+    ]
+
+    TOKEN_RX = {
+      identifiers: /\A([a-z_][\w\d]*[?!]?)/,
+      constants: /\A([A-Z][\w\d]*[?!]?)/,
+      globals: /\A(\$[a-z][\w\d]*[?!]?)/i,
+      class_var: /\A(\@\@[a-z][\w\d]*[!?]?)/i,
+      instance_var: /\A(\@[a-z][\w\d]*[!?]?)/i,
+      operator: /\A(->|=>|[.+\-\*\/%<>=!]=|\*\*=|\*\*|[+\-\*\/%=><]|or|and|not|isnt|is|\||\(|\)|\[|\]|\{|\}|::|[.,])/,
+      whitespace: /\A([ \t]+)/,
+      terminator: /\A([;\n])/,
+      integer: /\A([\d_]+)/,
+      float: /\A([\d_]*?\.[\d_]+)/,
+      string: /\A\"(.*?)(?<!\\)\"/m,
+      comment: /\A#.*?(?=\n|$)/m
+    }
+
+    def tokenize(code)
+      tokens = []
+      if code.length == 0
+        return tokens
+      end
+      line = 1
+      i = 0
+      while i < code.length
+        chunk = code[i..-1]
+        if operator = chunk[TOKEN_RX[:operator]]
+          tokens << [operator, operator]
+          i += operator.length
+        elsif constant = chunk[TOKEN_RX[:constants]]
+          tokens << [:CONSTANT, constant]
+          i += constant.length
+        elsif global = chunk[TOKEN_RX[:globals]]
+          tokens << [:GLOBAL, $1]
+          i += global.length
+        elsif class_var = chunk[TOKEN_RX[:class_var]]
+          tokens << [:CLASS_IDENTIFIER, $1]
+          i += class_var.length
+        elsif instance_var = chunk[TOKEN_RX[:instance_var]]
+          tokens << [:INSTANCE_IDENTIFIER, $1]
+          i += instance_var.length
+        elsif identifier = chunk[TOKEN_RX[:identifiers]]
+          if KEYWORDS.include? identifier
+            tokens << [identifier.upcase.gsub(/\?\!/, "").to_sym, identifier]
+          else
+            tokens << [:IDENTIFIER, identifier]
+          end
+          i += identifier.length
+        elsif float = chunk[TOKEN_RX[:float]]
+          tokens << [:FLOAT, float.to_f]
+          i += float.length
+        elsif integer = chunk[TOKEN_RX[:integer]]
+          tokens << [:NUMBER, integer.to_i]
+          i += integer.length
+        elsif string = chunk[TOKEN_RX[:string]]
+          tokens << [:STRING, $1.gsub('\"', '"')]
+          i += string.length
+        elsif comment = chunk[TOKEN_RX[:comment]]
+          i += comment.length # Ignore comments
+        elsif terminator = chunk[TOKEN_RX[:terminator]]
+          tokens << [:TERMINATOR, terminator]
+          if terminator == "\n"
+            line += 1
+          end
+          i += 1
+        elsif space = chunk[TOKEN_RX[:whitespace]]
+          i += space.length # ignore spaces and tab characters
+        else
+          raise LexicalError.new(code[i], line)
+        end
+      end
+      if tokens.length > 0 && tokens.last != [:TERMINATOR, "\n"]
+        tokens << [:TERMINATOR, "\n"]
+      end
+      tokens << [:EOF, :eof] if tokens.length > 0
+      tokens
+    end
+  end
+end

data/lib/lang/nodes.rb

@@ -0,0 +1,197 @@
+require "eleetscript"
+
+module EleetScript
+  module NodeMethods
+    def spaces(level)
+      "  " * level
+    end
+
+    def to_s(level = 0)
+      "#{spaces(level)}<#{self.class.name}>\n"
+    end
+
+    def is_node?
+      true
+    end
+  end
+
+  class Node < Struct
+    include NodeMethods
+  end
+
+  class NodeType
+    include NodeMethods
+  end
+
+  class Nodes < Node.new(:nodes)
+    def <<(node)
+      nodes << node
+      self
+    end
+
+    def to_s(level = 0)
+      str = "#{spaces(level)}<EleetScript::Nodes\n"
+      nodes.each do |node|
+        str += node.to_s(level + 1)
+      end
+      str + "#{spaces(level)}>\n"
+    end
+  end
+
+  class LiteralNode < Node.new(:value)
+    def to_s(level = 0)
+      "#{spaces(level)}<#{self.class.name} #{value}>\n"
+    end
+  end
+
+  class IntegerNode < LiteralNode; end
+  class FloatNode < LiteralNode; end
+  class StringNode < LiteralNode; end
+
+  class TrueNode < LiteralNode
+    def value
+      true
+    end
+  end
+
+  class FalseNode < LiteralNode
+    def value
+      false
+    end
+  end
+
+  class NilNode < LiteralNode
+    def value
+      nil
+    end
+  end
+
+  class CallNode < Node.new(:receiver, :method_name, :arguments, :lambda)
+    def to_s(level = 0)
+      tabs = spaces(level)
+      str = "#{tabs}<EleetScript::CallNode\n"
+      if receiver.nil?
+        str += "#{tabs}  @receiver=nil\n"
+      else
+        str += "#{tabs}  @receiver=#{receiver.to_s[0..-2]}\n"
+      end
+      str += "#{tabs}  @method_name=#{method_name}\n"
+      if arguments.empty?
+        str += "#{tabs} @arguemtns=empty\n"
+      else
+        str += "#{tabs}  @arguments=(\n"
+        arguments.each do |arg|
+          str += arg.to_s(level + 2)
+        end
+        str += "#{tabs}  )\n"
+      end
+      if lambda.nil?
+        str + "#{tabs}  @lambda=nil\n>\n"
+      else
+        str += "#{tabs}  @lambda=(\n"
+        str += lambda.to_s(level + 2)
+      end
+      str + "#{tabs}>\n"
+    end
+  end
+
+  class SetVarNode < Node.new(:name, :value)
+    def to_s(level = 0)
+      tabs = spaces(level)
+      str = "#{tabs}<#{self.class.name}\n"
+      str += "#{tabs}  @name=#{name}\n"
+      str += "#{tabs}  @value=(\n"
+      str += value.to_s(level + 2)
+      str += "#{tabs}>\n"
+    end
+  end
+
+  class GetVarNode < Node.new(:name)
+    def to_s(level = 0)
+      str = "<#{self.class.name} \"#{name}\">\n"
+    end
+  end
+
+  class SetConstantNode < SetVarNode; end
+  class GetConstantNode < GetVarNode; end
+  class SetGlobalNode < SetVarNode; end
+  class GetGlobalNode < GetVarNode; end
+  class SetClassVarNode < SetVarNode; end
+  class GetClassVarNode < GetVarNode; end
+  class SetInstanceVarNode < SetVarNode; end
+  class GetInstanceVarNode < GetVarNode; end
+  class SetLocalNode < SetVarNode; end
+  class GetLocalNode < GetVarNode; end
+
+  class DefMethodNode < Node.new(:method_name, :method)
+    def to_s(level = 0)
+      tabs = spaces(level)
+      str = "#{tabs}<EleetScript::DefMethodNode \"#{method_name}\"\n"
+      str += "#{tabs}  @method=(\n"
+      str += method.to_s(level + 2)
+      str + "#{tabs}  )\n#{tabs}>\n"
+    end
+  end
+
+  class LambdaNode < Node.new(:params, :body)
+    def to_s(level = 0)
+      tabs = spaces(level)
+      str = "#{tabs}<EleetScript::LambdaNode\n"
+      str += "#{tabs}  @params=#{params.inspect}\n"
+      if body.nodes.length > 0
+        str += "#{tabs}  @body=(\n"
+        str += body.to_s(level + 2)
+        str += "#{tabs}  )\n#{tabs}>\n"
+      else
+        str += "#{tabs}  @body=nil\n#{tabs}>\n"
+      end
+      str
+    end
+  end
+
+  class MethodNode < Node.new(:params, :body)
+    def to_s(level = 0)
+      tabs = spaces(level)
+      str = "#{tabs}<EleetScript::MethodNode\n"
+      str += "#{tabs}  @params=#{params.inspect}\n"
+      if body.nodes.length > 0
+        str += "#{tabs}  @body=(\n"
+        str += body.to_s(level + 2)
+        str += "#{tabs}  )\n#{tabs}>\n"
+      else
+        str += "#{tabs}  @body=nil\n#{tabs}>\n"
+      end
+      str
+    end
+  end
+
+  class IfNode < Node.new(:condition, :body, :else_node); end
+  class ElseNode < Node.new(:body); end
+  class NotNode < Node.new(:value); end
+  class WhileNode < Node.new(:condition, :body); end
+  class SelfNode < NodeType; end
+  class DefinedNode < Node.new(:value); end
+  class NamespaceNode < Node.new(:name, :body); end
+  class NamespaceAccessNode < Node.new(:namespace, :expression); end
+
+  class ClassNode < Node.new(:name, :parent, :body)
+    def to_s(level = 0)
+      tabs = spaces(level)
+      str = "#{tabs}<EleetScript::ClassNode \"#{name}\"\n"
+      str += "#{tabs}  @extends=\"#{parent || "Object"}\"\n"
+      str += "#{tabs}  @body=(\n"
+      str += body.to_s(level + 2)
+      str + "#{tabs}  )\n#{tabs}>\n"
+    end
+  end
+
+  class ReturnNode < Node.new(:expression); end
+  class PropertyNode < Node.new(:properties); end
+
+  class NextNode < NodeType
+    def eval(context, memory); end
+    def ==(o)
+      o.kind_of?(NextNode)
+    end
+  end
+end