sol 0.0.1

data/lib/sol/grammar.y

@@ -0,0 +1,178 @@
+class Parser
+
+	#Declare tokens by the lexer
+
+	token IF
+	token FUNC
+	token NEWLINE
+	token NUMBER
+	token STRING
+	token TRUE FALSE NULL
+	token IDENTIFIER
+	token CONSTANT
+
+	prechigh
+		left "."
+		left "!"
+		left "*" "/"
+		left "+" "-"
+		left ">" ">=" "<" "<="
+		left "==" "!="
+		left "&&"
+		left "||"
+		left "="
+		left ","
+	preclow
+
+	rule
+
+	# All rules are declared in this format:
+	#
+	#   RuleName:
+	#     OtherRule TOKEN AnotherRule    { code to run when this matches }
+	#   | OtherRule                      { ... }
+	#   ;
+	#
+	# In the code section (inside the {...} on the right):
+	# - Assign to "result" the value returned by the rule.
+
+	# All parsinng will end in this rule, being the trunk of the AST
+	Root: 
+		/* nothing */							{ result = Nodes.new([]) }				
+		| Expressions                       	{ result = val[0] }
+		;
+
+	# Any list of expressions are seperated by line breaks
+	Expressions:
+		Expression 								{ result = Nodes.new(val) }
+		| Expressions Expression  				{ result = val[0] << val[1] }
+		# To ignore trailing line breaks
+		| Expressions Terminator    			{ result = val[0] }
+		| Terminator							{ result = Nodes.new([]) }
+		;
+
+	# All types of expressions in our language
+	Expression:
+		Literal
+		| Call
+		| Operator
+		| Constant
+		| Assign
+		| Func
+		| If
+		| "(" Expression ")" 					{ result = val[1] }
+		;
+
+	# All tokens that can terminate and expression
+	Terminator:
+		NEWLINE
+		| ";"
+		;
+
+	# All hardcoded value
+	Literal:
+		NUMBER									{ result = NumberNode.new(val[0]) }
+		| STRING								{ result = StringNode.new(val[0]) }
+		| TRUE 									{ result = TrueNode.new }
+		| FALSE									{ result = FalseNode.new }
+		| NULL									{ result = NullNode.new }
+		;
+
+	# A method call
+	Call:
+		# Method
+	#	IDENTIFIER 				    			{ result = CallNode.new(nil, val[0], []) }
+		# method arguments are optional
+		 IDENTIFIER "(" ArgList ")"			{ result = CallNode.new(nil, val[0], val[2]) }
+		# receiver.method
+	#	| Expression "." IDENTIFIER				{ result = CallNode.new(val[0], val[2], []) }
+		# receiver.method(arguments) arguments are optional
+		| Expression "." IDENTIFIER "(" ArgList ")"	{ result = CallNode.new(val[0], val[2], val[4]) }
+		;
+
+	ArgList:
+		/* Nothing */							{ result = [] }
+		| Expression 							{ result = val }
+		| ArgList "," Expression 				{ result = val[0] << val[2]}
+		;
+
+	Operator:
+		# Binary operators
+		Expression "||" Expression 				{ result = CallNode.new(val[0], val[1], [val[2]]) }
+		| Expression '&&' Expression 			{ result = CallNode.new(val[0], val[1], [val[2]]) }
+		| Expression '==' Expression 			{ result = CallNode.new(val[0], val[1], [val[2]]) }
+		| Expression '!=' Expression 			{ result = CallNode.new(val[0], val[1], [val[2]]) }
+		| Expression '>' Expression   			{ result = CallNode.new(val[0], val[1], [val[2]]) } 
+		| Expression '>=' Expression 			{ result = CallNode.new(val[0], val[1], [val[2]]) }
+		| Expression '<' Expression  			{ result = CallNode.new(val[0], val[1], [val[2]]) }
+		| Expression '<=' Expression 			{ result = CallNode.new(val[0], val[1], [val[2]]) }
+		| Expression '+' Expression  			{ result = CallNode.new(val[0], val[1], [val[2]]) }
+		| Expression '-' Expression  			{ result = CallNode.new(val[0], val[1], [val[2]]) }
+		| Expression '*' Expression 			{ result = CallNode.new(val[0], val[1], [val[2]]) } 
+		| Expression '/' Expression  			{ result = CallNode.new(val[0], val[1], [val[2]]) }
+		;
+
+	Constant:
+		CONSTANT 								{ result = GetConstantNode.new(val[0]) }
+		;
+
+	# Assignment to a variable or constant
+	Assign:
+		IDENTIFIER "=" Expression 				{ result = SetLocalNode.new(val[0], val[2]) }
+		| CONSTANT "=" Expression 				{ result = SetLocalNode.new(val[0], val[2]) }
+		;
+
+	# Method definition
+	Func:
+		# ParamList is optional
+		FUNC IDENTIFIER "(" ParamList ")" Block { result = FuncNode.new(val[1], val[3], val[5]) }
+		;
+
+	ParamList:
+		/* Nothing */
+		| IDENTIFIER 							{ result = [] }
+		| ParamList "," IDENTIFIER 				{ result = val }
+		;
+
+	# If block
+	If:
+		IF Expression Block 					{ result = IfNode.new(val[1], val[2]) }
+		;
+
+	# A block of code all the work was done by the lexer
+	Block:
+		"{" Expressions "}" 					{ result = val[1] }
+		;
+
+end
+
+---- header
+
+require_relative "lexer"
+
+require_relative "nodes"
+
+module Sol
+
+---- inner
+
+		# This code will be puts as-is in the Parser class
+		def parse(input, show_tokens=true)
+
+			@tokens = Sol::Lexer.new.tokenise(input) # Tokenise the code using our lexer
+
+			puts @tokens.inspect if show_tokens
+
+			do_parse # Kickoff the parsing process
+
+		end
+
+		def next_token
+
+			@tokens.shift
+
+		end
+
+---- footer
+
+end # End the module

data/lib/sol/interpreter.rb

@@ -0,0 +1,187 @@
+require_relative "parser"
+require_relative "runtime"
+
+module Sol
+
+	class Interpreter
+
+		def initialize
+
+			@parser = Sol::Parser.new
+
+		end
+
+		def eval(input)
+
+			@parser.parse(input).eval(RuntimeModel::Runtime)
+
+		end
+
+	end
+
+	class Nodes
+
+		# This method is the "interpreter" part of our language. All nodes know how to eval
+		# itself and returns the result of its evaluation by implementing the "eval" method.
+		# The "context" variable is the environment in which the node is evaluated (local variables, current class, etc.).
+		def eval(context)
+
+			return_value = nil
+
+			nodes.each do |node|
+
+				return_value = node.eval(context)
+
+			end
+
+			# The last value evaluated in a method is the return value. Or null if node
+			return_value || RuntimeModel::Runtime["null"]
+
+		end
+
+	end
+
+	class NumberNode
+
+		def eval(context)
+
+			# Here we access the Runtime, which we'll see in the next section, to create a new instance of the Number class
+			RuntimeModel::Runtime["Number"].new_with_value(value)
+
+		end
+
+	end
+
+	class StringNode
+
+		def eval(context)  
+
+			RuntimeModel::Runtime["String"].new_with_value(value)
+
+		end
+
+	end
+
+	class TrueNode
+
+		def eval(context)  
+
+			RuntimeModel::Runtime["true"]
+
+		end
+
+	end
+
+	class FalseNode
+
+		def eval(context)  
+
+			RuntimeModel::Runtime["false"]
+
+		end
+
+	end
+
+	class NullNode
+
+		def eval(context)  
+
+			RuntimeModel::Runtime["null"]
+
+		end
+
+	end
+
+	class CallNode
+
+		def eval(context)
+
+			if receiver.nil? && arguments.empty? && RuntimeModel::Runtime.locals[method]
+
+				return context::Runtime.locals[method]
+
+			else
+
+				if receiver
+
+					value = receiver.eval(context)
+
+				else
+
+					value = RuntimeModel::Runtime.current_self # I think this works
+
+				end
+
+				eval_arguments = arguments.map do |arg| 
+
+					arg.eval(context) 
+
+				end
+
+				value.call(method, eval_arguments)
+
+			end
+
+		end
+
+	end
+
+	class GetConstantNode
+
+		def eval(context)
+
+			context[name]
+
+		end
+
+	end
+
+	class SetConstantNode
+
+		def eval(context)
+
+			context[name] = value.eval(context)
+
+		end
+
+	end
+
+	class SetLocalNode
+
+		def eval(context)
+
+			context.locals[name] = value.eval(context)
+
+		end
+
+	end
+
+	class FuncNode
+
+		def eval(context)
+
+			# Defining a method is adding a method to the current class
+			method = RuntimeModel::SolFunction.new(params, body)
+
+			RuntimeModel::Runtime.current_class.runtime_methods[name] = method # I think this works
+
+		end
+
+	end
+
+	class IfNode
+
+		def eval(context)
+
+			# We turn the condition node innto a Ruby value to use Ruby's "if" control structure
+			if condition.eval(context).ruby_value
+
+				body.eval(context)
+
+			end
+
+		end
+
+	end
+
+end

data/lib/sol/lexer.rb

@@ -0,0 +1,163 @@
+# encoding=utf-8
+
+require "readline"
+
+module Sol
+
+    class Lexer
+     
+        attr_reader :KEYWORDS
+
+        IDENTIFIER = /\A([a-zA-Z]\p{WORD}+\w*)/
+
+        NUMBER = /\A([0-9]+)/
+
+        STRING = /\A["'](.*?)["']/
+
+        OPERATOR = /\A(\|\||&&|==|!=|<=|>=)/
+
+        WHITESPACE = /\A([ \t\r\n]+)/
+
+        NEWLINE = /\A([\r\n])+/
+
+        def initialize
+
+            @KEYWORDS = ["func", "if", "true", "false", "null"]
+
+        end
+
+        # This is how to implement a very simple scanner.
+        # Scan one caracter at the time until you find something to parse.
+
+        def tokenise(input)
+
+            @input = input.chomp # Cleanup code by remove extra line breaks
+
+            @i = 0 # Current character position we're parsing
+
+            @tokens = [] # Collection of all parsed tokens in the form [:TOKEN_TYPE, value]
+
+            while @i < @input.length
+
+              @chunk = @input[@i..-1]
+
+              extract_next_token
+             
+            end
+
+            return @tokens
+             
+        end
+
+        def repl
+
+            loop do
+             
+              line = Readline::readline('> ')
+             
+              break if line.nil? || line == 'quit'
+             
+              Readline::HISTORY.push(line)
+
+              puts "#{tokenise(line)}" # Brackets are for clarity purposes
+             
+            end
+
+        end
+
+        private
+
+        def extract_next_token
+
+            return if identifier_token
+
+            return if number_token
+
+            return if string_token
+
+            return if whitespace_token
+
+            return literal_token
+
+        end
+
+        # Matching if, print, method names, etc.
+
+        def identifier_token
+
+            return false unless identifier = @chunk[IDENTIFIER, 1]
+
+            # Keywords are special identifiers tagged with their own name, 'if' will result
+            # in an [:IF, "if"] token
+
+            if @KEYWORDS.include?(identifier)
+
+              @tokens << [identifier.upcase.to_sym, identifier]
+
+            else
+
+              @tokens << [:IDENTIFIER, identifier]
+
+            end
+
+            @i += identifier.length
+
+        end
+
+        def number_token
+
+            return false unless number = @chunk[NUMBER, 1]
+
+            @tokens << [:NUMBER, number.to_i]
+
+            @i += number.length
+
+        end
+
+        def string_token
+
+            return false unless string = @chunk[STRING, 1]
+
+            @tokens << [:STRING, string]
+
+            @i += string.length + 2
+
+        end
+
+        # Ignore whitespace
+
+        def whitespace_token
+
+            return false unless whitespace = @chunk[WHITESPACE, 1]
+
+            @i += whitespace.length
+
+        end
+
+        # We treat all other single characters as a token. Eg.: ( ) , . !
+
+        def literal_token
+
+            value = @chunk[NEWLINE, 1]
+
+            if value
+
+                @tokens << ["\n", "\n"]  unless @tokens.last && @tokens.last[0] == "\n"
+
+                return @i + value.length
+
+            end
+
+            value = @chunk[OPERATOR, 1]
+
+            value ||= @chunk[0, 1]
+
+            @tokens << [value, value]
+
+            @i += value.length
+
+        end
+     
+    end
+
+end