citrus-compiler 0.8.0

data/LICENSE

@@ -0,0 +1,32 @@
+Copyright (c) 2011 Mac Malone
+
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+   notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the author nor the names of his contributors
+   may be used to endorse or promote products derived from this software
+   without specific prior written permission.
+
+This license is subject to change without notice.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.

data/README.rdoc

@@ -0,0 +1,63 @@
+= Citrus
+
+Author::	Mac Malone
+License::	See LICENSE
+Copyright::	Copyright (c) 2010 Mac Malone
+
+Citrus is a simple dynamically typed linear language written in Ruby, Treetop, and LLVM. It is meant to be an example of how to write a basic compiler.
+
+Being linear, it could be called very c-like, but it has been written to have a syntax closer to Ruby. Its current main features are:
+
+* Dynamically typed
+* Extremely ruby-like syntax
+* Integer, Float, String, Boolean, and Array types
+* Easy integration of C functions into the API
+
+It's prime examples are in the example directory, but here is an excerpt from factorial.ct:
+
+	def factorial(num)
+	  if num == 0
+	    fac = 1
+	  else
+	    fac = num*factorial(num-1)
+	  end
+	  return fac
+	end
+
+	printf("factorial(%d): %d", 6, factorial(6))
+	
+As you can see, very ruby-like.
+
+== Installing & Requirements
+
+Citrus requires the following libraries:
+
+* LLVM 2.8 compiled with shared libraries
+  * On Mac OS X, the quickest way is to use `brew install llvm --shared`
+  * On Linux, there are usually pre-compiled packages
+* Ruby
+* Treetop
+* Ruby LLVM 2.9.1
+
+Everything except LLVM is installed when running `gem install citrus`
+
+== Running
+
+Citrus is a pretty simple thing to run:
+
+	$ ruby bin/citrus [options] FILENAME
+	    -O				Doesn't run optimization
+	    -i				Dumps bitcode
+	    -c NAME			Compiles to the given file name
+	    -h				Prints help
+	
+If citrus is run without -c it JIT complies the code, running it in place.
+
+== Problems & Todos
+
+* Hashs
+* Create a standard library
+* Better dynamically typed arrays (using structures)
+* Better exception handling (currently only works semi-effectively within begin blocks)
+* Garbage Collection
+	

data/bin/citrus.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby -s
+$:.unshift File.dirname(__FILE__) + "/../lib"
+require "citrus"
+
+if $h
+  puts <<-EOS
+  
+              ~= Citrus =~
+  
+             To run a file
+            citrus fruit.ct
+  
+    To compile to native application
+        citrus -c=lemon lime.ct
+  
+  EOS
+  exit
+end
+
+file = ARGV.first
+abort "Usage: citrus [-hiO] [-c=file.o] file.or" unless file
+
+g = Citrus.compile_file(File.expand_path(file))
+g.optimize unless $O
+
+case
+when $i: g.inspect
+when $c: g.compile(TrueClass === $c ? File.basename(file, File.extname(file)) : $c)
+else     g.run
+end

data/example/factorial.ct

@@ -0,0 +1,14 @@
+# Citrus factorials...
+
+def factorial(num)
+  if num == 0
+    fac = 1
+  else
+	fac = num*factorial(num-1)
+  end
+  return fac
+end
+
+puts("== factorial ")
+printf("factorial(%d): %d", 6, factorial(6))
+puts("")

data/example/simple.ct

@@ -0,0 +1,69 @@
+=begin
+  A simple test...
+  Included in Citrus source code
+  v1.0
+=end
+
+require 'factorial.ct'
+
+$exitcode = 7
+
+def input
+  buf = " "
+  read(0, buf, 1)
+  puts(buf)
+end
+
+def compare
+  num = 7
+  cond = (num == 4.5 + 2.5)
+  if cond
+    puts("7 = 4.5 + 2.5")
+  end
+  if num == 6 - 3
+    puts("6 - 3 = 7")
+  else
+    puts("6 - 3 != 7")
+  end
+end
+
+def iterate
+  iteration = 10
+  while iteration >= 0
+    printf("%d ", iteration)
+    iteration = iteration - 1
+  end
+  puts("")
+  array = ["lift", "off", "and", "away"]
+  for iteration in array
+    printf("%s ", iteration)
+  end
+  puts("")
+end
+
+def handle(err)
+  begin
+    puts("beginning exception handling...")
+    if err
+      raise(" - Erred! - ")
+    end
+  rescue
+    puts($!)
+  else
+    puts(" - No Error - ")
+  ensure
+    puts("...end of exception handling")
+  end
+end
+
+puts("== input ")
+input
+puts("== compare ")
+compare
+puts("== iterate ")
+iterate
+puts("== handle ")
+handle(true)
+handle(false)
+puts("== exit ")
+exit($exitcode)

data/lib/citrus.rb

@@ -0,0 +1,37 @@
+require "rubygems"
+require "treetop"
+
+require "citrus/core"
+require "citrus/runtime"
+require "citrus/compiler"
+require "citrus/exceptions"
+require "citrus/nodes"
+
+if File.file?(File.dirname(__FILE__) + "/citrus/grammar.rb")
+  # Take compiled one
+  require "citrus/grammar"
+else
+  Treetop.load File.dirname(__FILE__) + "/citrus/grammar.tt"
+end
+
+module Citrus
+  
+  def self.compile(code)
+    $compiler = Citrus::Compiler.new
+    $parser   = CitrusParser.new
+    
+    if node = $parser.parse(code)
+      node.compile($compiler)
+    else
+      error(SyntaxError.new)
+    end
+    
+    $compiler
+  end
+  
+  def self.compile_file(file)
+    $file = file
+    self.compile(File.read(file))
+  end
+  
+end

data/lib/citrus/compiler.rb

@@ -0,0 +1,65 @@
+require "citrus/compiler/generator"
+require "citrus/compiler/block"
+require "citrus/compiler/function"
+require "citrus/compiler/variable"
+require "citrus/compiler/global_strings"
+
+require "tempfile"
+
+module Citrus
+  class Compiler
+    
+    attr_reader :generator
+    attr_reader :module
+    
+    def initialize
+      @module = LLVM::Module.create("Citrus")
+      GlobalVariables.init(@module)
+      GlobalFunctions.init(@module)
+      @function = @module.functions.add("main", LLVM::Type.function([INT, LLVM::Type.pointer(PCHAR)], INT))
+      @generator = Generator.new(@module, @function)
+      GlobalStrings.init(@generator.builder)
+    end
+    
+    def preamble
+      Runtime.build_lib(@generator)
+    end
+    
+    def finish
+      @generator.builder.ret(INT.from_i(0))
+      @generator.finish
+    end
+    
+    def run
+      @engine = LLVM::ExecutionEngine.create_jit_compiler(@module)
+      @engine.run_function(@function, 0, 0)
+    end
+    
+    def to_file(file)
+      @module.write_bitcode(file)
+    end
+    
+    def compile(file)
+      #bc = Tempfile.new("#{file}.bc", "/tmp")
+      #as = Tempfile.new("#{file}.s", "/tmp")
+      to_file("#{file}.ctc.bc")
+      tool = LLVM.bin_path.empty? ? "llc" : File.join(LLVM.bin_path, "llc")
+      %x[#{tool} #{file}.ctc.bc -o #{file}.ctc.s]
+      %x[gcc #{file}.ctc.s -o #{file}]
+      File.delete("#{file}.ctc.bc")
+      File.delete("#{file}.ctc.s")
+      #bc.close!
+      #as.close!
+    end
+    
+    def optimize
+      PassManager.new(@engine).run(@module) unless @engine.nil?
+    end
+    
+    def inspect
+      @module.dump
+    end
+    
+  end   
+end
+      

data/lib/citrus/compiler/block.rb

@@ -0,0 +1,29 @@
+module Citrus
+  class Block
+    
+    def initialize(mod, function, parent)
+      @module = mod
+      @function = function
+      @parent = parent
+      build_block { |g| yield g if block_given? }
+    end
+    
+    def basic_block
+      return @generator.basic_block
+    end
+    alias :bb :basic_block
+    
+    def locals
+      return @generator.locals
+    end
+    
+    private
+    
+    def build_block
+      @generator = Generator.new(@module, @function, @parent)
+      yield @generator if block_given?
+      @generator.finish
+    end
+  
+  end
+end

data/lib/citrus/compiler/function.rb

@@ -0,0 +1,79 @@
+module Citrus
+  class Function
+    
+    attr_reader :varargs
+    attr_reader :generator
+    
+    def initialize(name, args, mod)
+      @name = name
+      @module = mod
+      @rtype = LLVM::Type.opaque
+      @atypes = args.map{LLVM::Type.opaque}
+      @args = args.map{|arg| arg.class.to_s == "String" ? arg.to_a : arg}
+      @varargs = @args.empty? ? false : (@args.last[0].slice(0, 1) == "*")
+      @func = @module.functions.add(name, LLVM::Type.function(@atypes, @rtype, :varargs => @vaargs))
+      build_function { |g| yield g if block_given? }
+    end
+    
+    def args
+      return @args.map{|arg| arg[0]}
+    end
+    
+    def return(value, builder)
+      @rtype.refine(LLVM::Type(value)) if @rtype.kind == :opaque
+      builder.ret(value)
+    end
+    
+    def call(args, builder)
+      for i in 0...@atypes.size
+        @atypes[i].refine(LLVM::Type(args[i])) if @atypes[i].kind == :opaque
+      end
+      builder.call(@func, *args)
+    end
+    
+    def force_types(args, ret=nil)
+      unless args.empty?
+        for i in 0...@atypes.size
+          @atypes[i].refine(LLVM::Type(args[i])) if @atypes[i].kind == :opaque
+        end
+      end
+      unless ret.nil?
+        @rtype.refine(ret) if @rtype.kind == :opaque
+      end
+    end
+    
+    def method_missing(symbol, *args, &block)
+      @func.send(symbol, *args, &block)
+    end
+    
+    private
+    
+    def build_function
+      @generator = Generator.new(@module, self)
+      @args.each do |arg|
+        @generator.assign(arg[0], @func.params[@args.index(arg)])
+      end
+      yield generator
+      @generator.return
+      @generator.finish
+    end
+  
+  end
+  
+  class GlobalFunctions
+  
+    def self.init(mod)
+      @module ||= mod
+      @functions ||= {}
+    end
+  
+    def self.add(name, args)
+      return @functions[name] = Function.new(name, args, @module) { |g| yield g if block_given? }
+    end
+    
+    def self.named(name)
+      return @functions[name]
+    end
+  
+  end
+end

data/lib/citrus/compiler/generator.rb

@@ -0,0 +1,303 @@
+module Citrus
+  class Generator
+    
+    attr_reader :basic_block
+    attr_reader :module
+    attr_reader :builder
+    attr_reader :locals
+    attr_reader :parent
+    
+    def initialize(mod, function, parent=nil)
+      @module = mod
+      @locals = {}
+      @parent = parent
+      @function = function
+      @basic_block = @function.basic_blocks.append
+      @builder = LLVM::Builder.create
+      @builder.position_at_end(@basic_block)
+    end
+    
+    def array(values)
+      ary = @builder.alloca(LLVM::Array(LLVM::Type(values.first), values.size))
+      for index in 0...values.size
+        ptr = @builder.gep(ary, [INT.from_i(0), INT.from_i(index)])
+        @builder.store(values[index], ptr)
+      end
+      return ary
+    end
+    
+    def string(value)
+      ptr = GlobalStrings.pointer(value)
+    end
+    
+    def float(value)
+      FLOAT.from_f(value)
+    end
+    
+    def number(value)
+      INT.from_i(value)
+    end
+    
+    def bool(value)
+      BOOL.from_i(value ? 1 : 0)
+    end
+    
+    def not(value)
+      @builder.not(value)
+    end
+    
+    def call(func, *args)
+      begin
+        GlobalFunctions.named(func).call(args, @builder)
+      rescue NoMethodError # for C methods
+        f = @module.functions.named(func)
+        raise NoMethodError if f.nil?
+        @builder.call(f, *args)
+      end
+    end
+    
+    def resolve_conflicts(*gens)
+      locals = []
+      gens.each{|g| locals += g.locals.keys}
+      stat = locals.inject(Hash.new(0)){|h, e| h[e]+=1; h}
+      stat.select{|k, v| v > 1}.collect{|a| a[0]}.each do |k|
+        resolve_conflict(k, *gens)
+      end
+    end
+    
+    def resolve_conflict(name, *gens)
+      ty = INT
+      nodes = {}
+      gens.select{|g| g.locals.has_key?(name)}.each do |g|
+        bb = g.basic_block
+        var = g.locals[name]
+        builder = LLVM::Builder.create
+        if bb == @builder.insert_block && !nodes.has_key?(bb.previous)
+          builder.position_before(bb.previous.instructions.last)
+          nodes[bb.previous] = var.value(builder)
+        else
+          builder.position_before(bb.instructions.last)
+          nodes[bb] = var.value(builder)
+        end
+        builder.dispose
+      end
+      ptr = @builder.phi(ty, nodes)
+      self.assign(name, ptr)
+    end
+    
+    def assign(name, value)
+      unless @locals.has_key?(name)
+        @locals[name] = Variable.new(value, @builder) 
+      else
+        @locals[name].assign(value, @builder)
+      end
+    end
+    
+    def assign_global(name, value)
+      unless GlobalVariables.named(name)
+        GlobalVariables.add(name, value, @builder)
+      else
+        GlobalVariables.named(name).assign(value, @builder)
+      end
+    end
+    
+    def assign_index(name, index, value)
+      ary = @locals[name].value(@builder)
+      ptr = @builder.gep(ary, [INT.from_i(0), index])
+      @builder.store(value, ptr)
+    end
+    
+    def compare(op, lval, rval)
+      case op.to_s
+      when *CMP_MAPPING.keys
+        if LLVM::Type(lval) == FLOAT.type || LLVM::Type(rval) == FLOAT.type
+          symbol = "o#{CMP_MAPPING[op.to_s].to_s}".to_sym
+          if LLVM::Type(lval) != FLOAT.type
+            lval = @builder.ui2fp(lval, FLOAT.type)
+          elsif LLVM::Type(rval) != FLOAT.type
+            rval = @builder.ui2fp(rval, FLOAT.type)
+          end
+          @builder.fcmp(symbol, lval, rval)
+        else
+          symbol = CMP_MAPPING[op.to_s]
+          symbol = "s#{symbol.to_s}".to_sym unless symbol == :eq || symbol == :ne
+          @builder.icmp(symbol, lval, rval)
+        end
+      when "&&", "and"
+        @builder.and(lval, rval)
+      when "||", "or"
+        @builder.or(lval, rval)
+      end
+    end
+    
+    def equate(op, lval, rval)
+      if LLVM::Type(lval) == FLOAT.type || LLVM::Type(rval) == FLOAT.type
+        symbol = "f#{EQU_MAPPING[op.to_s].to_s}".to_sym
+        if LLVM::Type(lval) != FLOAT.type
+          lval = @builder.ui2fp(lval, FLOAT.type)
+        elsif LLVM::Type(rval) != FLOAT.type
+          rval = @builder.ui2fp(rval, FLOAT.type)
+        end
+        @builder.send(symbol, lval, rval)
+      else
+        symbol = EQU_MAPPING[op.to_s]
+        symbol = :sdiv if symbol == :div
+        @builder.send(symbol, lval, rval)
+      end
+    end
+    
+    def vars
+      return @parent.nil? ? @locals : @locals.merge(@parent.vars) 
+    end
+    
+    def load(name)
+      if @locals.has_key?(name)
+        @locals[name].value(@builder)
+      else
+        self.vars[name].value(@builder)
+      end
+    end
+    
+    def load_global(name)
+      GlobalVariables.named(name).value(@builder)
+    end
+    
+    def load_index(ary, index)
+      @builder.load(@builder.gep(ary, [INT.from_i(0), index]))
+    end
+    
+    def function(name, args)
+      GlobalFunctions.add(name, args) { |g| yield g }
+    end
+    
+    def declare(name, args, ret, varargs = false)
+      rtype = DEC_MAPPING[ret.to_sym]
+      atypes = args.map{|arg| DEC_MAPPING[arg.to_sym]}
+      @module.functions.add(name.to_s, LLVM::Type.function(atypes, rtype, :varargs => varargs))
+    end
+    
+    def block
+      Block.new(@module, @function, self) { |g| yield g if block_given? }
+    end
+    
+    def condition(cond, thenblock, elseblock, elsifs=[])
+      @basic_block = self.block.bb
+      eb = elsifs.empty? ? elseblock : self.block
+      efbs = []
+      @builder.cond(cond, thenblock.bb, eb.bb)
+      for i in 0...elsifs.length
+        efbs += eb
+        @builder.position_at_end(eb.bb)
+        neb = i+1 == elsifs.length ? elseblock : self.block
+        @builder.cond(elsifs[i][0], elsifs[i][1].bb, eb.bb)
+        @builder.position_at_end(elsifs[i][1].bb)
+        @builder.br(@basic_block)    
+        eb = neb
+      end
+      @builder.position_at_end(thenblock.bb)
+      @builder.br(@basic_block)
+      @builder.position_at_end(elseblock.bb)
+      @builder.br(@basic_block)
+      @builder.position_at_end(@basic_block)
+      self.resolve_conflicts(thenblock, elseblock, *efbs)
+    end
+    
+    def case(val, cases, elseblock)
+      ncases = {}
+      for pair in cases
+        ncases[pair[0].bb] = pair[1]
+      end
+      switch = @builder.switch(val, elseblock.bb, ncases)
+      @basic_block = self.block.bb
+      @builder.position_at_end(elseblock.bb)
+      @builder.br(@basic_block)
+      ncases.each_value do |c|
+        @builder.position_at_end(c[1])
+        @builder.br(@basic_block)
+      end
+      @builder.position_at_end(@basic_block)
+      self.resolve_conflicts(elseblock, *cases.keys)
+    end
+    
+    def begin(rblock, elblock, enblock)
+      cond = self.compare(:==, self.load_global(STS_GLOBAL), self.number(1))
+      @builder.cond(cond, rblock.bb, elblock.bb)
+      @basic_block = self.block.bb
+      @builder.position_before(rblock.bb.instructions.first)
+      self.assign_global(STS_GLOBAL, self.number(0))
+      @builder.position_at_end(rblock.bb)
+      @builder.br(enblock.bb)
+      @builder.position_at_end(elblock.bb)
+      @builder.br(enblock.bb)
+      @builder.position_before(enblock.bb.instructions.first)
+      self.resolve_conflicts(rblock, elblock)
+      @builder.position_at_end(enblock.bb)
+      @builder.br(@basic_block)
+      @builder.position_at_end(@basic_block)
+      @locals.merge!(enblock.locals)
+    end
+    
+    def unwind
+      @builder.unwind
+    end
+    
+    # Needs to be called before running any loop command
+    # (specifically before calculating the conditions for the loop)
+    def preploop(looptype=nil, *args)
+      if looptype == :for
+        self.assign("for", INT.from_i(0))
+        self.assign(args[0], self.load_index(args[1], self.number(0)))
+      end
+      @basic_block = self.block.bb
+      @builder.br(@basic_block)
+      @builder.position_at_end(@basic_block)
+    end
+    
+    def while(cond)
+      @builder.position_before(@basic_block.instructions.first)
+      generator = Generator.new(@module, @function, self)
+      yield generator
+      generator.break(@basic_block)
+      generator.finish
+      self.resolve_conflicts(generator, self)
+      @builder.position_at_end(@basic_block)
+      @basic_block = self.block.bb
+      @builder.cond(cond, generator.basic_block, @basic_block)
+      @builder.position_at_end(@basic_block)
+    end
+    
+    def for(var, indices)
+      generator = Generator.new(@module, @function, self)
+      generator.assign(var, generator.load_index(indices, generator.load("for")))
+      yield generator
+      generator.assign("for", generator.equate(:+, generator.load("for"), generator.number(1)))
+      generator.break(@basic_block)
+      generator.finish
+      @builder.position_at_end(@basic_block)
+      self.resolve_conflict("for", generator, self)
+      @basic_block = self.block.bb
+      size = LLVM::C.LLVMGetArrayLength(LLVM::Type(indices).element_type)
+      cond = self.compare(:<, self.load("for"), self.number(size))
+      @builder.cond(cond, generator.basic_block, @basic_block)
+      @builder.position_at_end(@basic_block)
+    end
+    
+    def return(value=self.number(0))
+      unless @finished
+        @function.return(value, @builder)
+        @finished = true
+      end
+    end
+    
+    def break(block)
+      unless @finished
+        @builder.br(block)
+      end
+    end
+    
+    def finish
+      @builder.dispose
+    end
+
+  end
+end

data/lib/citrus/compiler/global_strings.rb

@@ -0,0 +1,19 @@
+module Citrus
+  class GlobalStrings
+  
+    def self.init(builder)
+      @builder ||= builder
+      @pointers ||= {}
+    end
+  
+    def self.pointer(value)
+      if @pointers.has_key?(value)
+        return @pointers[value]
+      else
+        @pointers[value] = @builder.global_string_pointer(value)
+        return @pointers[value]
+      end
+    end
+  
+  end
+end

data/lib/citrus/compiler/variable.rb

@@ -0,0 +1,65 @@
+module Citrus
+  class Variable
+    
+    attr_reader :type
+    attr_reader :pointer
+    
+    def initialize(value, builder)
+      @type = LLVM::Type(value)
+      @pointer = builder.alloca(@type)
+      builder.store(value, @pointer)
+    end
+    
+    def assign(value, builder)
+      type = LLVM::Type(value)
+      unless type == @type
+        @type = type
+        @pointer = builder.alloca(type)
+      end
+      builder.store(value, @pointer)
+    end
+    
+    def value(builder)
+      builder.load(@pointer)
+    end
+  
+  end
+  
+  class GlobalVariable < Variable
+    
+    def initialize(name, value, mod, builder)
+      @name = name
+      @module = mod
+      @type = LLVM::Type(value)
+      @pointer = @module.globals.add(@type, @name)
+      @pointer.initializer = value
+    end
+    
+    def assign(value, builder)
+      @type = LLVM::Type(value)
+      builder.store(value, @pointer)
+    end
+    
+    def value(builder)
+      builder.load(@module.globals.named(@name))
+    end
+  
+  end
+  
+  class GlobalVariables
+  
+    def self.init(mod)
+      @module ||= mod
+      @variables ||= {}
+    end
+  
+    def self.add(name, value, builder)
+      return @variables[name] = GlobalVariable.new(name, value, @module, builder)
+    end
+    
+    def self.named(name)
+      return @variables[name]
+    end
+  
+  end
+end

data/lib/citrus/core.rb

@@ -0,0 +1,31 @@
+require "rubygems"
+
+=begin # Custom LLVM Loading (for me only)
+require "llvm/load"
+LLVM.load("#{File.dirname(__FILE__)}/../llvm-2.9")
+=end
+
+require 'llvm/core'
+require 'llvm/execution_engine'
+require 'llvm/transforms/scalar'
+
+module Citrus
+
+  LLVM.init_x86
+
+  PCHAR = LLVM::Type.pointer(LLVM::Int8)
+  FLOAT = LLVM::Double
+  INT   = LLVM::Int
+  BOOL  = LLVM::Int1
+
+  CMP_MAPPING = { "==" => :eq,  "!=" => :ne,  ">" => :gt, 
+                  ">=" => :ge,  "<" => :lt,  "<=" => :le }
+                
+  EQU_MAPPING = { "+" => :add,  "-" => :sub,  "/" => :div, "*" => :mul }
+  
+  DEC_MAPPING = { :bool => BOOL, :float => FLOAT, :int => INT, :string => PCHAR }
+  
+  ERR_GLOBAL = "$!"
+  STS_GLOBAL = "$?"
+    
+end

data/lib/citrus/exceptions.rb

@@ -0,0 +1,33 @@
+module Citrus  
+  class SyntaxError < RuntimeError  
+    def initialize
+      line = $parser.failure_line
+      col = $parser.failure_column
+      str = $parser.input.lines.to_a[line-1]
+      str = str.slice(col-1, str.length).delete($/)
+      str = "file end" if str.empty?
+      puts $parser.failure_reason
+      super("Unexpected #{str} at #{line}:#{col}.")
+    end 
+  end
+  
+  class NameError < RuntimeError  
+    def initialize(name, index=nil, ff=false)
+      index ||= $parser.input.index(name)
+      line = $parser.input.line_of(index)
+      col = $parser.input.column_of(index)
+      super("Undefined #{ff ? "" : "local variable or "}function '#{name}' at #{line}:#{col}.")
+    end 
+  end
+  
+  class NotFoundError < StandardError
+    def initialize(file)
+      super("No such file or directory - #{file}.")
+    end
+  end
+  
+  def self.error(error)
+    puts("#{error.message} (#{error.class.to_s.split('::').last})")
+    exit(1)
+  end  
+end

data/lib/citrus/nodes.rb

@@ -0,0 +1,238 @@
+module Citrus
+  class ::Treetop::Runtime::SyntaxNode
+    def value
+      text_value
+    end
+    
+    def codegen(context)
+    end
+  end
+  Node = Treetop::Runtime::SyntaxNode
+  
+  class Script < Node
+    def compile(compiler)
+      compiler.preamble
+      expressions.each { |e| e.codegen(compiler.generator) }
+      compiler.finish
+    end
+  end
+
+  class Expression < Node
+    def codegen(g)
+      statements.map { |s| s.codegen(g) }
+    end
+  end
+  
+  class Assign < Node
+    def codegen(g)
+      g.assign(var.value, expression.codegen(g).last)
+    end
+  end
+  
+  class GlobalEq < Node
+    def codegen(g)
+      g.assign_global(globalvar.value, expression.codegen(g).last)
+    end
+  end
+  
+  class IndexEq < Node
+    def codegen(g)
+      g.assign_index(index.var.value, index.expression.codegen(g).last, expression.codegen(g).last)
+    end
+  end
+  
+  class Cmp < Node
+    def codegen(g)
+      g.compare(op.value, object.codegen(g), expression.codegen(g).last)
+    end
+  end
+  
+  class Equation < Node
+    def codegen(g)
+      g.equate(op.value, object.codegen(g), expression.codegen(g).last)
+    end
+  end
+  
+  class Require < Node
+    def codegen(g)
+      file = string.value
+      file = File.join(File.dirname($file), file) unless $file.nil?
+      error(NotFoundError.new(file)) unless File.exists?(file)
+      if node = $parser.parse(File.read(file))
+        node.expressions.each { |e| e.codegen(g) }
+      else
+        error(SyntaxError.new)
+      end
+    end
+  end
+  
+  class Call < Node
+    def codegen(g)
+      arg_values = calllist.args.map { |arg| arg.codegen(g) }
+      begin
+        g.call(func.value, *arg_values)
+      rescue
+        Citrus.error(NameError.new(func.value, self.interval.first, true))
+      end
+    end
+  end
+  
+  class Def < Node
+    def codegen(g)
+      args = arglist.args.map do |arg|
+        [arg.var.value, arg.default.nil? ? nil : arg.default.codegen(g)]
+      end
+      g.function(func.value, args) do |gf|
+        expressions.each { |e| e.codegen(gf) }
+      end
+    end
+  end
+  
+  class Return < Node
+    def codegen(g)
+      g.return(expression.codegen(g).last)
+    end
+  end
+  
+  class Begin < Node
+    def codegen(g)
+      expressions.each { |e| e.codegen(g) }
+      rb = g.block do |gb|
+        rescue_expressions.each { |e| e.codegen(gb) }
+      end
+      elb = g.block do |gb|
+        else_expressions.each { |e| e.codegen(gb) }
+      end
+      enb = g.block do |gb|
+        ensure_expressions.each { |e| e.codegen(gb) }
+      end
+      g.begin(rb, elb, enb)
+    end
+  end
+  
+  class If < Node
+    def codegen(g)
+      tb = g.block do |gb|
+        expressions.each { |e| e.codegen(gb) }
+      end
+      elfs = elsifs.each do |elf|
+        [elf.condition.codegen(g).last,
+        g.block do |gb|
+          elf.elements.each { |e| e.expression.codegen(gb) }
+        end]
+      end
+      fb = g.block do |gb|
+        else_expressions.each { |e| e.codegen(gb) }
+      end
+      g.condition(condition.codegen(g).last, tb, fb, elfs)
+    end
+  end
+  
+  class Unless < Node
+    def codegen(g)
+      tb = g.block do |gb|
+        expressions.each { |e| e.codegen(gb) }
+      end
+      fb = g.block do |gb|
+        else_expressions.each { |e| e.codegen(gb) }
+      end
+      g.condition(g.not(condition.codegen(g).last), tb, fb)
+    end
+  end
+  
+  class Case < Node
+    def codegen(g)
+      cases = {}
+      whens.each do |w|
+        cases[w.val.codegen(g).last] = g.block do |gb|
+          w.elements.each { |e| e.expression.codegen(gb) }
+        end
+      end
+      eb = g.block do |gb|
+        else_expressions.each { |e| e.codegen(gb) }
+      end
+      g.case(switch.codegen(g).last, cases, eb)
+    end
+  end
+  
+  class While < Node
+    def codegen(g)
+      g.preploop(:while)
+      g.while(condition.codegen(g).last) do |gw|
+        expressions.each { |e| e.codegen(gw) }
+      end
+    end
+  end
+  
+  class For < Node
+    def codegen(g)
+      ary = indices.codegen(g)
+      g.preploop(:for, var.value, ary)
+      g.for(var.value, ary) do |gf|
+        expressions.each { |e| e.codegen(gf) }
+      end
+    end
+  end
+  
+  class Index < Node
+    def codegen(g)
+      g.load_index(var.codegen(g), expression.codegen(g).last)
+    end
+  end
+  
+  class GlobalVar < Node
+    def codegen(g)
+      g.load_global(value)
+    end
+  end
+  
+  class Var < Node
+    def codegen(g)
+      begin
+        g.load(value)
+      rescue NoMethodError
+        begin
+          g.call(value)
+        rescue NoMethodError
+          Citrus.error(NameError.new(value, self.interval.first))
+        end
+      end
+    end
+  end
+  
+  class ArrayNode < Node
+    def codegen(g)
+      g.array(value.map{ |v| v.codegen(g).last })
+    end
+  end
+  
+  class StringNode < Node
+    def codegen(g)
+      g.string(value)
+    end
+  end
+  
+  class SymbolNode < Node
+    def codegen(g)
+      g.string(value)
+    end
+  end
+  
+  class FloatNode < Node
+    def codegen(g)
+      g.float(value)
+    end
+  end
+  
+  class NumberNode < Node
+    def codegen(g)
+      g.number(value)
+    end
+  end
+  
+  class BoolNode < Node
+    def codegen(g)
+      g.bool(value)
+    end
+  end
+end

data/lib/citrus/runtime.rb

@@ -0,0 +1,32 @@
+module Citrus
+  module Runtime
+    
+    def self.build_lib(generator)
+      @ct = generator
+      build_clib
+      build_globals
+      build_raise
+    end
+    
+    def self.build_clib
+      @ct.declare(:printf, [:string], :int, true)
+      @ct.declare(:puts, [:string], :int)
+      @ct.declare(:read, [:int, :string, :int], :int)
+      @ct.declare(:exit, [:int], :int)
+    end
+    
+    def self.build_globals
+      @ct.assign_global(ERR_GLOBAL, @ct.string(""))
+      @ct.assign_global(STS_GLOBAL, @ct.number(0))
+    end
+    
+    def self.build_raise
+      func = @ct.function("raise", ["msg"]) do |gf|
+        gf.assign_global(ERR_GLOBAL, gf.load("msg"))
+        gf.assign_global(STS_GLOBAL, gf.number(1))
+      end
+      func.force_types([PCHAR], INT)
+    end
+    
+  end
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification 
+name: citrus-compiler
+version: !ruby/object:Gem::Version 
+  hash: 63
+  prerelease: 
+  segments: 
+  - 0
+  - 8
+  - 0
+  version: 0.8.0
+platform: ruby
+authors: 
+- Mac Malone
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-02 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: treetop
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 21
+        segments: 
+        - 1
+        - 4
+        - 9
+        version: 1.4.9
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: ruby-llvm
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 41
+        segments: 
+        - 2
+        - 9
+        - 1
+        version: 2.9.1
+  type: :runtime
+  version_requirements: *id002
+description: 
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- LICENSE
+files: 
+- lib/citrus/compiler/block.rb
+- lib/citrus/compiler/function.rb
+- lib/citrus/compiler/generator.rb
+- lib/citrus/compiler/global_strings.rb
+- lib/citrus/compiler/variable.rb
+- lib/citrus/compiler.rb
+- lib/citrus/core.rb
+- lib/citrus/exceptions.rb
+- lib/citrus/nodes.rb
+- lib/citrus/runtime.rb
+- lib/citrus.rb
+- bin/citrus.rb
+- example/factorial.ct
+- example/simple.ct
+- README.rdoc
+- LICENSE
+homepage: http://github.com/tophat/citrus
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: 
+- LLVM v2.9
+rubyforge_project: 
+rubygems_version: 1.7.2
+signing_key: 
+specification_version: 3
+summary: Linear compiler written in Ruby
+test_files: []
+