koi-reference-compiler 0.0.1

data/.gitignore

@@ -0,0 +1,3 @@
+*.gem
+*.gemspec
+*.swp

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Aaron Gough (http://thingsaaronmade.com/)
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,76 @@
+= koi-reference-compiler
+
+This is the reference compiler implementation for the programming language {Koi}[http://github.com/aarongough/koi]. This is a very simple compiler that does no optimization, and because of this remains very easy to understand. The compiler is implemented using the {delegation pattern}[http://en.wikipedia.org/wiki/Delegation_pattern] in that a tree representing the program is built up out of subclasses of the SyntaxNode class, each of which knows how to compile it's own specific instruction and nothing more.
+
+=== Example
+
+Take, for example, a very simple (and incorrect!) program that just pushes an integer onto the stack. The {Abstract Syntax Tree (AST)}[http://en.wikipedia.org/wiki/Abstract_syntax_tree] for such a program might look like this:
+
+  <IntegerLiteral "1">
+  
+In order to compile this program we might create an instance method on the IntegerLiteral class that looks like this:
+
+  class IntegerLiteral < SyntaxNode
+    def compile
+      return [PUSH_INT, self.text_value.to_i]
+    end
+  end
+  
+This method simply produces the opcode PUSH_INT and provides the integer value of the text_value of the syntax node, in this case "1". This is obviously a minimal case, but it demonstrates the principal in a straight-forward way.
+
+=== Abstract Syntax Tree Format
+
+The compiler expects the AST to be passed to it in the form of a nested hash which represents the program structure. The AST hash for the program:
+
+  test = 1
+  
+would look like so:
+
+  {
+    :name => "Statement",
+    :text_value => "test = 1",
+    :offset => 0,
+    :elements => [
+      {
+        :name => "AssignmentOperator",
+        :text_value => "=",
+        :offset => 5,
+        :elements => nil
+      },
+      {
+        :name => "Expression",
+        :text_value => "1",
+        :offset => 7,
+        :elements => [
+          {
+            :name => "IntegerLiteral",
+            :text_value => "1",
+            :offset => 7,
+            :elements => nil
+          }
+        ]
+      }
+    ]
+  }
+  
+
+=== Installation
+
+This compiler is normally installed as part of Koi's default toolchain. However if you would like to install it on it's own you can do so by installing the gem like so:
+
+  gem install koi-reference-compiler
+
+=== Usage
+
+  require 'rubygems'
+  require 'koi-reference-compiler'
+  
+  include KoiReferenceCompiler
+  
+  bytecode = Compiler.compile( hash_representing_abstract_syntax_tree )
+
+=== Author & Credits
+
+Author:: {Aaron Gough}[mailto:aaron@aarongough.com]
+
+Copyright (c) 2010 {Aaron Gough}[http://thingsaaronmade.com/] ({thingsaaronmade.com}[http://thingsaaronmade.com/]), released under the MIT license

data/Rakefile

@@ -0,0 +1,42 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "koi-reference-compiler"
+    gemspec.summary = "The reference compiler for the Koi language."
+    gemspec.description = "The reference compiler for the Koi language."
+    gemspec.email = "aaron@aarongough.com"
+    gemspec.homepage = "http://github.com/aarongough/min-koi"
+    gemspec.authors = ["Aaron Gough"]
+    gemspec.rdoc_options << '--line-numbers' << '--inline-source'
+    gemspec.extra_rdoc_files = ['README.rdoc', 'MIT-LICENSE']
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end
+
+
+desc 'Test koi-reference-compiler.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib/*.rb'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+
+desc 'Generate documentation for koi-reference-compiler.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'koi-reference-compiler'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+  rdoc.rdoc_files.include('app/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/koi-reference-compiler.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+
+require File.expand_path(File.join(File.dirname(__FILE__), 'koi-reference-compiler/syntax_node.rb'))
+
+require_files = []
+require_files.concat Dir[File.join(File.dirname(__FILE__), 'koi-reference-compiler', '**', '*.rb')]
+
+require_files.each do |file|
+  require File.expand_path(file)
+end

data/lib/koi-reference-compiler/exceptions.rb

@@ -0,0 +1,2 @@
+class CompileError < Exception
+end

data/lib/koi-reference-compiler/koi-reference-compiler.rb

@@ -0,0 +1,23 @@
+module KoiReferenceCompiler
+
+  class Compiler
+    
+    def self.compile(ast_hash)
+      tree = self.load_ast_hash(ast_hash)
+      bytecode = tree.compile
+      return bytecode
+    end
+    
+    def self.load_ast_hash(hash)
+      unless(hash[:elements].nil?)
+        elements = hash[:elements].map {|x| self.load_ast_hash(x) }
+      else
+        elements = nil
+      end
+      tree = Kernel.const_get("KoiReferenceCompiler").const_get(hash[:name]).new(hash[:text_value], hash[:offset], elements)
+      return tree
+    end
+    
+  end
+  
+end

data/lib/koi-reference-compiler/node_extensions/assignment/assignment.rb

@@ -0,0 +1,12 @@
+module KoiReferenceCompiler
+
+  class Assignment < SyntaxNode
+    def compile
+      bytecode = []
+      bytecode.concat( self.elements[2].compile )
+      bytecode.concat( self.elements[0].compile )
+      return bytecode
+    end
+  end
+  
+end

data/lib/koi-reference-compiler/node_extensions/blocks/block.rb

@@ -0,0 +1,13 @@
+module KoiReferenceCompiler
+
+  class Block < SyntaxNode
+    def compile
+      bytecode = []
+      self.elements.each do |element|
+        bytecode.concat( element.compile )
+      end
+      return bytecode
+    end
+  end
+  
+end

data/lib/koi-reference-compiler/node_extensions/control_flow/if.rb

@@ -0,0 +1,14 @@
+module KoiReferenceCompiler
+
+  class If < SyntaxNode
+    def compile
+      bytecode = self.elements[0].compile
+      block = self.elements[1].compile
+      bytecode.concat([
+        JUMP_UNLESS, block.length + 2
+      ])
+      bytecode.concat( block )
+    end
+  end
+  
+end

data/lib/koi-reference-compiler/node_extensions/control_flow/unless.rb

@@ -0,0 +1,14 @@
+module KoiReferenceCompiler
+
+  class Unless < SyntaxNode
+    def compile
+      bytecode = self.elements[0].compile
+      block = self.elements[1].compile
+      bytecode.concat([
+        JUMP_IF, block.length + 2
+      ])
+      bytecode.concat( block )
+    end
+  end
+  
+end

data/lib/koi-reference-compiler/node_extensions/expressions/additive_expression.rb

@@ -0,0 +1,13 @@
+module KoiReferenceCompiler
+
+  class AdditiveExpression < SyntaxNode
+    def compile
+      bytecode = []
+      bytecode.concat(self.elements[0].compile)
+      bytecode.concat(self.elements[2].compile)
+      bytecode.concat(self.elements[1].compile)
+      return bytecode
+    end
+  end
+  
+end

data/lib/koi-reference-compiler/node_extensions/expressions/comparative_expression.rb

@@ -0,0 +1,13 @@
+module KoiReferenceCompiler
+
+  class ComparativeExpression < SyntaxNode
+    def compile
+      bytecode = []
+      bytecode.concat(self.elements[0].compile)
+      bytecode.concat(self.elements[2].compile)
+      bytecode.concat(self.elements[1].compile)
+      return bytecode
+    end
+  end
+  
+end

data/lib/koi-reference-compiler/node_extensions/expressions/expression.rb

@@ -0,0 +1,9 @@
+module KoiReferenceCompiler
+
+  class Expression < SyntaxNode
+    def compile
+      return self.elements.first.compile
+    end
+  end
+  
+end

data/lib/koi-reference-compiler/node_extensions/expressions/multitive_expression.rb

@@ -0,0 +1,13 @@
+module KoiReferenceCompiler
+
+  class MultitiveExpression < SyntaxNode
+    def compile
+      bytecode = []
+      bytecode.concat(self.elements[0].compile)
+      bytecode.concat(self.elements[2].compile)
+      bytecode.concat(self.elements[1].compile)
+      return bytecode
+    end
+  end
+  
+end

data/lib/koi-reference-compiler/node_extensions/functions/function_call.rb

@@ -0,0 +1,54 @@
+module KoiReferenceCompiler
+
+  class FunctionCall < SyntaxNode
+    def compile
+      number_of_arguments = self.elements.length - 1
+    
+      bytecode = []
+      bytecode.concat( self.elements[2].compile ) if(number_of_arguments > 1)
+      bytecode.concat( self.elements[1].compile ) if(number_of_arguments > 0)
+      
+      function_name = self.elements.first.text_value
+      
+      if( function_name == "print")
+        raise_error unless(number_of_arguments == 1)
+        bytecode << PRINT
+        
+      elsif( function_name == "gets")
+        raise_error unless(number_of_arguments == 0)
+        bytecode << GETS
+        
+      elsif( function_name == "call")
+        raise_error unless(number_of_arguments == 2)
+        bytecode << CALL
+        
+      elsif( function_name == "tailcall")
+        raise_error unless(number_of_arguments == 1 || number_of_arguments == 2)
+        bytecode << TAILCALL
+        
+      elsif( function_name == "return")
+        raise_error unless(number_of_arguments == 0 || number_of_arguments == 1)
+        bytecode << RETURN
+        
+      elsif( function_name == "to_string")
+        raise_error unless(number_of_arguments == 1)
+        bytecode <<  TO_STRING
+        
+      elsif( function_name == "type_of")
+        raise_error unless(number_of_arguments == 1)
+        bytecode << TYPEOF
+        
+      else
+        raise CompileError, "Unknown function: #{function_name} at offset: #{self.elements.first.offset}"
+      end
+    end
+    
+    private
+    
+      def raise_error()
+        function_name = self.elements.first.text_value
+        raise CompileError, "Wrong number of arguments for: #{function_name}() at offset: #{self.elements.first.offset}"
+      end
+  end
+  
+end

data/lib/koi-reference-compiler/node_extensions/functions/function_definition.rb

@@ -0,0 +1,19 @@
+module KoiReferenceCompiler
+
+  class FunctionDefinition < SyntaxNode
+    def compile
+      function_id = self.offset
+      bytecode = [
+        PUSH_FUNCTION, function_id
+      ]
+      bytecode.concat( self.elements[0].compile )
+      bytecode.concat( self.elements[1].compile )
+      bytecode.concat([
+        RETURN,
+        END_FUNCTION, 0,
+        END_FUNCTION, function_id
+      ])
+    end
+  end
+  
+end

data/lib/koi-reference-compiler/node_extensions/hash_literals/hash_access.rb

@@ -0,0 +1,12 @@
+module KoiReferenceCompiler
+
+  class HashAccess < SyntaxNode
+    def compile
+      bytecode = []
+      bytecode.concat( self.elements[0].compile )
+      bytecode.concat( self.elements[1].compile )
+      return bytecode
+    end
+  end
+  
+end

data/lib/koi-reference-compiler/node_extensions/hash_literals/hash_accessor.rb

@@ -0,0 +1,15 @@
+module KoiReferenceCompiler
+
+  class HashAccessor < SyntaxNode
+    def compile_get
+      bytecode = self.elements.first.compile
+      bytecode << GET_KEY
+    end
+    
+    def compile_set
+      bytecode = self.elements.first.compile
+      bytecode << SET_KEY
+    end
+  end
+  
+end

data/lib/koi-reference-compiler/node_extensions/hash_literals/hash_accessor_list.rb

@@ -0,0 +1,26 @@
+module KoiReferenceCompiler
+
+  class HashAccessorList < SyntaxNode
+    def compile
+      bytecode = []
+      if(self.parent.is_a?(HashAssignment))
+        self.elements.each_index do |x|
+          if(x == self.elements.length - 1)
+            bytecode.concat( self.elements[x].compile_set )
+          else
+            bytecode.concat( self.elements[x].compile_get )
+          end
+        end
+        bytecode << POP
+      elsif(self.parent.is_a?(HashAccess))
+        self.elements.each do |x|
+          bytecode.concat( x.compile_get )
+        end
+      else  
+        raise CompileError, "Unkown parent for HashAccessorList: #{self.parent.class}"
+      end
+      return bytecode
+    end
+  end
+  
+end