sol 0.0.1

data/lib/sol/runtime.rb

@@ -0,0 +1,13 @@
+=begin
+require_relative "runtime/object"
+require_relative "runtime/class"
+require_relative "runtime/method"
+require_relative "runtime/context"
+require_relative "runtime/bootstrap"
+=end
+
+Dir[File.dirname(__FILE__) + "/runtime/*.rb"].each { |file| require file }
+
+module Sol
+
+end

data/lib/sol/runtime/bootstrap.rb

@@ -0,0 +1,156 @@
+require_relative "class"
+require_relative "context"
+
+module Sol
+
+	module RuntimeModel
+
+		# Bootstrap the runtime. This is where we assemble all the classes and objects together to form the runtime
+		# Whats happening in the runtime
+		sol_class = SolClass.new
+
+		sol_class.runtime_class = sol_class
+
+		object_class = SolClass.new
+
+		object_class.runtime_class = sol_class
+
+		Runtime = Context.new(object_class.new)
+
+		Runtime["Class"] = sol_class
+
+		Runtime["Object"] = object_class
+
+		Runtime["Number"] = SolClass.new
+
+		Runtime["String"] = SolClass.new
+
+		# Everything is an object in  our language, even true, false and null. So they nneed to have a class too.
+		Runtime["TrueClass"] = SolClass.new
+
+		Runtime["FalseClass"] = SolClass.new
+
+		Runtime["NullClass"] = SolClass.new
+
+		Runtime["true"] = Runtime["TrueClass"].new_with_value(true)
+
+		Runtime["false"] = Runtime["FalseClass"].new_with_value(false)
+
+		Runtime["null"] = Runtime["TrueClass"].new_with_value(nil)
+
+		# Add a few core methods to the runtime
+
+		# Print an object to the console, e.g print("hello, world")
+		Runtime["Object"].runtime_methods["print"] = proc do |receiver, arguments|
+
+			puts arguments.first.ruby_value
+
+			Runtime["Null"]
+
+		end
+
+		# Exit 
+		Runtime["Object"].runtime_methods["exit"] = proc do |receiver|
+
+			Runtime["Null"]
+
+			exit(0)
+
+		end
+
+		# Quit
+		Runtime["Object"].runtime_methods["quit"] = proc do |receiver|
+
+			Runtime["Null"]
+
+			exit(0)
+
+		end
+
+		# Or (||)
+		Runtime["Number"].runtime_methods["||"] = proc do |receiver, arguments|
+
+			Runtime["Number"].new_with_value(receiver.ruby_value || arguments.first.ruby_value)
+
+		end
+
+		# And (&&)
+		Runtime["Number"].runtime_methods["&&"] = proc do |receiver, arguments|
+
+			Runtime["Number"].new_with_value(receiver.ruby_value && arguments.first.ruby_value)
+
+		end
+
+		# Equal to (==)
+		Runtime["Number"].runtime_methods["=="] = proc do |receiver, arguments|
+
+			Runtime["Number"].new_with_value(receiver.ruby_value == arguments.first.ruby_value)
+
+		end
+
+		# Does not equal to (!=)
+		Runtime["Number"].runtime_methods["!="] = proc do |receiver, arguments|
+
+			Runtime["Number"].new_with_value(receiver.ruby_value != arguments.first.ruby_value)
+
+		end
+
+		# Greater than (>)
+		Runtime["Number"].runtime_methods[">"] = proc do |receiver, arguments|
+
+			Runtime["Number"].new_with_value(receiver.ruby_value > arguments.first.ruby_value)
+
+		end
+
+		# Greater than or equal to (>=)
+		Runtime["Number"].runtime_methods[">="] = proc do |receiver, arguments|
+
+			Runtime["Number"].new_with_value(receiver.ruby_value >= arguments.first.ruby_value)
+
+		end
+
+		# Less than (<)
+		Runtime["Number"].runtime_methods["<"] = proc do |receiver, arguments|
+
+			Runtime["Number"].new_with_value(receiver.ruby_value < arguments.first.ruby_value)
+
+		end
+
+		# Less than or equal to (>=)
+		Runtime["Number"].runtime_methods["<="] = proc do |receiver, arguments|
+
+			Runtime["Number"].new_with_value(receiver.ruby_value <= arguments.first.ruby_value)
+
+		end
+
+		# Add
+		Runtime["Number"].runtime_methods["+"] = proc do |receiver, arguments|
+
+			Runtime["Number"].new_with_value(receiver.ruby_value + arguments.first.ruby_value)
+
+		end
+
+		# Minus
+		Runtime["Number"].runtime_methods["-"] = proc do |receiver, arguments|
+
+			Runtime["Number"].new_with_value(receiver.ruby_value - arguments.first.ruby_value)
+
+		end
+
+		# Times 
+		Runtime["Number"].runtime_methods["*"] = proc do |receiver, arguments|
+
+			Runtime["Number"].new_with_value(receiver.ruby_value * arguments.first.ruby_value)
+
+		end
+
+		# Divide
+		Runtime["Number"].runtime_methods["/"] = proc do |receiver, arguments|
+
+			Runtime["Number"].new_with_value(receiver.ruby_value / arguments.first.ruby_value)
+
+		end
+
+	end
+
+end

data/lib/sol/runtime/class.rb

@@ -0,0 +1,69 @@
+require_relative "object"
+
+module Sol
+
+	module RuntimeModel
+
+		# Represents a Sol class in the Ruby world. Classes are objects in Sol so they inherit from SolObject
+		class SolClass < SolObject
+
+			attr_reader :runtime_methods
+
+			# Create a new class. Number is an instance of Class for example
+			def initialize
+
+				@runtime_methods = {}
+
+				# Check if we're bootstrapping (launching the runtime). During this process the
+				# runtime is not fully initialised and core classes do not yet exists, so we defer
+				# using those once the language is bootstrapped.
+				# This solves the chicken-or-the-egg problem with the Class class. We can
+				# initialise Class then set Class.class = Class.
+				if defined?(Runtime) # RuntimeModel is a temporary name
+
+					runtime_class = Runtime["Class"]
+
+				else
+
+					runtime_class = nil
+
+				end
+
+				super(runtime_class)
+
+			end
+
+			# Lookup a method
+			def lookup(method_name)
+
+				method = @runtime_methods[method_name]
+
+				unless method
+
+					raise "Method not found: #{method_name}"
+
+				end
+
+				return method
+
+			end
+
+			# Create a new instance of the class
+			def new
+
+				SolObject.new(self)
+
+			end
+
+			# Create an instance of this Sol class that holds a Ruby value
+			def new_with_value(value)
+
+				SolObject.new(self, value)
+
+			end
+
+		end
+
+	end
+
+end

data/lib/sol/runtime/context.rb

@@ -0,0 +1,42 @@
+module Sol
+
+	module RuntimeModel
+
+		class Context
+
+			attr_reader :locals, :current_self, :current_class
+
+			# We store constants as class variable (class variables start with @@ and instance
+			# variables start with @ in Ruby) since they are globally accessible. If you want to
+			# implement namespacing of constants, you could store it in the instance of this class.
+		 	@@constants = {}
+
+			def initialize(current_self, current_class=current_self.runtime_class)
+
+				@locals = {}
+
+				@current_self = current_self
+
+				@current_class = current_class
+
+		 	end
+
+			 # Shortcuts to access constants, Runtime[...] instead of Runtime.constants[...]
+
+			def [](name)
+
+				@@constants[name]
+
+		 	end
+
+			def []=(name, value)
+
+				@@constants[name] = value
+
+		 	end
+
+		end
+
+	end
+
+end

data/lib/sol/runtime/function.rb

@@ -0,0 +1,42 @@
+module Sol
+
+	module RuntimeModel
+
+		require_relative "object"
+
+		# Represents a method defined in the runtime
+		class SolFunction < SolObject
+
+			def initialize(params, body)
+
+				@params = params
+
+				@body = body
+
+			end
+
+			def call(reciever, arguments)
+
+				# Create a context of evaluation in which the method will execute
+				context = Context.new(reciever)
+
+				if @params.class == "NullClass"
+
+					# Assign arguments to local variables
+					@params.to_enum.each_with_index do |param, index|
+
+						context.locals[param] = arguments[index]
+
+					end
+
+				end
+
+				return @body.eval(context)
+
+			end
+
+		end
+
+	end
+
+end

data/lib/sol/runtime/object.rb

@@ -0,0 +1,32 @@
+module Sol
+
+	module RuntimeModel
+
+		# Represents an Sol object instance in the Ruby world
+		class SolObject
+
+			attr_accessor :runtime_class, :ruby_value
+
+			# Each object have a class (named runtime_class to prevents errors with Ruby's class method). 
+			# Optionally an object can hold a Ruby value (e.g strings and numbers)
+			def initialize(runtime_class, ruby_value=self)
+
+				@runtime_class = runtime_class
+
+				@ruby_value = ruby_value
+
+			end
+
+			# Call a method on the object
+			def call(method, arguments=[])
+
+				# Like a typical Class-based runtime model, we store methods in the class of the object
+				@runtime_class.lookup(method).call(self, arguments)
+
+			end
+
+		end
+
+	end
+
+end

data/lib/sol/spec/lexer_test.rb

@@ -0,0 +1,68 @@
+require "minitest/spec"
+require "minitest/autorun"
+
+require_relative "../lexer" # Reqiure lexer in above folder
+
+describe "lexer" do
+	
+	before do
+
+		@lexer = Sol::Lexer.new
+
+		@literals = ["(", ")", ".", "!", "+", "-", "*", "/"]
+
+		@operators = ["+", "-", "*", "/", "&&", "==", "!=", "<=", ">="]
+
+	end
+
+	it "can accept all keywords" do
+
+		@lexer.KEYWORDS.each do |keyword|
+
+			assert_equal [[keyword.upcase.to_sym, keyword]], @lexer.tokenise(keyword)
+
+		end
+
+	end
+
+	it "can accept numbers" do
+
+		assert_equal [[:NUMBER, 123]], @lexer.tokenise("123")
+
+	end
+
+	it "can accept double qouted strings" do
+
+		# Escaped strings are the best
+
+		assert_equal [[:STRING, "hello"]], @lexer.tokenise("\"hello\"")
+
+	end
+
+	it "can accept single qouted strings" do
+
+		assert_equal [[:STRING, 'hello']], @lexer.tokenise("'hello'")
+
+	end
+
+	it "can accept operators" do 
+
+		@operators.each do |operator| 
+
+			assert_equal [[operator, operator]], @lexer.tokenise(operator)
+
+		end
+
+	end
+
+	it "can accept literals" do 
+
+		@literals.each do |literal|
+
+			assert_equal [[literal, literal]], @lexer.tokenise(literal)
+
+		end
+
+	end
+
+end

data/lib/sol/spec/parser_test.rb

@@ -0,0 +1,38 @@
+require "minitest/autorun"
+require "minitest/spec"
+
+require_relative "../parser.rb" # Reqiure parser in above folder
+
+describe "parser" do 
+
+	before do 
+
+		@parser = Sol::Parser.new
+
+		@operators = ["||", "&&", "==", "!=", ">", ">=", "<", "<=", "+", "-", "*", "/"]
+
+	end
+
+	it "can do operations" do
+
+		@operators.each do |operator|
+
+			@parser.parse "1#{operator}1", show_tokens = false
+
+		end
+
+	end
+
+	it "can do functions" do 
+
+		@parser.parse "func hello() {1 + 1}", show_tokens =  false
+
+	end
+
+	it "can do if statements" do
+
+		@parser.parse "if 1 == 1 { 1 + 1 }", show_tokens =  false
+
+	end
+
+end