sweet-lang 0.1.0

data/bin/sweet

@@ -0,0 +1,2 @@
+#!/usr/bin/env ruby
+require 'sweet'

data/lib/interpreter.rb

@@ -0,0 +1,141 @@
+require "parser"
+require "runtime"
+
+class Interpreter
+  def initialize
+    @parser = Parser.new
+  end
+  
+  def eval(code)
+    @parser.parse(code).eval(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 nil if none.
+    return_value || Runtime["nil"]
+  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.
+    Runtime["Number"].new_with_value(value)
+  end
+end
+
+class StringNode
+  def eval(context)
+    Runtime["String"].new_with_value(value)
+  end
+end
+
+class TrueNode
+  def eval(context)
+    Runtime["true"]
+  end
+end
+
+class FalseNode
+  def eval(context)
+    Runtime["false"]
+  end
+end
+
+class NilNode
+  def eval(context)
+    Runtime["nil"]
+  end
+end
+
+class CallNode
+  def eval(context)
+    # If there's no receiver and the method name is the name of a local variable, then 
+    # it's a local variable access. This trick allows us to skip the () when calling a 
+    # method.
+    if receiver.nil? && context.locals[method] && arguments.empty?
+      context.locals[method]
+    
+    # Method call
+    else
+      if receiver
+        value = receiver.eval(context)
+      else
+        # In case there's no receiver we default to self, calling "print" is like
+        # "self.print".
+        value = context.current_self
+      end
+      
+      eval_arguments = arguments.map { |arg| arg.eval(context) }
+      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 DefNode
+  def eval(context)
+    # Defining a method is adding a method to the current class.
+    method = SweetMethod.new(params, body)
+    context.current_class.runtime_methods[name] = method
+  end
+end
+
+class ClassNode
+  def eval(context)
+    # Try to locate the class. Allows reopening classes to add methods.
+    sweet_class = context[name]
+    
+    unless sweet_class # Class doesn't exist yet
+      sweet_class = SweetClass.new
+      # Register the class as a constant in the runtime.
+      context[name] = sweet_class
+    end
+    
+    # Evaluate the body of the class in its context. Providing a custom context allows 
+    # to control where methods are added when defined with the def keyword. In this 
+    # case, we add them to the newly created class.
+    class_context = Context.new(sweet_class, sweet_class)
+    
+    body.eval(class_context)
+    
+    sweet_class
+  end
+end
+
+class IfNode
+  def eval(context)
+    # We turn the condition node into a Ruby value to use Ruby's "if" control 
+    # structure.
+    if condition.eval(context).ruby_value
+      body.eval(context)
+    end
+  end
+end

data/lib/lexer.rb

@@ -0,0 +1,3 @@
+require "lexer/tags"
+require "lexer/strings"
+require "lexer/core"

data/lib/lexer/core.rb

@@ -0,0 +1,128 @@
+class Lexer
+  KEYWORDS = ["def", "class", "if", "true", "false", "nil"]
+
+  def treat(code)
+    tags = Tags.new
+    code = tags.implement_tag(code)
+  end
+  
+  def tokenize(code)
+    # Cleanup code by remove extra line breaks
+    code.chomp!
+
+    # Replacing all spaces, inputing tabs
+    code = code.gsub( /[ ]+\n/, "\n" )
+		code = code.gsub( "\n ", "\n\t" )
+		code = code.gsub( /^\s*$/m, '' )
+    
+    tags = Tags.new
+
+		code = treat(code)
+
+    # Current character position we're parsing
+    i = 0
+    
+    # Collection of all parsed tokens in the form [:TOKEN_TYPE, value]
+    tokens = []
+    
+    # Current indent level is the number of spaces in the last indent.
+    current_indent = 0
+    # We keep track of the indentation levels we are in so that when we dedent, we can 
+    # check if we're on the correct level.
+    indent_stack = []
+    
+    # This is how to implement a very simple scanner.
+    # Scan one character at the time until you find something to parse.
+    while i < code.size
+      chunk = code[i..-1]
+      
+      # Matching standard tokens.
+      #
+      # Matching if, print, method names, etc.
+      if identifier = chunk[/\A([a-z]\w*)/, 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]
+        # Non-keyword identifiers include method and variable names.
+        else
+          tokens << [:IDENTIFIER, identifier]
+        end
+        # skip what we just parsed
+        i += identifier.size
+      
+      # Matching class names and constants starting with a capital letter.
+      elsif constant = chunk[/\A([A-Z]\w*)/, 1]
+        tokens << [:CONSTANT, constant]
+        i += constant.size
+        
+      elsif number = chunk[/\A([0-9]+)/, 1]
+        tokens << [:NUMBER, number.to_i]
+        i += number.size
+        
+      elsif string = chunk[/\A"(.*?)"/, 1]
+        tokens << [:STRING, string]
+        i += string.size + 2
+      
+     	# Here's the indentation magic!
+			elsif indent = chunk[/\A\n(\t+)/m, 1]
+				# Create a new block we expect the indent level to go up.
+				if indent.size < current_indent
+					indent_stack.pop
+					current_indent = indent_stack.last || 0
+					tokens << [:DEDENT, indent.size]
+					tokens << [:NEWLINE, "\n"]
+								
+				elsif indent.size == current_indent
+					tokens << [:NEWLINE, "\n"]
+					
+				else
+					# Adjust the current indentation level.
+					current_indent = indent.size
+					indent_stack.push(current_indent)
+					tokens << [:INDENT, indent.size]
+				end
+
+				i += indent.size + 1
+
+			elsif indent = chunk[/\A\n(	*)/m, 1]
+				if indent.size == current_indent
+					# Nothing to do, we're still in the same block
+					tokens << [:NEWLINE, "\n"]
+				elsif indent.size < current_indent
+					indent_stack.pop
+					current_indent = indent_stack.last || 0
+					tokens << [:DEDENT, indent.size]
+					tokens << [:NEWLINE, "\n"]
+				end
+				i += indent.size + 1
+      
+      # Match long operators such as ||, &&, ==, !=, <= and >=.
+      # One character long operators are matched by the catch all `else` at the bottom.
+      elsif operator = chunk[/\A(\|\||&&|==|!=|<=|>=)/, 1]
+        tokens << [operator, operator]
+        i += operator.size
+      
+      # Ignore whitespace
+      elsif chunk.match(/\A /)
+        i += 1
+      
+      # Catch all single characters
+      # We treat all other single characters as a token. Eg.: ( ) , . ! + - <
+      else
+        value = chunk[0,1]
+        tokens << [value, value]
+        i += 1
+        
+      end
+      
+    end
+    
+    # Close all open blocks
+    while indent = indent_stack.pop
+      tokens << [:DEDENT, indent_stack.last || 0]
+    end
+    
+    tokens
+  end
+end

data/lib/lexer/strings.rb

@@ -0,0 +1,13 @@
+class Strings
+
+	def convert_string(code)
+		strings = code.scan(/\t(\"[a-zA-Z0-9].*\")/)
+		strings.uniq!
+		strings.each do |string|
+			new_string = "print(#{string[0]})"
+			code = code.gsub(string[0], new_string)
+		end
+		return code
+	end
+
+end

data/lib/lexer/tags.rb

@@ -0,0 +1,100 @@
+class Tags
+
+	@@inline_tags = [ "area", "img", "param", "input", "option", "base", "link", 
+		"meta", "hr", "br", "wbr" ]
+
+	@@tags = ["DOCTYPE","a","abbr","acronym","address","applet","b",
+		"bdo","big","blockquote","body","button","caption","center","cite","code",
+		"colgroup","dd","del","dfn","dir","div","dl","dt","em","fieldset","font",
+		"form","frameset","h1","h2","h3","h4","h5","h6","head","html","i","iframe",
+		"ins","kbd","label","legend","li","map","menu","noframes","noscript",
+		"object","ol","optgroup","option","p","pre","q","s","samp","script",
+		"select","small","span","strike","strong","style","sub","sup","table",
+		"tbody","td","textarea","tfoot","th","thead","title","tr","tt","u","ul",
+		"var"]
+
+	def convert_tag(code, index, indent, tag, atr, inline=false)
+		content = code.scan(/(\t+[a-zA-Z0-9]+.*)/)
+		tab = ""
+		p_tab = ""
+		for i in 0..indent
+			if i == (indent - 1 )
+				p_tab = tab
+			else
+				tab += "\t"
+			end
+		end
+		attributes = convert_attr(atr).join(" ")
+		if inline
+			new_def = "#{p_tab}def tag_#{index}\n#{tab}print(\"<#{tag} #{attributes} />\")\n#{p_tab}tag_#{index}"
+		else
+			new_def = "def tag_#{index}\n#{tab}print(\"<#{tag} #{attributes}>\")"
+			content.each do |lol|
+				new_def += "\n" + lol[0]
+			end
+			new_def += "\n#{tab}print(\"</#{tag}>\")\n#{p_tab}tag_#{index}"	
+		end
+		return new_def
+	end
+
+	def convert_attr(atr)
+		atr.map {|x| x[0] + "'#{x[1]}'" }
+	end
+
+	def adding_attributes(code, tag)
+		_attr = [ [ "id", "#" ], [ "class", "\\." ] ]
+		_attr.each do |a|
+			orig = code.scan(/#{tag} ([.a-zA-Z0-9=-_ ]+)?(#{a[1]}([a-zA-Z0-9]+))/)
+			orig.map! {|x| [x[1], x[2]] }
+			orig.uniq!
+			orig.each do |_old|
+				_new = "#{a[0]}=#{_old[1]}"
+				code = code.gsub(_old[0], _new)
+			end
+		end
+		return code
+	end
+
+	def implement_tag(code, indent=1)
+		new_code = []
+		@@inline_tags.each do |tag|
+			general = code.scan(/(^(\t)+?(#{tag}(()$| )([ #.=_\-a-zA-Z0-9]+)?((\n\t.*)+)?).*)/)
+			general.map! {|x| x[0]}
+			general.each_with_index do |block, index|
+				new_indent = general[0].split("\t").count
+				_code_block = block
+				code_block = adding_attributes(block, tag)
+				strings = Strings.new
+				code_block = strings.convert_string( code_block )
+				atr = code_block.scan(/([a-zA-Z0-9_-]+=)'?"?([a-zA-Z0-9_-]+)'?"?/)
+				code_block = convert_tag( code_block , index, new_indent, tag, atr, true)
+				code = code.gsub(_code_block, code_block)
+			end
+		end
+		@@tags.each do |tag|
+			general = code.scan(/(^(#{tag}(()$| )([ #.=_\-a-zA-Z0-9]+)?((\n\t.*)+)?).*)/)
+			general.map! {|x| x[0]}
+			general.each_with_index do |block, index|
+				_code_block = block
+				code_block = adding_attributes(block, tag)
+				@@tags.each do |r_tag|
+					if !code_block.scan(/^(\t){#{indent}}(#{r_tag}(()$| )([a-zA-Z0-9= \t_\-#.\\'\/]+)?((\n\1{#{indent+1},})?(["#a= ()a-zA-Z0-9_.-\\'\/]+)?)+)/m).empty?
+						r_code = code_block.scan(/^(\t){#{indent}}(#{r_tag}(()$| )([a-zA-Z0-9= \t_\-#.\\'\/]+)?((\n\1{#{indent+1},})?(["#a= ()a-zA-Z0-9_.-\\'\/]+)?)+)/m)
+						r_code.each do |r|
+							new_indent = indent + 1
+							new_block = implement_tag(r[1], new_indent)
+							code_block = code_block.gsub(r[1], new_block)
+						end
+					end
+				end
+				strings = Strings.new
+				code_block = strings.convert_string( code_block )
+				atr = code_block.scan(/([a-zA-Z0-9_-]+=)([a-zA-Z0-9_-]+)/)
+				code_block = convert_tag( code_block , index, indent, tag, atr)
+				code = code.gsub(_code_block, code_block)
+			end
+		end
+		return code
+	end
+
+end

data/lib/nodes.rb

@@ -0,0 +1,56 @@
+# Collection of nodes each one representing an expression.
+class Nodes < Struct.new(:nodes)
+  def <<(node)
+    nodes << node
+    self
+  end
+end
+
+# Literals are static values that have a Ruby representation, eg.: a string, a number, 
+# true, false, nil, etc.
+class LiteralNode < Struct.new(:value); end
+class NumberNode < LiteralNode; end
+class StringNode < LiteralNode; end
+class TrueNode < LiteralNode
+  def initialize
+    super(true)
+  end
+end
+class FalseNode < LiteralNode
+  def initialize
+    super(false)
+  end
+end
+class NilNode < LiteralNode
+  def initialize
+    super(nil)
+  end
+end
+
+# Node of a method call or local variable access, can take any of these forms:
+# 
+#   method # this form can also be a local variable
+#   method(argument1, argument2)
+#   receiver.method
+#   receiver.method(argument1, argument2)
+#
+class CallNode < Struct.new(:receiver, :method, :arguments); end
+
+# Retrieving the value of a constant.
+class GetConstantNode < Struct.new(:name); end
+
+# Setting the value of a constant.
+class SetConstantNode < Struct.new(:name, :value); end
+
+# Setting the value of a local variable.
+class SetLocalNode < Struct.new(:name, :value); end
+
+# Method definition.
+class DefNode < Struct.new(:name, :params, :body); end
+
+# Class definition.
+class ClassNode < Struct.new(:name, :body); end
+
+# "if" control structure. Look at this node if you want to implement other control
+# structures like while, for, loop, etc.
+class IfNode  < Struct.new(:condition, :body); end