Add README.

README.md

@@ -1,22 +1,64 @@
 # chalk
 
-TODO: Write a description here
+Chalk is a basic compiler from a toy language into CHIP-8 bytecode.
+It supports some higher-level constructs like looks and if-statements,
+and has some higher-level functions for drawing numbers and sprites.
 
 ## Installation
 
-TODO: Write installation instructions here
+To compile chalk, simply run
+```Bash
+crystal build --release src/chalk.cr
+```
 
 ## Usage
+### Syntax
+Chalk has minimal syntax. All code goes into functions, which are declared as follows:
+```
+fun function(param, another_param): return_type {
 
-TODO: Write usage instructions here
+}
+```
+All parameters are assumed to be of type `u8`, an unsigned byte.
+The return type can be either `u8` or `u0`, the latter being the same as `void` in C.
+Users can declare variables using the `var` keyword:
+```
+var name = 5;
+```
+Assigning to existing variables is performed as such:
+```
+name = 6;
+```
+It's possible to call another function, which uses the CHIP-8 stack. This stack
+is used exclusively for function calls, and may not exceed 12, as per the specifications
+of the CHIP-8 virtual machine.
+```
+var result = double(name);
+```
+Additionally, to ensure that user-defined variables stored
+in registers are not modified, chalk uses its own custom stack, placed at the end of the program.
+This stack is accessed by modifying a stack pointer register, which holds the offset from the beginning of the stack. Because CHIP-8 registers can only hold up 8-bit unsinged numbers, the stack is therefore limited to 254 items.
 
-## Development
+If statements take "truthy" values to be those that have a nonzero value. As such,
+`if (0) {}` will never run, while `while(5) {}` will never terminate. Input can be awaited
+using the `get_key` function, which returns the number of the next key pressed.
 
-TODO: Write development instructions here
+Sprites can be declared using a quasi-visual syntax:
+```
+sprite dum [
+`  x  x  `
+`  x  x  `
+`  x  x  `
+`        `
+`x      x`
+` xxxxxx `
+]
+```
+These sprites can then be used in calls to `draw_sprite(sprite, x, y)`.
 
 ## Contributing
 
-1. Fork it (<https://github.com/your-github-user/chalk/fork>)
+1. Fork it (<https://github.com/DanilaFe/chalk/fork>)
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
@@ -24,4 +66,4 @@ TODO: Write development instructions here
 
 ## Contributors
 
-- [your-github-user](https://github.com/your-github-user) Danila Fedorin - creator, maintainer
+- [DanilaFe](https://github.com/DanilaFe) Danila Fedorin - creator, maintainer

programs/basic_arithmetic.chalk

@@ -0,0 +1,7 @@
+fun main(): u0 {
+    1+2+3;
+    var a = 5+5;
+    var b = a;
+    var a = a + b;
+    var c = a - b;
+}

programs/basic_call.chalk

@@ -0,0 +1,21 @@
+fun double(a): u8 {
+    return a + a;
+}
+
+fun quadruple(a): u8 {
+    return double(double(a));
+}
+
+fun reuse(): u0 {
+    var one = 2;
+    var two = 4;
+    var three = 6;
+}
+
+fun main(): u0 {
+    var a = quadruple(4);
+    var one = 1;
+    var two = 2;
+    var three = 3;
+    reuse();
+}

programs/basic_draw_number.chalk

@@ -0,0 +1,3 @@
+fun main(): u0 {
+    draw_number(69, 1, 1);
+}

programs/basic_empty.chalk

@@ -0,0 +1,3 @@
+fun main(): u0 {
+
+}

programs/basic_if.chalk

@@ -0,0 +1,17 @@
+fun main(): u0 {
+    var a = 3+3;
+    if(a) {
+        a = 0;
+    }
+
+    var b = 0;
+    if(b) {
+        b = 4;
+    }
+
+    if(b) {
+        b = 4;
+    } else {
+        b = 5;
+    }
+}

programs/basic_input.chalk

@@ -0,0 +1,4 @@
+fun main(): u0 {
+    var a = get_key();
+    var b = get_key();
+}

programs/basic_sprite.chalk

@@ -0,0 +1,12 @@
+sprite dum [
+`  x  x  `
+`  x  x  `
+`  x  x  `
+`        `
+`x      x`
+` xxxxxx `
+]
+
+fun main(): u0 {
+  draw_sprite(dum, 0, 0);
+}

programs/basic_while.chalk

@@ -0,0 +1,8 @@
+fun main(): u0 {
+    var a = 5;
+    var b = 0;
+    while(a) {
+        b = b + 2;
+        a = a - 1;
+    }
+}

programs/comb_fib.chalk

@@ -0,0 +1,14 @@
+fun main(): u0 {
+    var a = 1;
+    var b = 1;
+    while(233 - a) {
+        draw_number(a, 24, 13);
+        set_delay(30);
+        var temp = a;
+        a = b;
+        b = b + temp;
+        while(get_delay()){}
+        draw_number(temp, 24, 13);
+    }
+    draw_number(a, 24, 13);
+}

programs/comb_input.chalk

@@ -0,0 +1,13 @@
+fun main(): u0 {
+    var a = 1;
+    var b = 0;
+    var previous = 0;
+    draw_number(0, 24, 13);
+
+    while(a) {
+        previous = b;
+        b = get_key();
+        draw_number(previous, 24, 13);
+        draw_number(b, 24, 13);
+    }
+}

programs/comb_sprite.chalk

@@ -0,0 +1,39 @@
+sprite dum [
+`  x  x  `
+`  x  x  `
+`  x  x  `
+`        `
+`x      x`
+` xxxxxx `
+]
+
+fun main(): u8 {
+  var x = 0;
+  var y = 5;
+  var vy = 0;
+  var ay = 1;
+  var mode = 0;
+  while(1) {
+    draw_sprite(dum, x, y);
+    set_delay(1);
+    while(get_delay()){}
+    draw_sprite(dum, x, y);
+    if(5 - y) {
+
+    } else {
+        mode = 0;
+    }
+    if(26 - y) {
+
+    } else {
+        mode = 1;
+    }
+    if(mode) {
+        vy = vy - ay;
+        y = y - vy;
+    } else {
+        y = y + vy;
+        vy = vy + ay;
+    }
+  }
+}

programs/comb_sprite_2.chalk

@@ -0,0 +1,34 @@
+sprite dum [
+`  x  x  `
+`  x  x  `
+`  x  x  `
+`        `
+`x      x`
+` xxxxxx `
+]
+
+fun main(): u8 {
+  var x = 0;
+  var y = 27;
+  var vx = 1;
+  var vy = 0;
+  var a = 1;
+  while(1) {
+    var draw_y = 32 - y;
+    draw_sprite(dum, x, draw_y);
+    set_delay(1);
+    while(get_delay()){}
+
+    vy = vy - a;
+    y = y + vy;
+    x = x + vx;
+    if(6-y) {
+
+    } else {
+      var vtemp = vy;
+      vy = 0 - vtemp;
+      vy = vy + 1;
+    }
+    clear();
+  }
+}

src/chalk.cr

@@ -2,9 +2,9 @@ require "./chalk/*"
 require "option_parser"
 
 module Chalk
-  config = Config.parse!
+  config = Ui::Config.parse!
   exit unless config.validate!
 
-  compiler = Compiler.new config
+  compiler = Compiler::Compiler.new config
   compiler.run
 end

src/chalk/builder.cr

@@ -1,38 +0,0 @@
-require "./lexer.cr"
-require "./parsers.cr"
-
-module Chalk
-  module Builder
-    def type(type) : BasicParser(Token)
-      return TypeParser.new(type).as(BasicParser(Token))
-    end
-
-    def char(type) : BasicParser(Token)
-      return CharParser.new(type).as(BasicParser(Token))
-    end
-
-    def transform(parser : BasicParser(T), &transform : T -> R) forall T, R
-      return TransformParser.new(parser, &transform).as(BasicParser(R))
-    end
-
-    def optional(parser : BasicParser(T)) : BasicParser(T?) forall T
-      return OptionalParser.new(parser).as(BasicParser(T?))
-    end
-
-    def either(*args : BasicParser(T)) : BasicParser(T) forall T
-      return EitherParser.new(args.to_a).as(BasicParser(T))
-    end
-
-    def many(parser : BasicParser(T)) : BasicParser(Array(T)) forall T
-      return ManyParser.new(parser).as(BasicParser(Array(T)))
-    end
-
-    def delimited(parser : BasicParser(T), delimiter : BasicParser(R)) : BasicParser(Array(T)) forall T, R
-      return DelimitedParser.new(parser, delimiter).as(BasicParser(Array(T)))
-    end
-
-    def then(first : BasicParser(T), second : BasicParser(R)) forall T, R
-      return NextParser.new(first, second).as(BasicParser(Array(T | R)))
-    end
-  end
-end

src/chalk/builtin.cr

@@ -0,0 +1,35 @@
+module Chalk
+  module Builtin
+    # A normal function (i.e., a "call" is generated for it)
+    # that is provided by chalk's standard library, and therefore
+    # has predefined output.
+    abstract class BuiltinFunction
+      # Creates a new function with *param_count* parameters.
+      def initialize()
+      end
+
+      # Uses the given `Compiler::Emitter` to output code.
+      abstract def generate!(codegen)
+      # Gets the `Compiler::FunctionType` of this function.
+      abstract def type
+    end
+
+    # A function to which a call is not generated. This function
+    # is copied everywhere a call to it occurs. Besides this, the
+    # function also accepts trees rather than register numbers,
+    # and therefore can accept and manipulate trees.
+    abstract class InlineFunction
+      # Creates a new function with *param_count* parameters.
+      def initialize()
+      end
+
+      # Generates code like `Compiler::CodeGenerator` would.
+      # The *codegen* parameter is used to emit instructions,
+      # the *params* are trees that are being passed as arguments.
+      # See `Compiler::CodeGenerator#generate!` for what the other parameters mean.
+      abstract def generate!(codegen, params, table, target, free)
+      # Gets the `Compiler::FunctionType` of this function.
+      abstract def type
+    end
+  end
+end

src/chalk/codegen.cr

@@ -1,160 +1,148 @@
 require "./ir.cr"
+require "./emitter.cr"
 
 module Chalk
-  class CodeGenerator
+  module Compiler
-    def initialize(table, @function : TreeFunction)
+    # A class that converts a tree into the corresponding
-      @register = 0
+    # intermediate representation, without optimizing.
-      @instructions = [] of Instruction
+    class CodeGenerator
-      @table = Table.new table
+      include Emitter
 
-      @function.params.each do |param|
+      # Gets the instructions currently emitted by this code generator.
-        @table[param] = VarEntry.new @register
+      getter instructions
-        @register += 1
-      end
-    end
 
-    private def load(into, value)
+      # Creates a new compiler with the given symbol *table*
-      inst = LoadInstruction.new into, value.to_i32
+      # and *function* for which code should be generated.
-      @instructions << inst
+      def initialize(table, @function : Trees::TreeFunction)
-      return inst
+        @registers = 0
-    end
+        @instructions = [] of Ir::Instruction
+        @table = Table.new table
 
-    private def loadr(into, from)
+        @function.params.each do |param|
-      inst = LoadRegInstruction.new into, from
+          @table.set_var param, VarEntry.new @registers
-      @instructions << inst
+          @registers += 1
-      return inst
-    end
-
-    private def op(op, into, from)
-      inst = OpRegInstruction.new op, into, from
-      @instructions << inst
-      return inst
-    end
-
-    private def jeq(rel, l, r)
-      inst = JumpEqRegInstruction.new rel, l, r
-      @instructions << inst
-      return inst
-    end
-
-    private def store(up_to)
-      inst = StoreInstruction.new up_to
-      @instructions << inst
-      return inst
-    end
-
-    private def restore(up_to)
-      inst = RestoreInstruction.new up_to
-      @instructions << inst
-      return inst
-    end
-
-    private def ret(reg)
-      inst =  ReturnInstruction.new reg
-      @instructions << inst
-      return inst
-    end
-
-    def generate!(tree, target)
-      case tree
-      when TreeId
-        entry = @table[tree.id]?
-        raise "Unknown variable" unless entry &&
-                                        entry.is_a?(VarEntry)
-        loadr target, entry.register
-      when TreeLit
-        load target, tree.lit
-      when TreeOp
-        into = @register
-        @register += 1
-        generate! tree.left, target
-        generate! tree.right, into
-        @register -= 1
-        op tree.op, target, into
-      when TreeBlock
-        register = @register
-        tree.children.each do |child|
-          generate! child, @register
-        end
-        @register = register
-      when TreeVar
-        entry = @table[tree.name]?
-        if entry == nil
-          entry = VarEntry.new @register
-          @register += 1
-          @table[tree.name] = entry
-        end
-        raise "Unknown variable" unless entry.is_a?(VarEntry)
-        generate! tree.expr, entry.register
-      when TreeAssign
-        entry = @table[tree.name]?
-        raise "Unknown variable" unless entry &&
-                                        entry.is_a?(VarEntry)
-        generate! tree.expr, entry.register
-      when TreeIf
-        cond_target = @register
-        @register += 1
-
-        generate! tree.condition, cond_target
-        load cond_target + 1, 0
-        jump_inst = jeq 0, cond_target, cond_target + 1
-        @register -= 1
-
-        old_size = @instructions.size
-        generate! tree.block, @register
-        jump_inst.offset = @instructions.size - old_size + 1
-
-        generate! tree.otherwise, @register if tree.otherwise
-      when TreeReturn
-        into = @register
-        @register += 1
-        generate! tree.rvalue, into
-        @register -= 1
-        ret into
-      end
-    end
-
-    private def check_dead(inst)
-      if inst.is_a?(LoadRegInstruction)
-        return inst.from == inst.into
-      end
-      return false
-    end
-
-    private def optimize!(range)
-      offset = 0
-      range.each do |index|
-        if check_dead(@instructions[index + offset])
-          @instructions.delete_at(index + offset)
-          offset -= 1
         end
       end
-      return offset
-    end
 
-    private def optimize!
+      # Generates code for an inline function, with the given *tree* being the `Trees::TreeCall`
-      block_boundaries = [ @instructions.size ]
+      # that caused the function call. The other parameters are as described in the more general
-      @instructions.each_with_index do |inst, i|
+      # `#generate!` call.
-        if inst.is_a?(JumpEqRegInstruction) ||
+      def generate!(tree, function : Builtin::InlineFunction, table, target, free)
-           inst.is_a?(JumpEqInstruction)
+        function.generate!(self, tree.params, table, target, free)
-            block_boundaries << (inst.offset + i)
+      end
+
+      # Generates code for a tree or a builtin function (that is, a call is actually necessary).
+      # I is set to the current stack pointer, the registers are stored, and the call is made.
+      # The registers are then restored. The other parameters are as described in the more general
+      # `#generate!` call.
+      def generate!(tree, function : Trees::TreeFunction | Builtin::BuiltinFunction, table, target, free)
+        start_at = free
+        to_stack
+        # Store variables
+        store (start_at - 1) unless start_at == 0
+        # Increment I and stack position
+        load free, start_at
+        opr TokenType::OpAdd, STACK_REG, free
+        addi free
+
+        # Calculate the parameters
+        tree.params.each do |param|
+          generate! param, table, free, free + 1
+          free += 1
         end
-      end
+        # Call the function
-      block_boundaries.sort!
+        tree.params.size.times do |time|
+          loadr time, time + start_at
+        end
+        call tree.name
 
-      previous = 0
+        # Reduce stack pointer
-      offset = 0
+        load free, start_at
-      block_boundaries.each do |boundary|
+        opr TokenType::OpSub, STACK_REG, free
-        range = (previous + offset)...(boundary + offset)
+        to_stack
-        offset += optimize!(range)
+        # Restore
-        previous = boundary
+        restore (start_at - 1) unless start_at == 0
+        # Get call value into target
+        loadr target, RETURN_REG
       end
-    end
 
-    def generate!
+      # Generates code for a *tree*, using a symbol *table*
-      generate!(@function.block, @register)
+      # housing all the names for identifiers in the code.
-      optimize!
+      # The result is stored into the *target* register,
-      return @instructions
+      # and the *free* register is the next register into
+      # which a value can be stored for "scratch work".
+      def generate!(tree, table, target, free)
+        case tree
+        when Trees::TreeId
+          entry = table.get_var? tree.id
+          raise "Unknown variable" unless entry
+          loadr target, entry.register
+        when Trees::TreeLit
+          load target, tree.lit
+        when Trees::TreeOp
+          generate! tree.left, table, target, free
+          generate! tree.right, table, free, free + 1
+          opr tree.op, target, free
+        when Trees::TreeCall
+          entry = table.get_function?(tree.name).not_nil!
+          raise "Unknown function" unless entry.is_a?(FunctionEntry)
+          generate! tree, entry.function, table, target, free
+        when Trees::TreeBlock
+          table = Table.new(table)
+          tree.children.each do |child|
+            free += generate! child, table, THROWAWAY_REG, free
+          end
+        when Trees::TreeVar
+          entry = table.get_var? tree.name
+          if entry == nil
+            entry = VarEntry.new free
+            free += 1
+            table.set_var tree.name, entry
+          end
+          generate! tree.expr, table, entry.as(VarEntry).register, free
+          return 1
+        when Trees::TreeAssign
+          entry = table.get_var? tree.name
+          raise "Unknown variable" unless entry
+          generate! tree.expr, table, entry.register, free
+        when Trees::TreeIf
+          generate! tree.condition, table, free, free + 1
+          sne free, 0
+          jump_inst = jr 0
+
+          old_size = @instructions.size
+          generate! tree.block, table, free, free + 1
+          jump_after = jr 0
+          jump_inst.offset = @instructions.size - old_size + 1
+
+          old_size = @instructions.size
+          generate! tree.otherwise, table, free, free + 1 if tree.otherwise
+          jump_after.offset = @instructions.size - old_size + 1
+        when Trees::TreeWhile
+          before_cond = @instructions.size
+          generate! tree.condition, table, free, free + 1
+          sne free, 0
+          cond_jump = jr 0
+
+          old_size = @instructions.size
+          generate! tree.block, table, free, free + 1
+          after_jump = jr 0
+
+          cond_jump.offset = @instructions.size - old_size + 1
+          after_jump.offset = before_cond - instructions.size + 1
+        when Trees::TreeReturn
+          generate! tree.rvalue, table, free, free + 1
+          loadr RETURN_REG, free
+          ret
+        end
+        return 0
+      end
+
+      # Generates code for the function that was given to it.
+      def generate!
+        generate!(@function.block, @table, 0, @registers)
+        return @instructions
+      end
     end
   end
 end

src/chalk/compiler.cr

@@ -3,84 +3,228 @@ require "./constant_folder.cr"
 require "./table.cr"
 
 module Chalk
-  class Compiler
+  module Compiler
-    def initialize(@config : Config)
+    # Top-level class to tie together the various
-      @logger = Logger.new STDOUT
+    # components, such as the `Lexer`,
-      @lexer = Lexer.new
+    # `ParserCombinators::Parser`, and `Optimizer`
-      @parser = Parser.new
+    class Compiler
-      @logger.debug("Initialized compiler")
+      # Creates a new compiler with the given *config*.
-      @logger.level = Logger::DEBUG
+      def initialize(@config : Ui::Config)
-    end
+        @logger = Logger.new STDOUT
-
+        @logger.debug("Initialized compiler")
-    private def create_trees(file)
+        @logger.level = @config.loglevel
-      string = File.read(file)
-      tokens = @lexer.lex string
-      if tokens.size == 0 && string != ""
-        raise "Unable to tokenize file."
       end
-      @logger.debug("Finished tokenizing")
-      if trees = @parser.parse?(tokens)
-        @logger.debug("Finished parsing")
-        return trees
-      end
-      raise "Unable to parse file."
-    end
 
-    private def process_initial(trees)
+      # Reads a file an extracts instances of
-      table = Table.new
+      # `Trees:TreeFunction`.
-      folder = ConstantFolder.new
+      private def create_trees(file)
-      trees.each do |tree|
+        string = File.read(file)
-        tree = tree.as(TreeFunction)
+        @logger.debug("Tokenizing")
-        @logger.debug("Constant folding #{tree.name}")
+        lexer = Lexer.new
-        tree = tree.apply(folder).as(TreeFunction)
+        tokens = lexer.lex string
-        @logger.debug("Storing #{tree.name} in symbol table")
+        if tokens.size == 0 && string != ""
-        table[tree.name] = FunctionEntry.new tree
+          raise "Unable to tokenize file."
+        end
+        @logger.debug("Finished tokenizing")
+        @logger.debug("Beginning parsing")
+        parser = ParserCombinators::Parser.new
+        if trees = parser.parse?(tokens)
+          @logger.debug("Finished parsing")
+          @logger.debug("Beginning constant folding")
+          folder = Trees::ConstantFolder.new
+          trees.map! do |tree|
+            next tree unless tree.is_a?(Trees::TreeFunction)
+            @logger.debug("Constant folding #{tree.name}")
+            tree.apply(folder)
+          end
+          @logger.debug("Done constant folding")
+          return trees
+        end
+        raise "Unable to parse file."
       end
-      return table
-    end
 
-    private def generate_code(trees, table)
+      # Creates a default symbol table using the default functions,
-      code = {} of String => Array(Instruction)
+      # as well as the functions declared by *trees*
-      trees.each do |tree|
+      private def create_table(trees)
-        tree = tree.as(TreeFunction)
+        table = Table.new
+        @logger.debug("Creating symbol table")
+        trees.each do |tree|
+          case tree
+          when Trees::TreeSprite
+              @logger.debug("Storing sprite #{tree.name} in symbol table")
+              table.set_sprite tree.name, SpriteEntry.new tree.sprite
+          when Trees::TreeFunction
+              @logger.debug("Storing function #{tree.name} in symbol table")
+              table.set_function tree.name, FunctionEntry.new tree
+          else
+              @logger.debug("Unexpected tree type in input.")
+          end
+        end
+        @logger.debug("Done creating symbol table")
+
+        table.set_function "get_key", FunctionEntry.new Builtin::InlineAwaitKeyFunction.new
+        table.set_function "set_delay", FunctionEntry.new Builtin::InlineSetDelayFunction.new
+        table.set_function "get_delay", FunctionEntry.new Builtin::InlineGetDelayFunction.new
+        table.set_function "set_sound", FunctionEntry.new Builtin::InlineSetSoundFunction.new
+        table.set_function "draw_number", FunctionEntry.new Builtin::InlineDrawNumberFunction.new
+        table.set_function "draw_sprite", FunctionEntry.new Builtin::InlineDrawSpriteFunction.new
+        table.set_function "clear", FunctionEntry.new Builtin::InlineClearFunction.new
+        return table
+      end
+
+      # Generates and optimizes intermediate representation for the given *tree*,
+      # looking up identifiers in the symbol *table*, and appending the given *instruction*
+      # at the end of the function to ensure correct program flow.
+      private def create_code(tree : Trees::TreeFunction, table, instruction = Ir::ReturnInstruction.new)
+        tree.reduce(Trees::TypeChecker.new table, tree.type.return_type)
+        optimizer = Optimizer.new
         generator = CodeGenerator.new table, tree
         @logger.debug("Generating code for #{tree.name}")
-        instructions = generator.generate!
+        code = generator.generate!
-        code[tree.name] = instructions
+        code << instruction
+        return code # optimizer.optimize(code)
       end
-      return code
-    end
 
-    private def run_tree
+      # Generate code for a builtin function. Neither the *table* nor the *instruction*
-      trees = create_trees(@config.file)
+      # are used, and serve to allow function overloading.
-      trees.each do |it|
+      private def create_code(function : Builtin::BuiltinFunction, table, instruction = nil)
-        STDOUT << it
+        instructions = [] of Ir::Instruction
+        function.generate!(instructions)
+        return instructions
       end
-    end
 
-    private def run_intermediate
+      # Creates a hash containing function names and their generated code.
-      trees = create_trees(@config.file)
+      # Only functions parsed from the file are compiled, and the *table*
-      table = process_initial(trees)
+      # is used for looking up identifiers.
-      raise "No main function!" unless table["main"]?
+      private def create_code(trees : Array(Trees::TreeFunction), table)
-      code = generate_code(trees, table)
+        code = {} of String => Array(Ir::Instruction)
-      code.each do |name, insts|
+        trees.each do |tree|
-        puts "Code for #{name}:"
+          code[tree.name] = create_code(tree, table)
-        insts.each { |it| puts it }
+        end
-        puts "-----"
+        return code
       end
-    end
 
-    private def run_binary
+      private def create_code(trees : Array(Trees::Tree), table)
-    end
+        functions = trees.select &.is_a?(Trees::TreeFunction)
+        return create_code(functions.map &.as(Trees::TreeFunction), table)
+      end
 
-    def run
+      # Runs in the tree `Ui::OutputMode`. The file is
-      case @config.mode
+      # tokenized and parsed, and the result is printed
-      when OutputMode::Tree
+      # to the standard output.
-        run_tree
+      private def run_tree
-      when OutputMode::Intermediate
+        trees = create_trees(@config.file)
-        run_intermediate
+        trees.each do |it|
-      when OutputMode::Binary
+          STDOUT << it
-        run_binary
+        end
+      end
+
+      # Runs in the intermediate `Ui::OutputMode`. The file
+      # is tokenized and parsed, and for each function,
+      # intermediate representation is generated. However,
+      # an executable is not generated, and the IR
+      # is printed to the screen.
+      private def run_intermediate
+        trees = create_trees(@config.file)
+        table = create_table(trees)
+        code = create_code(trees, table)
+        code.each do |name, insts|
+          puts "Code for #{name}:"
+          insts.each { |it| puts it }
+          puts "-----"
+        end
+      end
+
+      # Creates binary from the given *instructions*,
+      # using the symbol *table* for lookups, and writes
+      # the output to *dest*
+      private def generate_binary(table, instructions, dest)
+        binary = instructions.map_with_index { |it, i| it.to_bin(table, instructions.size, i).to_u16 }
+        binary.each do |inst|
+          first = (inst >> 8).to_u8
+          dest << first
+          second = (inst & 0xff).to_u8
+          dest << second
+        end
+      end
+
+      # Find all calls performed by the functions
+      # stored in the *table*, starting at the main function.
+      private def collect_calls(table)
+        open = Set(String).new
+        done = Set(String).new
+
+        open << "main"
+        while !open.empty?
+          first = open.first
+          open.delete first
+
+          entry = table.get_function? first
+          raise "Unknown function" unless entry
+          function = entry.function
+          next if function.is_a?(Builtin::InlineFunction)
+          done << first
+          next unless function.is_a?(Trees::TreeFunction)
+
+          visitor = Trees::CallVisitor.new
+          function.accept(visitor)
+          open.concat(visitor.calls - done)
+        end
+        return done
+      end
+
+      # Runs in the binary `Ui::OutputMode`. The file is
+      # converted into an executable.
+      private def run_binary
+        all_instructions = [] of Ir::Instruction
+        trees = create_trees(@config.file)
+        table = create_table(trees)
+        names = collect_calls(table)
+        names.delete "main"
+
+        main_entry = table.get_function?("main").not_nil!
+        all_instructions.concat create_code(main_entry.function.as(Trees::TreeFunction),
+          table, Ir::JumpRelativeInstruction.new 0)
+        main_entry.addr = 0
+
+        names.each do |name|
+          entry = table.get_function?(name).not_nil!
+          entry.addr = all_instructions.size
+          function = entry.function
+          raise "Trying to compile inlined function" if function.is_a?(Builtin::InlineFunction)
+          all_instructions.concat create_code(function, table)
+          all_instructions << Ir::ReturnInstruction.new
+        end
+
+        sprite_bytes = [] of UInt8
+        offset = 0
+        table.sprites.each do |k, v|
+          data = v.sprite.encode
+          v.addr = offset + all_instructions.size * 2
+          offset += data.size
+          sprite_bytes.concat data
+        end
+
+        binary = [] of UInt8
+        file = File.open(@config.output, "w")
+        generate_binary(table, all_instructions, binary)
+        binary.concat sprite_bytes
+        binary.each do |byte|
+          file.write_byte byte
+        end
+        file.close
+      end
+
+      # Runs the compiler.
+      def run
+        case @config.mode
+        when Ui::OutputMode::Tree
+          run_tree
+        when Ui::OutputMode::Intermediate
+          run_intermediate
+        when Ui::OutputMode::Binary
+          run_binary
+        end
       end
     end
   end

src/chalk/config.cr

@@ -0,0 +1,95 @@
+module Chalk
+  module Ui
+    # The mode in which the compiler operates.
+    # Defines what actions are and aren't performed.
+    enum OutputMode
+      # The text is only parsed, and the result is printed to the screen.
+      Tree,
+      # The text is parsed and converted to intermediate representation.
+      # The intermediate representation is then printed to the screen.
+      Intermediate,
+      # The text is converted into a full CHIP-8 executable.
+      Binary
+    end
+
+    # A configuration class created from the command-line parameters.
+    class Config
+      # Gets the file to be compiled.
+      getter file : String
+      # Sets the file to be compiled.
+      setter file : String
+      # Gets the mode in which the compiler should operate.
+      getter mode : OutputMode
+      # Sets the mode in which the compiler should operate.
+      setter mode : OutputMode
+      # Gets the log level.
+      getter loglevel : Logger::Severity
+      # Sets the log level.
+      setter loglevel : Logger::Severity
+      # Gets the output file destination.
+      getter output : String
+      # Sets the output file destination.
+      setter output : String
+
+      # Creates a new configuration.
+      def initialize(@file = "",
+                     @mode = OutputMode::Tree,
+                     @loglevel = Logger::Severity::DEBUG,
+                     @output : String = "out.ch8")
+      end
+
+      # Reads a configuration from the command line options.
+      def self.parse!
+        config = self.new
+        OptionParser.parse! do |parser|
+          parser.banner = "Usage: chalk [arguments]"
+          parser.on("-m", "--mode=MODE", "Set the mode of the compiler.") do |mode|
+            hash = { 
+                "tree" => OutputMode::Tree,
+                "t" => OutputMode::Tree,
+                "intermediate" => OutputMode::Intermediate,
+                "i" => OutputMode::Intermediate,
+                "binary" => OutputMode::Binary,
+                "b" => OutputMode::Binary
+            }
+            puts "Invalid mode type. Using default." if !hash.has_key?(mode)
+            config.mode = hash[mode]? || OutputMode::Tree
+          end
+          parser.on("-f", "--file=FILE", "Set the input file to compile.") do |file|
+            config.file = file
+          end
+          parser.on("-o", "--output=OUT", "Sets the output file.") do |out|
+            config.output = out
+          end
+          parser.on("-l", "--log=LOG", "Set the log level of the compiler.") do |log|
+            hash = {
+                "debug" => Logger::Severity::DEBUG,
+                "fatal" => Logger::Severity::FATAL,
+                "error" => Logger::Severity::ERROR,
+                "info" => Logger::Severity::INFO,
+                "unknown" => Logger::Severity::UNKNOWN,
+                "warn" => Logger::Severity::WARN
+            }
+            puts "Invalid log level. Using default." if !hash.has_key?(log)
+            config.loglevel = hash[log]? || Logger::Severity::DEBUG
+          end
+          parser.on("-h", "--help", "Show this message.") { puts parser }
+        end
+        return config
+      end
+
+      # Validates the options provided, returning true if
+      # they are valid and false otherwise.
+      def validate!
+        if file == ""
+          puts "No source file specified."
+          return false
+        elsif !File.exists? file
+          puts "Unable to open source file."
+          return false
+        end
+        return true
+      end
+    end
+  end
+end

src/chalk/constant_folder.cr

@@ -1,33 +1,37 @@
 require "./tree.cr"
 
 module Chalk
-  class ConstantFolder < Transformer
+  module Trees
-    private def perform_op(op, left, right)
+    # `Trees::Transformer` that turns operations on
-      case op
+    # Constants into constants.
-      when TokenType::OpAdd
+    class ConstantFolder < Transformer
-        left + right
+      private def perform_op(op, left, right)
-      when TokenType::OpSub
+        case op
-        left - right
+        when Compiler::TokenType::OpAdd
-      when TokenType::OpMul
+          left + right
-        left*right
+        when Compiler::TokenType::OpSub
-      when TokenType::OpDiv
+          left - right
-        left/right
+        when Compiler::TokenType::OpMul
-      when TokenType::OpAnd
+          left*right
-        left & right
+        when Compiler::TokenType::OpDiv
-      when TokenType::OpOr
+          left/right
-        left | right
+        when Compiler::TokenType::OpAnd
-      else TokenType::OpXor
+          left & right
-      left ^ right
+        when Compiler::TokenType::OpOr
+          left | right
+        else Compiler::TokenType::OpXor
+        left ^ right
+        end
       end
-    end
 
-    def transform(tree : TreeOp)
+      def transform(tree : Trees::TreeOp)
-      if tree.left.is_a?(TreeLit) && tree.right.is_a?(TreeLit)
+        if tree.left.is_a?(Trees::TreeLit) && tree.right.is_a?(Trees::TreeLit)
-        return TreeLit.new perform_op(tree.op,
+          return Trees::TreeLit.new perform_op(tree.op,
-          tree.left.as(TreeLit).lit,
+            tree.left.as(Trees::TreeLit).lit,
-          tree.right.as(TreeLit).lit)
+            tree.right.as(Trees::TreeLit).lit)
+        end
+        return tree
       end
-      return tree
     end
   end
 end

src/chalk/emitter.cr

@@ -0,0 +1,124 @@
+module Chalk
+  module Compiler
+    # The register into which the return value of a function is stored.
+    RETURN_REG = 14
+    # The register into which the "stack pointer" is stored.
+    STACK_REG  = 13
+    # Register used for throwing away values.
+    THROWAWAY_REG = 12
+
+    # Module to emit instructions and store
+    # them into an existing array.
+    module Emitter
+      # Moves I to the next available value on the stack.
+      def to_stack
+        setis
+        addi STACK_REG
+      end
+
+      # Emits an instruction to load a *value* into a register, *into*.
+      def load(into, value)
+        inst = Ir::LoadInstruction.new into, value.to_i32
+        @instructions << inst
+        return inst
+      end
+
+      # Emits an instruction to load a register, *from*, into
+      # another register, *into*
+      def loadr(into, from)
+        inst = Ir::LoadRegInstruction.new into, from
+        @instructions << inst
+        return inst
+      end
+
+      # Emits an instruction that's converted
+      # to an operation, *op* that mutates the register, *into*,
+      # with the right hand operand *from*
+      def op(op, into, from)
+        inst = Ir::OpInstruction.new op, into, from
+        @instructions << inst
+        return inst
+      end
+
+      # Emits an instruction that's converted
+      # to an operation, *op*, that mutates the register, *into*,
+      # with the right hand operand (a register), *from*
+      def opr(op, into, from)
+        inst = Ir::OpRegInstruction.new op, into, from
+        @instructions << inst
+        return inst
+      end
+
+      # Emits a "skip next instruction if not equal"
+      # instruction. The left hand side is a register,
+      # an the right hand side is a value.
+      def sne(l, r)
+        inst = Ir::SkipNeInstruction.new l, r
+        @instructions << inst
+        return inst
+      end
+
+      # Emits an instruction to jump relative to
+      # where the instruction is.
+      # ```
+      # jr 0 # Infinite loop
+      # jr -1 # Run previous instruction
+      # jr 1 # pretty much a no-op.
+      # ```
+      def jr(o)
+        inst = Ir::JumpRelativeInstruction.new o
+        @instructions << inst
+        return inst
+      end
+
+      # Emits instruction that stores register 0 through *up_to* into
+      # memory at address I.
+      def store(up_to)
+        inst = Ir::StoreInstruction.new up_to
+        @instructions << inst
+        return inst
+      end
+
+      # Emits instruction that loads values from address I into
+      # register 0 through *up_t*
+      def restore(up_to)
+        inst = Ir::RestoreInstruction.new up_to
+        @instructions << inst
+        return inst
+      end
+
+      # Emits a return instruction.
+      def ret
+        inst = Ir::ReturnInstruction.new
+        @instructions << inst
+        return inst
+      end
+
+      # Emits an instruction to call
+      # the given function name.
+      def call(func)
+        inst = Ir::CallInstruction.new func
+        @instructions << inst
+        return inst
+      end
+
+      # Emits instruction to set I
+      # to the baste stack location. The stack
+      # pointer will need to be added to I
+      # to get the next available stack slot.
+      def setis
+        inst = Ir::SetIStackInstruction.new
+        @instructions << inst
+        return inst
+      end
+
+      # Emits instruction to add the value of a
+      # register to I
+      def addi(reg)
+        inst = Ir::AddIRegInstruction.new reg
+        @instructions << inst
+        return inst
+      end
+    end
+  end
+end

src/chalk/function_finder.cr

@@ -0,0 +1,16 @@
+module Chalk
+  module Trees
+    # Visitor that finds all function calls in a function.
+    class CallVisitor < Visitor
+      property calls : Set(String)
+
+      def initialize
+        @calls = Set(String).new
+      end
+
+      def visit(t : TreeCall)
+        @calls << t.name
+      end
+    end
+  end
+end

src/chalk/inline.cr

@@ -0,0 +1,111 @@
+require "./builtin"
+require "./type"
+
+module Chalk
+  module Builtin
+    # Inline function to await for a key and return it.
+    class InlineAwaitKeyFunction < InlineFunction
+      def generate!(emitter, params, table, target, free)
+        emitter.instructions << Ir::AwaitKeyInstruction.new target
+      end
+      def type
+          return Compiler::FunctionType.new(([] of Compiler::Type), Compiler::Type::U8)
+      end
+    end
+
+    # Inline function to set the delay timer.
+    class InlineSetDelayFunction < InlineFunction
+      def generate!(emitter, params, table, target, free)
+        emitter.generate! params[0], table, free, free + 1
+        emitter.instructions << Ir::SetDelayTimerInstruction.new free
+      end
+
+      def type
+          return Compiler::FunctionType.new([Compiler::Type::U8], Compiler::Type::U0)
+      end
+    end
+
+    # Inline function to get the delay timer.
+    class InlineGetDelayFunction < InlineFunction
+      def generate!(emitter, params, table, target, free)
+        emitter.instructions << Ir::GetDelayTimerInstruction.new target
+      end
+      def type
+          return Compiler::FunctionType.new(([] of Compiler::Type), Compiler::Type::U8)
+      end
+    end
+
+    # Function to set the sound timer.
+    class InlineSetSoundFunction < InlineFunction
+      def generate!(emitter, params, table, target, free)
+        emitter.generate! params[0], table, free, free + 1
+        emitter.instructions << Ir::SetSoundTimerInstruction.new free
+      end
+
+      def type
+          return Compiler::FunctionType.new([Compiler::Type::U8], Compiler::Type::U0)
+      end
+    end
+
+    # Function to draw numbers.
+    class InlineDrawNumberFunction < InlineFunction
+      def generate!(emitter, params, table, target, free)
+        emitter.to_stack
+        # Save variables from R0-R2
+        emitter.store 0x2
+        emitter.load free, 0x3
+        emitter.addi free
+        # Write BCD values to I
+        emitter.generate! params[0], table, free, free + 1
+        emitter.instructions << Ir::BCDInstruction.new free
+        emitter.restore 0x2
+        # Get the coordinates
+        free = 3 if free < 3
+        emitter.generate! params[1], table, free, free + 1
+        emitter.generate! params[2], table, free + 1, free + 2
+        # Draw
+        emitter.instructions << Ir::GetFontInstruction.new 0x0
+        emitter.instructions << Ir::DrawInstruction.new free, free + 1, 5
+        emitter.op(Compiler::TokenType::OpAdd, free, 6)
+        emitter.instructions << Ir::GetFontInstruction.new 0x1
+        emitter.instructions << Ir::DrawInstruction.new free, free + 1, 5
+        emitter.op(Compiler::TokenType::OpAdd, free, 6)
+        emitter.instructions << Ir::GetFontInstruction.new 0x2
+        emitter.instructions << Ir::DrawInstruction.new free, free + 1, 5
+        # Load variables from RO-R2 back
+        emitter.to_stack
+        emitter.restore 0x2
+      end
+
+      def type
+          return Compiler::FunctionType.new([Compiler::Type::U8] * 3, Compiler::Type::U0)
+      end
+    end
+
+    class InlineDrawSpriteFunction < InlineFunction
+      def generate!(emitter, params, table, target, free)
+        raise "First parameter should be a sprite name." if !params[0].is_a?(Trees::TreeId)
+        sprite_name = params[0].as(Trees::TreeId).id
+        sprite = table.get_sprite?(sprite_name).not_nil!.sprite
+        emitter.generate! params[1], table, free, free + 1
+        emitter.generate! params[2], table, free + 1, free + 2
+        emitter.instructions << Ir::SetISpriteInstruction.new params[0].as(Trees::TreeId).id
+        emitter.instructions << Ir::DrawInstruction.new free, free + 1, sprite.height.to_i32
+      end
+
+      def type
+          return Compiler::FunctionType.new([Compiler::Type::U8] * 3, Compiler::Type::U0)
+      end
+    end
+
+    class InlineClearFunction < InlineFunction
+      def generate!(emitter, params, table, target, free)
+        emitter.instructions << Ir::ClearInstruction.new
+      end
+
+      def type
+          return Compiler::FunctionType.new(([] of Compiler::Type), Compiler::Type::U0)
+      end
+    end
+  end
+end

src/chalk/ir.cr

@@ -1,134 +1,442 @@
 require "./lexer.cr"
 
 module Chalk
-  class Instruction
+  module Ir
-  end
+    # Base instruction class.
-
+    class Instruction
-  class LoadInstruction < Instruction
+      # Converts the instruction to binary, using
-    property register : Int32
+      # A table for symbol lookups, the stack position,
-    property value : Int32
+      # and the inex of the instruction.
-
+      def to_bin(table, stack, index)
-    def initialize(@register, @value)
+        return 0
+      end
     end
 
-    def to_s(io)
+    # Instruction to clear the screen
-      io << "load R"
+    class ClearInstruction < Instruction
-      @register.to_s(16, io)
+      def to_s(io)
-      io << " " << @value
+        io << "clear"
+      end
+
+      def to_bin(table, stack, index)
+        return 0x00e0
+      end
+    end
+
+    # Instruction to assign a random value to a register.
+    class RandomInstruction < Instruction
+      def initialize(@register : Int32, @value : Int32)
+      end
+
+      def to_s(io)
+        io << "rand R"
+        @register.to_s(16, io)
+        io << " " << @value
+      end
+
+      def to_bin(table, stack, index)
+        return 0xc000 | (@register << 8) | (@value)
+      end
+    end
+
+    # Instruction to load a value into a register.
+    class LoadInstruction < Instruction
+      def initialize(@register : Int32, @value : Int32)
+      end
+
+      def to_s(io)
+        io << "load R"
+        @register.to_s(16, io)
+        io << " " << @value
+      end
+
+      def to_bin(table, stack, index)
+        0x6000 | (@register << 8) | @value
+      end
+    end
+
+    # Instruction to load a register into another register.
+    class LoadRegInstruction < Instruction
+      # Gets the register being written to.
+      getter into
+      # Gets the register being used as right-hand operand.
+      getter from
+
+      def initialize(@into : Int32, @from : Int32)
+      end
+
+      def to_s(io)
+        io << "loadr R"
+        @into.to_s(16, io)
+        io << " R"
+        @from.to_s(16, io)
+      end
+
+      def to_bin(table, stack, index)
+        0x8000 | (@into << 8) | (@from << 4)
+      end
+    end
+
+    # Instruction to perform an operation on a register and a value,
+    # storing the output back into the register.
+    class OpInstruction < Instruction
+      def initialize(@op : Compiler::TokenType, @into : Int32, @value : Int32)
+      end
+
+      def to_s(io)
+        io << "op " << @op << " R"
+        @into.to_s(16, io)
+        io << " " << @value
+      end
+
+      def to_bin(table, stack, index)
+        case @op
+        when Compiler::TokenType::OpAdd
+          return 0x7000 | (@into << 8) | @value
+        else
+          raise "Invalid instruction"
+        end
+      end
+    end
+
+    # Instruction to perform an operation on a register and another register,
+    # storing the output back into left hand register.
+    class OpRegInstruction < Instruction
+      def initialize(@op : Compiler::TokenType, @into : Int32, @from : Int32)
+      end
+
+      def to_s(io)
+        io << "opr " << @op << " R"
+        @into.to_s(16, io)
+        io << " R"
+        @from.to_s(16, io)
+      end
+
+      def to_bin(table, stack, index)
+        code = 0
+        case @op
+        when Compiler::TokenType::OpAdd
+          code = 4
+        when Compiler::TokenType::OpSub
+          code = 5
+        when Compiler::TokenType::OpOr
+          code = 1
+        when Compiler::TokenType::OpAnd
+          code = 2
+        when Compiler::TokenType::OpXor
+          code = 3
+        else
+          raise "Invalid instruction"
+        end
+        return 0x8000 | (@into << 8) | (@from << 4) | code
+      end
+    end
+
+    # Instruction to write registers to memory at address I.
+    # The *up_to* parameter specifies the highest register
+    # that should be stored.
+    class StoreInstruction < Instruction
+      def initialize(@up_to : Int32)
+      end
+
+      def to_s(io)
+        io << "store R"
+        @up_to.to_s(16, io)
+      end
+
+      def to_bin(table, stack, index)
+        return 0xf055 | (@up_to << 8)
+      end
+    end
+
+    # Instruction to read registers from memory at address I.
+    # The *up_to* parameter specifies the highest register
+    # that should be read into.
+    class RestoreInstruction < Instruction
+      def initialize(@up_to : Int32)
+      end
+
+      def to_s(io)
+        io << "restore R"
+        @up_to.to_s(16, io)
+      end
+
+      def to_bin(table, stack, index)
+        return 0xf065 | (@up_to << 8)
+      end
+    end
+
+    # Instruction to return from a call.
+    class ReturnInstruction < Instruction
+      def initialize
+      end
+
+      def to_s(io)
+        io << "return"
+      end
+
+      def to_bin(table, stack, index)
+        return 0x00ee
+      end
+    end
+
+    # Instruction to jump relative to its own position.
+    class JumpRelativeInstruction < Instruction
+      # Gets the offset of this instruction.
+      getter offset
+      # Sets the offset of this instruction
+      setter offset
+
+      def initialize(@offset : Int32)
+      end
+
+      def to_s(io)
+        io << "jr " << @offset
+      end
+
+      def to_bin(table, stack, index)
+        return 0x1000 | ((@offset + index) * 2 + 0x200)
+      end
+    end
+
+    # Instruction to skip the next instruction if
+    # the left-hand register is equal to the right-hand value.
+    class SkipEqInstruction < Instruction
+      def initialize(@left : Int32, @right : Int32)
+      end
+
+      def to_s(io)
+        io << "seq R"
+        @left.to_s(16, io)
+        io << " " << @right
+      end
+
+      def to_bin(table, stack, index)
+        return 0x3000 | (@left << 8) | @right
+      end
+    end
+
+    # Instruction to skip the next instruction if
+    # the left-hand register is not equal to the right-hand value.
+    class SkipNeInstruction < Instruction
+      def initialize(@left : Int32, @right : Int32)
+      end
+
+      def to_s(io)
+        io << "sne R"
+        @left.to_s(16, io)
+        io << " " << @right
+      end
+
+      def to_bin(table, stack, index)
+        return 0x4000 | (@left << 8) | @right
+      end
+    end
+
+    # Instruction to skip the next instruction if
+    # the left-hand register is equal to the right-hand register.
+    class SkipRegEqInstruction < Instruction
+      def initialize(@left : Int32, @right : Int32)
+      end
+
+      def to_s(io)
+        io << "seqr R"
+        @left.to_s(16, io)
+        io << " R"
+        @right.to_s(16, io)
+      end
+
+      def to_bin(table, stack, index)
+        return 0x5000 | (@left << 8) | (@right << 4)
+      end
+    end
+
+    # Instruction to skip the next instruction if
+    # the left-hand register is not equal to the right-hand register.
+    class SkipRegNeInstruction < Instruction
+      def initialize(@left : Int32, @right : Int32)
+      end
+
+      def to_s(io)
+        io << "sner R"
+        @left.to_s(16, io)
+        io << " R"
+        @right.to_s(16, io)
+      end
+
+      def to_bin(table, stack, index)
+        return 0x9000 | (@left << 8) | (@right << 4)
+      end
+    end
+
+    # Instruction to call a function by name.
+    class CallInstruction < Instruction
+      # Gets the name of the function being called.
+      getter name
+
+      def initialize(@name : String)
+      end
+
+      def to_s(io)
+        io << "call " << @name
+      end
+
+      def to_bin(table, stack, index)
+          return 0x2000 | (table.get_function?(name).as(Compiler::FunctionEntry).addr * 2 + 0x200)
+      end
+    end
+
+    # Instruction to set I to the base position of the stack.
+    class SetIStackInstruction < Instruction
+      def to_s(io)
+        io << "setis"
+      end
+
+      def to_bin(table, stack, index)
+        return 0xa000 | (stack * 2 + 0x200)
+      end
+    end
+
+    class SetISpriteInstruction < Instruction
+      getter name
+
+      def initialize(@name : String)
+      end
+
+      def to_s(io)
+        io << "setispr " << @name
+      end
+      
+      def to_bin(table, stack, index)
+        return 0xa000 | (table.get_sprite?(@name).not_nil!.addr + 0x200)
+      end
+    end
+
+    # Instruction to add a register to I.
+    class AddIRegInstruction < Instruction
+      def initialize(@reg : Int32)
+      end
+
+      def to_s(io)
+        io << "addi R"
+        @reg.to_s(16, io)
+      end
+
+      def to_bin(table, stack, index)
+        return 0xf000 | (@reg << 8) | 0x1e
+      end
+    end
+
+    # Instruction to draw on screen.
+    # The x and y coordinates specify the position of the sprite,
+    # and the height gives the height of the sprite.
+    class DrawInstruction < Instruction
+      def initialize(@x : Int32, @y : Int32, @height : Int32)
+      end
+
+      def to_s(io)
+        io << "draw R"
+        @x.to_s(16, io)
+        io << " R"
+        @y.to_s(16, io)
+        io << " " << @height
+      end
+
+      def to_bin(table, stack, index)
+        return 0xd000 | (@x << 8) | (@y << 4) | @height
+      end
+    end
+
+    # Instruction to await a key press and store it into a register.
+    class AwaitKeyInstruction < Instruction
+      def initialize(@into : Int32)
+      end
+
+      def to_s(io)
+        io << "getk R"
+        @into.to_s(16, io)
+      end
+
+      def to_bin(table, stack, index)
+        return 0xf00a | (@into << 8)
+      end
+    end
+
+    # Instruction to set I to the font given by the value
+    # of a register.
+    class GetFontInstruction < Instruction
+      def initialize(@from : Int32)
+      end
+
+      def to_s(io)
+        io << "font R"
+        @from.to_s(16, io)
+      end
+
+      def to_bin(table, stack, index)
+        return 0xf029 | (@from << 8)
+      end
+    end
+
+    # Instruction to set the delay timer to the value
+    # of the given register.
+    class SetDelayTimerInstruction < Instruction
+      def initialize(@from : Int32)
+      end
+
+      def to_s(io)
+        io << "set_delay R"
+        @from.to_s(16, io)
+      end
+
+      def to_bin(table, stack, index)
+        return 0xf015 | (@from << 8)
+      end
+    end
+
+    # Instruction to get the delay timer, and store
+    # the value into the given register.
+    class GetDelayTimerInstruction < Instruction
+      def initialize(@into : Int32)
+      end
+
+      def to_s(io)
+        io << "get_delay R"
+        @into.to_s(16, io)
+      end
+
+      def to_bin(table, stack, index)
+        return 0xf007 | (@into << 8)
+      end
+    end
+
+    # Instruction to set the sound timer to a value.
+    class SetSoundTimerInstruction < Instruction
+      def initialize(@from : Int32)
+      end
+
+      def to_s(io)
+        io << "set_sound R"
+        @from.to_s(16, io)
+      end
+
+      def to_bin(table, stack, index)
+        return 0xf018 | (@from << 8)
+      end
+    end
+
+    class BCDInstruction < Instruction
+      def initialize(@from : Int32)
+      end
+
+      def to_s(io)
+        io << "bcd R"
+        @from.to_s(16, io)
+      end
+
+      def to_bin(table, stack, index)
+        return 0xf033 | (@from << 8)
+      end
     end
   end
-
-  class LoadRegInstruction < Instruction
-    property into : Int32
-    property from : Int32
-
-    def initialize(@into, @from)
-    end
-
-    def to_s(io)
-      io << "loadr R"
-      @into.to_s(16, io)
-      io << " R"
-      @from.to_s(16, io)
-    end
-  end
-
-  class OpInstruction < Instruction
-    property op : TokenType
-    property into : Int32
-    property value : Int32
-
-    def initialize(@op, @into, @value)
-    end
-
-    def to_s(io)
-      io << "op " << op << " R"
-      @into.to_s(16, io)
-      io << " " << @value
-    end
-  end
-
-  class OpRegInstruction < Instruction
-    property op : TokenType
-    property into : Int32
-    property from : Int32
-
-    def initialize(@op, @into, @from)
-    end
-
-    def to_s(io)
-      io << "opr " << op << " R"
-      @into.to_s(16, io)
-      io << " R"
-      @from.to_s(16, io)
-    end
-  end
-
-  class StoreInstruction < Instruction
-    property up_to : Int32
-
-    def initialize(@up_to)
-    end
-
-    def to_s(io)
-      io << "store R"
-      @up_to.to_s(16, io)
-    end
-  end
-
-  class RestoreInstruction < Instruction
-    property up_to : Int32
-
-    def initialize(@up_to)
-    end
-
-    def to_s(io)
-      io << "restore R"
-      @up_to.to_s(16, io)
-    end
-  end
-
-  class ReturnInstruction < Instruction
-    property to_return : Int32
-
-    def initialize(@to_return)
-    end
-
-    def to_s(io)
-      io << "return R"
-      @to_return.to_s(16, io)
-    end
-  end
-
-  class JumpEqInstruction < Instruction
-    property offset : Int32
-    property left : Int32
-    property right : Int32
-
-    def initialize(@offset, @left, @right)
-    end
-
-    def to_s(io)
-      io << "jeq " << offset << " R"
-      @left.to_s(16, io)
-      io << " " << right
-    end
-  end
-
-  class JumpEqRegInstruction < Instruction
-    property offset : Int32
-    property left : Int32
-    property right : Int32
-
-    def initialize(@offset, @left, @right)
-    end
-
-    def to_s(io)
-      io << "jeq " << offset << " R"
-      @left.to_s(16, io)
-      io << " R"
-      @right.to_s(16, io)
-    end
-  end
-  
 end

src/chalk/lexer.cr

@@ -1,82 +1,98 @@
 require "lex"
 
 module Chalk
-  enum TokenType
+  module Compiler
-    Any,
+    # The type of a token that can be lexed.
-    Str,
+    enum TokenType
-    Id,
+      Any,
-    LitDec,
+      Str,
-    LitBin,
+      Id,
-    LitHex,
+      SpriteRow,
-    OpAdd
+      LitDec,
-    OpSub
+      LitBin,
-    OpMul
+      LitHex,
-    OpDiv
+      OpAdd
-    OpOr
+      OpSub
-    OpAnd
+      OpMul
-    OpXor
+      OpDiv
-    KwSprite
+      OpOr
-    KwInline
+      OpAnd
-    KwFun
+      OpXor
-    KwU0
+      KwSprite
-    KwU8
+      KwInline
-    KwU12
+      KwFun
-    KwVar
+      KwU0
-    KwIf
+      KwU4
-    KwElse
+      KwU8
-    KwWhile
+      KwU12
-    KwReturn
+      KwVar
-  end
+      KwIf
-
+      KwElse
-  class Token
+      KwWhile
-    def initialize(@string : String, @type : TokenType)
+      KwReturn
     end
 
-    getter string : String
+    # A class that stores the string it matched and its token type.
-    getter type : TokenType
+    class Token
-  end
+      def initialize(@string : String, @type : TokenType)
+      end
 
-  class Lexer
+      # Gets the string this token represents.
-    def initialize
+      getter string : String
-      @lexer = Lex::Lexer.new
+      # Gets the type of this token.
-      @lexer.add_pattern(".", TokenType::Any.value)
+      getter type : TokenType
-      @lexer.add_pattern("\"(\\\\\"|[^\"])*\"",
-        TokenType::Str.value)
-      @lexer.add_pattern("[a-zA-Z_][a-zA-Z_0-9]*",
-        TokenType::Id.value)
-      @lexer.add_pattern("[0-9]+",
-        TokenType::LitDec.value)
-      @lexer.add_pattern("0b[0-1]+",
-        TokenType::LitBin.value)
-      @lexer.add_pattern("0x[0-9a-fA-F]+",
-        TokenType::LitHex.value)
-      @lexer.add_pattern("\\+", TokenType::OpAdd.value)
-      @lexer.add_pattern("-", TokenType::OpSub.value)
-      @lexer.add_pattern("\\*", TokenType::OpMul.value)
-      @lexer.add_pattern("/", TokenType::OpDiv.value)
-      @lexer.add_pattern("&", TokenType::OpAdd.value)
-      @lexer.add_pattern("\\|", TokenType::OpOr.value)
-      @lexer.add_pattern("^", TokenType::OpXor.value)
-      @lexer.add_pattern("sprite", TokenType::KwSprite.value)
-      @lexer.add_pattern("inline", TokenType::KwInline.value)
-      @lexer.add_pattern("fun", TokenType::KwFun.value)
-      @lexer.add_pattern("u0", TokenType::KwU0.value)
-      @lexer.add_pattern("u8", TokenType::KwU8.value)
-      @lexer.add_pattern("u12", TokenType::KwU12.value)
-      @lexer.add_pattern("var", TokenType::KwVar.value)
-      @lexer.add_pattern("if", TokenType::KwIf.value)
-      @lexer.add_pattern("else", TokenType::KwElse.value)
-      @lexer.add_pattern("while", TokenType::KwWhile.value)
-      @lexer.add_pattern("return", TokenType::KwReturn.value)
     end
 
-    def lex(string)
+    # Creates a new Lexer with default token values.
-      return @lexer.lex(string)
+    # The lexer is backed by liblex. When a string is
-        .select { |t| !t[0][0].whitespace? }
+    # matched by several tokens, the longest match is chosen
-        .map do |tuple|
+    # first, followed by the match with the highest enum value.
-          string, id = tuple
+    class Lexer
-          Token.new(string, TokenType.new(id))
+      def initialize
-        end
+        @lexer = Lex::Lexer.new
+        @lexer.add_pattern(".", TokenType::Any.value)
+        @lexer.add_pattern("\"(\\\\\"|[^\"])*\"",
+          TokenType::Str.value)
+        @lexer.add_pattern("[a-zA-Z_][a-zA-Z_0-9]*",
+          TokenType::Id.value)
+        @lexer.add_pattern("`[ x]*`",
+          TokenType::SpriteRow.value)
+        @lexer.add_pattern("[0-9]+",
+          TokenType::LitDec.value)
+        @lexer.add_pattern("0b[0-1]+",
+          TokenType::LitBin.value)
+        @lexer.add_pattern("0x[0-9a-fA-F]+",
+          TokenType::LitHex.value)
+        @lexer.add_pattern("\\+", TokenType::OpAdd.value)
+        @lexer.add_pattern("-", TokenType::OpSub.value)
+        @lexer.add_pattern("\\*", TokenType::OpMul.value)
+        @lexer.add_pattern("/", TokenType::OpDiv.value)
+        @lexer.add_pattern("&", TokenType::OpAdd.value)
+        @lexer.add_pattern("\\|", TokenType::OpOr.value)
+        @lexer.add_pattern("^", TokenType::OpXor.value)
+        @lexer.add_pattern("sprite", TokenType::KwSprite.value)
+        @lexer.add_pattern("inline", TokenType::KwInline.value)
+        @lexer.add_pattern("fun", TokenType::KwFun.value)
+        @lexer.add_pattern("u0", TokenType::KwU0.value)
+        @lexer.add_pattern("u4", TokenType::KwU4.value)
+        @lexer.add_pattern("u8", TokenType::KwU8.value)
+        @lexer.add_pattern("u12", TokenType::KwU12.value)
+        @lexer.add_pattern("var", TokenType::KwVar.value)
+        @lexer.add_pattern("if", TokenType::KwIf.value)
+        @lexer.add_pattern("else", TokenType::KwElse.value)
+        @lexer.add_pattern("while", TokenType::KwWhile.value)
+        @lexer.add_pattern("return", TokenType::KwReturn.value)
+      end
+
+      # Converts a string into tokens.
+      def lex(string)
+        return @lexer.lex(string)
+          .select { |t| !t[0][0].whitespace? }
+          .map do |tuple|
+            string, id = tuple
+            Token.new(string, TokenType.new(id))
+          end
+      end
     end
   end
 end

src/chalk/optimizer.cr

@@ -0,0 +1,70 @@
+module Chalk
+  module Compiler
+    # Class to optimize instructions.
+    class Optimizer
+      # Checks if *inst* is "dead code",
+      # an instruction that is completely useless.
+      private def check_dead(inst)
+        if inst.is_a?(Ir::LoadRegInstruction)
+          return inst.from == inst.into
+        end
+        return false
+      end
+
+      # Optimizes *instructions* in the basic block given by the *range*,
+      # storing addresses of instructions to be deleted into *deletions*,
+      # and the number of deleted instructions so far into *deletions_at*
+      private def optimize!(instructions, range, deletions, deletions_at)
+        range.each do |index|
+          if check_dead(instructions[index])
+            deletions << index
+          end
+          deletions_at[index] = deletions.size
+        end
+      end
+
+      # Optimizes the given list of instructions.
+      # The basic blocks are inferred from the various
+      # jumps and skips.
+      def optimize(instructions)
+        instructions = instructions.dup
+        block_boundaries = [instructions.size]
+        instructions.each_with_index do |inst, i|
+          if inst.is_a?(Ir::JumpRelativeInstruction)
+            block_boundaries << (i + 1)
+            block_boundaries << (inst.offset + i)
+          end
+          if inst.is_a?(Ir::SkipNeInstruction | Ir::SkipEqInstruction |
+                        Ir::SkipRegEqInstruction | Ir::SkipRegNeInstruction)
+            block_boundaries << (i + 1)
+          end
+        end
+        block_boundaries.uniq!.sort!
+
+        previous = 0
+        deletions = [] of Int32
+        deletions_at = {} of Int32 => Int32
+        block_boundaries.each do |boundary|
+          range = previous...boundary
+          optimize!(instructions, range, deletions, deletions_at)
+          previous = boundary
+        end
+
+        instructions.each_with_index do |inst, i|
+          next if !inst.is_a?(Ir::JumpRelativeInstruction)
+          jump_to = inst.offset + i
+          next unless deletions_at[jump_to]?
+          deletions_offset = deletions_at[i] - deletions_at[jump_to]
+          inst.offset += deletions_offset
+        end
+
+        deletions.reverse!
+        deletions.each do |i|
+          instructions.delete_at i
+        end
+
+        return instructions
+      end
+    end
+  end
+end

src/chalk/parser.cr

@@ -1,173 +1,218 @@
-require "./builder.cr"
+require "./parser_builder.cr"
 
 module Chalk
-  class Parser
+  module ParserCombinators
-    include Builder
+    # Parser created out of the various parser combinators.
+    class Parser
+      include ParserBuilder
 
-    private def create_type
+      private def create_sprite
-      either(type(TokenType::KwU0), type(TokenType::KwU8), type(TokenType::KwU12))
+        type(Compiler::TokenType::KwSprite)
-    end
+            .then(type(Compiler::TokenType::Id))
-
+            .then(char('['))
-    private def create_lit
+            .then(many(type(Compiler::TokenType::SpriteRow)))
-      dec_parser = type(TokenType::LitDec).transform &.string.to_i64
+            .then(char(']'))
-      hex_parser = type(TokenType::LitHex).transform &.string.lchop("0x").to_i64(16)
+            .transform do |array|
-      bin_parser = type(TokenType::LitBin).transform &.string.lchop("0b").to_i64(2)
+            array = array.flatten
-      lit_parser = either(dec_parser, hex_parser, bin_parser).transform { |it| TreeLit.new(it).as(Tree) }
+            name = array[1].string
-      return lit_parser
+            sprite = Compiler::Sprite.new(array[3..array.size - 2].map &.string)
-    end
+            Trees::TreeSprite.new(name, sprite).as(Trees::Tree)
-
-    private def create_op_expr(atom, op)
-      pl = PlaceholderParser(Tree).new
-      recurse = atom.then(op).then(pl).transform do |arr|
-        arr = arr.flatten
-        TreeOp.new(
-          arr[1].as(Token).type,
-          arr[0].as(Tree),
-          arr[2].as(Tree)).as(Tree)
-      end
-      pl.parser = either(recurse, atom)
-      return pl
-    end
-
-    private def create_op_exprs(atom, ops)
-      ops.reduce(atom) do |previous, current|
-        create_op_expr(previous, current)
-      end
-    end
-
-    private def create_call(expr)
-      call = type(TokenType::Id).then(char '(').then(delimited(expr, char ',')).then(char ')').transform do |arr|
-        arr = arr.flatten
-        name = arr[0].as(Token).string
-        params = arr[2..arr.size - 2].map &.as(Tree)
-        TreeCall.new(name, params).as(Tree)
-      end
-      return call
-    end
-
-    private def create_expr
-      expr_place = PlaceholderParser(Tree).new
-      literal = create_lit
-      id = type(TokenType::Id).transform { |it| TreeId.new(it.string).as(Tree) }
-      call = create_call(expr_place)
-      atom = either(literal, call, id)
-
-      ops = [either(type(TokenType::OpMul), type(TokenType::OpDiv)),
-             either(type(TokenType::OpAdd), type(TokenType::OpSub)),
-             type(TokenType::OpXor),
-             type(TokenType::OpAnd),
-             type(TokenType::OpOr)]
-      expr = create_op_exprs(atom, ops)
-      expr_place.parser = expr
-
-      return expr
-    end
-
-    private def create_var(expr)
-      var = type(TokenType::KwVar).then(type(TokenType::Id)).then(char '=').then(expr).then(char ';').transform do |arr|
-        arr = arr.flatten
-        name = arr[1].as(Token).string
-        exp = arr[arr.size - 2].as(Tree)
-        TreeVar.new(name, exp).as(Tree)
-      end
-      return var
-    end
-
-    private def create_assign(expr)
-      assign = type(TokenType::Id).then(char '=').then(expr).then(char ';').transform do |arr|
-        arr = arr.flatten
-        name = arr[0].as(Token).string
-        exp = arr[arr.size - 2].as(Tree)
-        TreeAssign.new(name, exp).as(Tree)
-      end
-      return assign
-    end
-
-    private def create_basic(expr)
-      basic = expr.then(char ';').transform do |arr|
-        arr.flatten[0].as(Tree)
-      end
-      return basic
-    end
-
-    private def create_if(expr, block)
-      iff = type(TokenType::KwIf).then(char '(').then(expr).then(char ')').then(block)
-        .then(optional(type(TokenType::KwElse).then(block)))
-        .transform do |arr|
-          arr = arr.flatten
-          cond = arr[2].as(Tree)
-          code = arr[4].as(Tree)
-          otherwise = arr.size == 7 ? arr[6].as(Tree) : nil
-          TreeIf.new(cond, code, otherwise).as(Tree)
         end
-      return iff
-    end
-
-    private def create_while(expr, block)
-      whilee = type(TokenType::KwWhile).then(char '(').then(expr).then(char ')').then(block).transform do |arr|
-        arr = arr.flatten
-        cond = arr[2].as(Tree)
-        code = arr[4].as(Tree)
-        TreeWhile.new(cond, code).as(Tree)
       end
-      return whilee
-    end
 
-    private def create_return(expr)
+      # Creates a parser for a type.
-      returnn = type(TokenType::KwReturn).then(expr).then(char ';').transform do |arr|
+      private def create_type
-        arr = arr.flatten
+        either(type(Compiler::TokenType::KwU0),
-        value = arr[1].as(Tree)
+               type(Compiler::TokenType::KwU4),
-        TreeReturn.new(value).as(Tree)
+               type(Compiler::TokenType::KwU8),
+               type(Compiler::TokenType::KwU12))
       end
-      return returnn
-    end
 
-    private def create_block(statement)
+      # Creates a parser for an integer literal.
-      block = char('{').then(many(statement)).then(char '}').transform do |arr|
+      private def create_lit
-        arr = arr.flatten
+        dec_parser = type(Compiler::TokenType::LitDec).transform &.string.to_i64
-        params = arr[1..arr.size - 2].map &.as(Tree)
+        hex_parser = type(Compiler::TokenType::LitHex).transform &.string.lchop("0x").to_i64(16)
-        TreeBlock.new(params).as(Tree)
+        bin_parser = type(Compiler::TokenType::LitBin).transform &.string.lchop("0b").to_i64(2)
+        lit_parser = either(dec_parser, hex_parser, bin_parser).transform { |it| Trees::TreeLit.new(it).as(Trees::Tree) }
+        return lit_parser
       end
-      return block
-    end
 
-    private def create_statement_block
+      # Creates a parser for an operation with a given *atom* parser
-      statement_place = PlaceholderParser(Tree).new
+      # and *op* parser.
-      expr = create_expr
+      private def create_op_expr(atom, op)
-      block = create_block(statement_place)
+        pl = PlaceholderParser(Trees::Tree).new
-      iff = create_if(expr, block)
+        recurse = atom.then(op).then(pl).transform do |arr|
-      whilee = create_while(expr, block)
-      returnn = create_return(expr)
-      var = create_var(expr)
-      assign = create_assign(expr)
-      basic = create_basic(expr)
-      statement = either(basic, var, assign, block, iff, whilee, returnn)
-      statement_place.parser = statement
-      return {statement, block}
-    end
-
-    private def create_func(block, type)
-      func = type(TokenType::KwFun).then(type(TokenType::Id))
-        .then(char '(').then(delimited(type(TokenType::Id), char ',')).then(char ')')
-        .then(char ':').then(type)
-        .then(block).transform do |arr|
           arr = arr.flatten
-          name = arr[1].as(Token).string
+          Trees::TreeOp.new(
-          params = arr[3..arr.size - 5].map &.as(Token).string
+            arr[1].as(Compiler::Token).type,
-          code = arr[arr.size - 1].as(Tree)
+            arr[0].as(Trees::Tree),
-          type = arr[arr.size - 2].as(Token).type
+            arr[2].as(Trees::Tree)).as(Trees::Tree)
-          TreeFunction.new(name, params, code).as(Tree)
         end
-      return func
+        pl.parser = either(recurse, atom)
-    end
+        return pl
+      end
 
-    def initialize
+      # Creates a parser to parse layers of *ops* with multiple
-      _, block = create_statement_block
+      # levels of precedence, specified by their order. The *atom*
-      @parser = many(create_func(block, create_type)).as(BasicParser(Array(Tree)))
+      # is the most basic expression.
-    end
+      private def create_op_exprs(atom, ops)
+        ops.reduce(atom) do |previous, current|
+          create_op_expr(previous, current)
+        end
+      end
 
-    def parse?(tokens)
+      # Creates a parser for a call, with the given expression parser.
-      return @parser.parse?(tokens, 0).try &.[0]
+      private def create_call(expr)
+        call = type(Compiler::TokenType::Id).then(char '(').then(delimited(expr, char ',')).then(char ')').transform do |arr|
+          arr = arr.flatten
+          name = arr[0].as(Compiler::Token).string
+          params = arr[2..arr.size - 2].map &.as(Trees::Tree)
+          Trees::TreeCall.new(name, params).as(Trees::Tree)
+        end
+        return call
+      end
+
+      # Creates a parser for an expression.
+      private def create_expr
+        expr_place = PlaceholderParser(Trees::Tree).new
+        literal = create_lit
+        id = type(Compiler::TokenType::Id).transform { |it| Trees::TreeId.new(it.string).as(Trees::Tree) }
+        call = create_call(expr_place)
+        atom = either(literal, call, id)
+
+        ops = [either(type(Compiler::TokenType::OpMul), type(Compiler::TokenType::OpDiv)),
+               either(type(Compiler::TokenType::OpAdd), type(Compiler::TokenType::OpSub)),
+               type(Compiler::TokenType::OpXor),
+               type(Compiler::TokenType::OpAnd),
+               type(Compiler::TokenType::OpOr)]
+        expr = create_op_exprs(atom, ops)
+        expr_place.parser = expr
+
+        return expr
+      end
+
+      # Creates a parser for a var statement.
+      private def create_var(expr)
+        var = type(Compiler::TokenType::KwVar).then(type(Compiler::TokenType::Id)).then(char '=').then(expr).then(char ';').transform do |arr|
+          arr = arr.flatten
+          name = arr[1].as(Compiler::Token).string
+          exp = arr[arr.size - 2].as(Trees::Tree)
+          Trees::TreeVar.new(name, exp).as(Trees::Tree)
+        end
+        return var
+      end
+
+      # Creates a parser for an assignment statement.
+      private def create_assign(expr)
+        assign = type(Compiler::TokenType::Id).then(char '=').then(expr).then(char ';').transform do |arr|
+          arr = arr.flatten
+          name = arr[0].as(Compiler::Token).string
+          exp = arr[arr.size - 2].as(Trees::Tree)
+          Trees::TreeAssign.new(name, exp).as(Trees::Tree)
+        end
+        return assign
+      end
+
+      # Creates a parser for a basic statement.
+      private def create_basic(expr)
+        basic = expr.then(char ';').transform do |arr|
+          arr.flatten[0].as(Trees::Tree)
+        end
+        return basic
+      end
+
+      # Creates a parser for an if statement.
+      private def create_if(expr, block)
+        iff = type(Compiler::TokenType::KwIf).then(char '(').then(expr).then(char ')').then(block)
+          .then(optional(type(Compiler::TokenType::KwElse).then(block)))
+          .transform do |arr|
+            arr = arr.flatten
+            cond = arr[2].as(Trees::Tree)
+            code = arr[4].as(Trees::Tree)
+            otherwise = arr.size == 7 ? arr[6].as(Trees::Tree) : nil
+            Trees::TreeIf.new(cond, code, otherwise).as(Trees::Tree)
+          end
+        return iff
+      end
+
+      # Creates a parser for a while loop.
+      private def create_while(expr, block)
+        whilee = type(Compiler::TokenType::KwWhile).then(char '(').then(expr).then(char ')').then(block).transform do |arr|
+          arr = arr.flatten
+          cond = arr[2].as(Trees::Tree)
+          code = arr[4].as(Trees::Tree)
+          Trees::TreeWhile.new(cond, code).as(Trees::Tree)
+        end
+        return whilee
+      end
+
+      # Creates a parser for a return.
+      private def create_return(expr)
+        returnn = type(Compiler::TokenType::KwReturn).then(expr).then(char ';').transform do |arr|
+          arr = arr.flatten
+          value = arr[1].as(Trees::Tree)
+          Trees::TreeReturn.new(value).as(Trees::Tree)
+        end
+        return returnn
+      end
+
+      # Creates a parser for a block of statements.
+      private def create_block(statement)
+        block = char('{').then(many(statement)).then(char '}').transform do |arr|
+          arr = arr.flatten
+          params = arr[1..arr.size - 2].map &.as(Trees::Tree)
+          Trees::TreeBlock.new(params).as(Trees::Tree)
+        end
+        return block
+      end
+
+      # Creates a statement and block parser, returning both.
+      private def create_statement_block
+        statement_place = PlaceholderParser(Trees::Tree).new
+        expr = create_expr
+        block = create_block(statement_place)
+        iff = create_if(expr, block)
+        whilee = create_while(expr, block)
+        returnn = create_return(expr)
+        var = create_var(expr)
+        assign = create_assign(expr)
+        basic = create_basic(expr)
+        statement = either(basic, var, assign, block, iff, whilee, returnn)
+        statement_place.parser = statement
+        return {statement, block}
+      end
+
+      # Creates a parser for a function declaration.
+      private def create_func(block, type)
+        func = type(Compiler::TokenType::KwFun).then(type(Compiler::TokenType::Id))
+          .then(char '(').then(delimited(type(Compiler::TokenType::Id), char ',')).then(char ')')
+          .then(char ':').then(type)
+          .then(block).transform do |arr|
+            arr = arr.flatten
+            name = arr[1].as(Compiler::Token).string
+            params = arr[3..arr.size - 5].map &.as(Compiler::Token).string
+            code = arr[arr.size - 1].as(Trees::Tree)
+            type = arr[arr.size - 2].as(Compiler::Token).type
+            table = {
+                Compiler::TokenType::KwU0 => Compiler::Type::U0,
+                Compiler::TokenType::KwU4 => Compiler::Type::U4,
+                Compiler::TokenType::KwU8 => Compiler::Type::U8,
+                Compiler::TokenType::KwU12 => Compiler::Type::U12
+            }
+            Trees::TreeFunction.new(name, params, table[type], code).as(Trees::Tree)
+          end
+        return func
+      end
+
+      def initialize
+        _, block = create_statement_block
+        @parser = many(either(create_func(block, create_type), create_sprite)).as(BasicParser(Array(Trees::Tree)))
+      end
+
+      # Parses the given tokens into a tree.
+      def parse?(tokens)
+        return @parser.parse?(tokens, 0).try &.[0]
+      end
     end
   end
 end

src/chalk/parser_builder.cr

@@ -0,0 +1,48 @@
+require "./lexer.cr"
+require "./parsers.cr"
+
+module Chalk
+  module ParserCombinators
+    module ParserBuilder
+      # Creates a parser for a given token type.
+      def type(type) : BasicParser(Compiler::Token)
+        return TypeParser.new(type).as(BasicParser(Compiler::Token))
+      end
+
+      # Creates a parser for a specific character.
+      def char(type) : BasicParser(Compiler::Token)
+        return CharParser.new(type).as(BasicParser(Compiler::Token))
+      end
+
+      # Creates a parser that transforms a value according to a block.
+      def transform(parser : BasicParser(T), &transform : T -> R) forall T, R
+        return TransformParser.new(parser, &transform).as(BasicParser(R))
+      end
+
+      # Creates a parser that allows for failure to match.
+      def optional(parser : BasicParser(T)) : BasicParser(T?) forall T
+        return OptionalParser.new(parser).as(BasicParser(T?))
+      end
+
+      # Creates a parser that tries several parsers in sequence until one succeeds.
+      def either(*args : BasicParser(T)) : BasicParser(T) forall T
+        return EitherParser.new(args.to_a).as(BasicParser(T))
+      end
+
+      # Creates a parser that parses one or more of the given parsers.
+      def many(parser : BasicParser(T)) : BasicParser(Array(T)) forall T
+        return ManyParser.new(parser).as(BasicParser(Array(T)))
+      end
+
+      # Creates a parser that parses one parser delimited by another.
+      def delimited(parser : BasicParser(T), delimiter : BasicParser(R)) : BasicParser(Array(T)) forall T, R
+        return DelimitedParser.new(parser, delimiter).as(BasicParser(Array(T)))
+      end
+
+      # Creates a parser that parses one parser, then the next.
+      def then(first : BasicParser(T), second : BasicParser(R)) forall T, R
+        return NextParser.new(first, second).as(BasicParser(Array(T | R)))
+      end
+    end
+  end
+end

src/chalk/parsers.cr

@@ -1,148 +1,171 @@
-require "./builder.cr"
-
 module Chalk
-  abstract class BasicParser(T)
+  module ParserCombinators
-    abstract def parse?(tokens : Array(Token),
+    # Abstract class for a parser function,
-                        index : Int64) : Tuple(T, Int64)?
+    # as used in parser combinators. This is basically
+    # a building block of parsing.
+    abstract class BasicParser(T)
+      # Attempts to parse the given *tokens*, starting at the given *index*.
+      abstract def parse?(tokens : Array(Compiler::Token),
+                          index : Int64) : Tuple(T, Int64)?
 
-    def parse(tokens, index)
+      # Attempts to parse the given tokens like `#parse?`, but throws
-      return parse?(tokens, index).not_nil!
+      # on error.
-    end
+      def parse(tokens, index)
-
+        return parse?(tokens, index).not_nil!
-    def transform(&transform : T -> R) forall R
-      return TransformParser.new(self, &transform).as(BasicParser(R))
-    end
-
-    def then(other : BasicParser(R)) : BasicParser(Array(T | R)) forall R
-      return NextParser.new(self, other).as(BasicParser(Array(T | R)))
-    end
-  end
-
-  class TypeParser < BasicParser(Token)
-    def initialize(@type : TokenType)
-    end
-
-    def parse?(tokens, index)
-      return nil unless index < tokens.size
-      return nil unless tokens[index].type == @type
-      return {tokens[index], index + 1}
-    end
-  end
-
-  class CharParser < BasicParser(Token)
-    def initialize(@char : Char)
-    end
-
-    def parse?(tokens, index)
-      return nil unless index < tokens.size
-      return nil unless (tokens[index].type == TokenType::Any) &&
-                        tokens[index].string[0] == @char
-      return {tokens[index], index + 1}
-    end
-  end
-
-  class TransformParser(T, R) < BasicParser(R)
-    def initialize(@parser : BasicParser(T), &@block : T -> R)
-    end
-
-    def parse?(tokens, index)
-      if parsed = @parser.parse?(tokens, index)
-        return {@block.call(parsed[0]), parsed[1]}
       end
-      return nil
-    end
-  end
 
-  class OptionalParser(T) < BasicParser(T?)
+      # Applies the given transformation to this parser,
-    def initialize(@parser : BasicParser(T))
+      # creating a new parser.
-    end
+      def transform(&transform : T -> R) forall R
-
+        return TransformParser.new(self, &transform).as(BasicParser(R))
-    def parse?(tokens, index)
-      if parsed = @parser.parse?(tokens, index)
-        return {parsed[0], parsed[1]}
       end
-      return {nil, index}
-    end
-  end
 
-  class EitherParser(T) < BasicParser(T)
+      # Creates a sequence with the given parser,
-    def initialize(@parsers : Array(BasicParser(T)))
+      # creating a new parser.
+      def then(other : BasicParser(R)) : BasicParser(Array(T | R)) forall R
+        return NextParser.new(self, other).as(BasicParser(Array(T | R)))
+      end
     end
 
-    def parse?(tokens, index)
+    # Parser that expects a specific token type.
-      @parsers.each do |parser|
+    class TypeParser < BasicParser(Compiler::Token)
-        if parsed = parser.parse?(tokens, index)
+      def initialize(@type : Compiler::TokenType)
-          return parsed
+      end
+
+      def parse?(tokens, index)
+        return nil unless index < tokens.size
+        return nil unless tokens[index].type == @type
+        return {tokens[index], index + 1}
+      end
+    end
+
+    # Parser that expects a specific character.
+    class CharParser < BasicParser(Compiler::Token)
+      def initialize(@char : Char)
+      end
+
+      def parse?(tokens, index)
+        return nil unless index < tokens.size
+        return nil unless (tokens[index].type == Compiler::TokenType::Any) &&
+                          tokens[index].string[0] == @char
+        return {tokens[index], index + 1}
+      end
+    end
+
+    # Parser that applies a transformation to the output
+    # of its child parser.
+    class TransformParser(T, R) < BasicParser(R)
+      def initialize(@parser : BasicParser(T), &@block : T -> R)
+      end
+
+      def parse?(tokens, index)
+        if parsed = @parser.parse?(tokens, index)
+          return {@block.call(parsed[0]), parsed[1]}
         end
+        return nil
       end
-      return nil
-    end
-  end
-
-  class ManyParser(T) < BasicParser(Array(T))
-    def initialize(@parser : BasicParser(T))
     end
 
-    def parse?(tokens, index)
+    # Parser that attempts to use its child parser,
-      many = [] of T
+    # and successfully returns nil if the child parser fails.
-      while parsed = @parser.parse?(tokens, index)
+    class OptionalParser(T) < BasicParser(T?)
-        item, index = parsed
+      def initialize(@parser : BasicParser(T))
-        many << item
-      end
-      return {many, index}
-    end
-  end
-
-  class DelimitedParser(T, R) < BasicParser(Array(T))
-    def initialize(@parser : BasicParser(T), @delimiter : BasicParser(R))
-    end
-
-    def parse?(tokens, index)
-      array = [] of T
-      first = @parser.parse?(tokens, index)
-      return {array, index} unless first
-      first_value, index = first
-      array << first_value
-      while delimiter = @delimiter.parse?(tokens, index)
-        _, new_index = delimiter
-        new = @parser.parse?(tokens, new_index)
-        break unless new
-        new_value, index = new
-        array << new_value
       end
 
-      return {array, index}
+      def parse?(tokens, index)
-    end
+        if parsed = @parser.parse?(tokens, index)
-  end
+          return {parsed[0], parsed[1]}
-
+        end
-  class NextParser(T, R) < BasicParser(Array(T | R))
+        return {nil, index}
-    def initialize(@first : BasicParser(T), @second : BasicParser(R))
+      end
     end
 
-    def parse?(tokens, index)
+    # Parser that tries all of its children until one succeeds.
-      first = @first.parse?(tokens, index)
+    class EitherParser(T) < BasicParser(T)
-      return nil unless first
+      def initialize(@parsers : Array(BasicParser(T)))
-      first_value, index = first
+      end
 
-      second = @second.parse?(tokens, index)
+      def parse?(tokens, index)
-      return nil unless second
+        @parsers.each do |parser|
-      second_value, index = second
+          if parsed = parser.parse?(tokens, index)
-
+            return parsed
-      array = Array(T | R).new
+          end
-      array << first_value << second_value
+        end
-      return {array, index}
+        return nil
-    end
+      end
-  end
-
-  class PlaceholderParser(T) < BasicParser(T)
-    property parser : BasicParser(T)?
-
-    def initialize
-      @parser = nil
     end
 
-    def parse?(tokens, index)
+    # Parser that parses at least one of a given type.
-      @parser.try &.parse?(tokens, index)
+    class ManyParser(T) < BasicParser(Array(T))
+      def initialize(@parser : BasicParser(T))
+      end
+
+      def parse?(tokens, index)
+        many = [] of T
+        while parsed = @parser.parse?(tokens, index)
+          item, index = parsed
+          many << item
+        end
+        return {many, index}
+      end
+    end
+
+    # Parser that parses at least 0 of its child parser,
+    # delimited with its other child parser.
+    class DelimitedParser(T, R) < BasicParser(Array(T))
+      def initialize(@parser : BasicParser(T), @delimiter : BasicParser(R))
+      end
+
+      def parse?(tokens, index)
+        array = [] of T
+        first = @parser.parse?(tokens, index)
+        return {array, index} unless first
+        first_value, index = first
+        array << first_value
+        while delimiter = @delimiter.parse?(tokens, index)
+          _, new_index = delimiter
+          new = @parser.parse?(tokens, new_index)
+          break unless new
+          new_value, index = new
+          array << new_value
+        end
+
+        return {array, index}
+      end
+    end
+
+    # Parser that parses using the first parser, and, if it succeeds,
+    # parses using the second parses.
+    class NextParser(T, R) < BasicParser(Array(T | R))
+      def initialize(@first : BasicParser(T), @second : BasicParser(R))
+      end
+
+      def parse?(tokens, index)
+        first = @first.parse?(tokens, index)
+        return nil unless first
+        first_value, index = first
+
+        second = @second.parse?(tokens, index)
+        return nil unless second
+        second_value, index = second
+
+        array = Array(T | R).new
+        array << first_value << second_value
+        return {array, index}
+      end
+    end
+
+    # Parser used to declare recursive grammars.
+    class PlaceholderParser(T) < BasicParser(T)
+      property parser : BasicParser(T)?
+
+      def initialize
+        @parser = nil
+      end
+
+      def parse?(tokens, index)
+        @parser.try &.parse?(tokens, index)
+      end
     end
   end
 end

src/chalk/print_visitor.cr

@@ -1,53 +1,55 @@
 require "./tree.cr"
 
 module Chalk
-  class PrintVisitor < Visitor
+  module Trees
-    def initialize(@stream : IO)
+    # Visitor that prints a `Tree`.
-      @indent = 0
+    class PrintVisitor < Visitor
-    end
+      def initialize(@stream : IO)
-
+        @indent = 0
-    def print_indent
-      @indent.times do
-        @stream << "  "
       end
-    end
 
-    def visit(id : TreeId)
+      private def print_indent
-      print_indent
+        @indent.times do
-      @stream << id.id << "\n"
+          @stream << "  "
-    end
+        end
-
-    def visit(lit : TreeLit)
-      print_indent
-      @stream << lit.lit << "\n"
-    end
-
-    def visit(op : TreeOp)
-      print_indent
-      @stream << "[op] "
-      @stream << op.op << "\n"
-      @indent += 1
-    end
-
-    def finish(op : TreeOp)
-      @indent -= 1
-    end
-
-    def visit(function : TreeFunction)
-      print_indent
-      @stream << "[function] " << function.name << "( "
-      function.params.each do |param|
-        @stream << param << " "
       end
-      @stream << ")" << "\n"
-      @indent += 1
-    end
 
-    def finish(function : TreeFunction)
+      def visit(id : TreeId)
-      @indent -= 1
+        print_indent
-    end
+        @stream << id.id << "\n"
+      end
 
-    macro forward(text, type)
+      def visit(lit : TreeLit)
+        print_indent
+        @stream << lit.lit << "\n"
+      end
+
+      def visit(op : TreeOp)
+        print_indent
+        @stream << "[op] "
+        @stream << op.op << "\n"
+        @indent += 1
+      end
+
+      def finish(op : TreeOp)
+        @indent -= 1
+      end
+
+      def visit(function : TreeFunction)
+        print_indent
+        @stream << "[function] " << function.name << "( "
+        function.params.each do |param|
+          @stream << param << " "
+        end
+        @stream << ")" << "\n"
+        @indent += 1
+      end
+
+      def finish(function : TreeFunction)
+        @indent -= 1
+      end
+
+      macro forward(text, type)
       def visit(tree : {{type}})
         print_indent
         @stream << {{text}} << "\n"
@@ -59,18 +61,19 @@ module Chalk
       end
     end
 
-    forward("[call]", TreeCall)
+      forward("[call]", TreeCall)
-    forward("[block]", TreeBlock)
+      forward("[block]", TreeBlock)
-    forward("[var]", TreeVar)
+      forward("[var]", TreeVar)
-    forward("[assign]", TreeAssign)
+      forward("[assign]", TreeAssign)
-    forward("[if]", TreeIf)
+      forward("[if]", TreeIf)
-    forward("[while]", TreeWhile)
+      forward("[while]", TreeWhile)
-    forward("[return]", TreeReturn)
+      forward("[return]", TreeReturn)
-  end
+    end
 
-  class Tree
+    class Tree
-    def to_s(io)
+      def to_s(io)
-      accept(PrintVisitor.new io)
+        accept(PrintVisitor.new io)
+      end
     end
   end
 end

src/chalk/sprite.cr

@@ -0,0 +1,97 @@
+module Chalk
+  module Compiler
+    class Sprite
+      def initialize
+        @pixels = Hash(UInt8, UInt8).new(default_value: 0_u8)
+      end
+
+      def height
+        return (@pixels.keys.max || 0_u8) + 1
+      end
+
+      def initialize(string, blank_char = ' ')
+        @pixels = Hash(UInt8, UInt8).new(default_value: 0_u8)
+        string.split("\n").each_with_index do |s, i|
+          break if i > 15
+          index = 0
+          byte = 0_u8
+          s.each_char do |char|
+            break if index > 7
+            bit = (char == blank_char) ? 0_u8 : 1_u8
+            byte |= (bit << (7 - index))
+            index += 1
+          end
+          @pixels[i.to_u8] = byte
+        end
+      end
+      
+      def initialize(tokens)
+          raise "Invalid sprite" if tokens.size > 15
+          @pixels = Hash(UInt8, UInt8).new(default_value: 0_u8)
+          tokens.each_with_index do |token, i|
+            byte = 0_u8
+            substring = token[1..token.size - 2]
+            raise "Invalid sprite" if substring.size > 8
+            bit = 0b10000000
+            substring.each_char do |char|
+                byte |= bit if char == 'x'
+                bit >>= 1
+            end
+            @pixels[i.to_u8] = byte
+          end
+      end
+
+      def set_pixel(x, y)
+        raise "Invalid x-coordinate" if x > 7
+        raise "Invalid y-coordinate" if y > 15
+        x = x.to_u8
+        y = y.to_u8
+        char = @pixels.fetch y, 0_u8
+        char |= (1 << (7 - x))
+        @pixels[y] = char
+      end
+
+      def unset_pixel(x, y)
+        raise "Invalid x-coordinate" if x > 7
+        raise "Invalid y-coordinate" if y > 15
+        x = x.to_u8
+        y = y.to_u8
+        char = @pixels.fetch y, 0_u8
+        char &= ~(1 << (7 - x))
+        @pixels[y] = char
+      end
+
+      def toggle_pixel(x, y)
+        raise "Invalid x-coordinate" if x > 7
+        raise "Invalid y-coordinate" if y > 15
+        x = x.to_u8
+        y = y.to_u8
+        char = @pixels.fetch y, 0_u8
+        char ^= (1 << (7 - x))
+        @pixels[y] = char
+      end
+
+      def draw(io = STDOUT, blank_char = ' ', ink_char = 'x')
+        until_y = @pixels.keys.max?
+        return unless until_y
+        (0..until_y).each do |y|
+          row = @pixels.fetch y, 0_u8
+          pointer = 0b10000000
+          while pointer != 0
+            draw_pixel = (row & pointer) != 0
+            io << (draw_pixel ? ink_char : blank_char)
+            pointer = pointer >> 1
+          end
+          io << '\n'
+        end
+      end
+
+      def encode
+        if until_y = @pixels.keys.max?
+          return (0..until_y).map { |it| @pixels.fetch it, 0_u8 }
+        end
+        return [0_u8]
+      end
+    end
+  end
+end

src/chalk/table.cr

@@ -1,51 +1,81 @@
+require "./sprite.cr"
+
 module Chalk
-  class Entry
+  module Compiler
-  end
+    # An entry that represents a function in the symbol table.
+    class FunctionEntry
+      # Gets the function stored in this entry.
+      getter function
+      # Gets the address in code of this function.
+      getter addr
+      # Sets the address in code of this function.
+      setter addr
 
-  class FunctionEntry < Entry
+      def initialize(@function : Trees::TreeFunction | Builtin::BuiltinFunction | Builtin::InlineFunction,
-    property function : TreeFunction
+                     @addr = -1)
-    property addr : Int32
+      end
-
+
-    def initialize(@function, @addr = -1)
+      def to_s(io)
-    end
+        io << "[function]"
-
-    def to_s(io)
-      io << "[function]"
-    end
-  end
-
-  class VarEntry < Entry
-    property register : Int32
-
-    def initialize(@register)
-    end
-
-    def to_s(io)
-      io << "[variable] " << "(R" << @register.to_s(16) << ")"
-    end
-  end
-
-  class Table
-    property parent : Table?
-
-    def initialize(@parent = nil)
-      @data = {} of String => Entry
-    end
-
-    def []?(key)
-      if entry = @data[key]?
-        return entry
       end
-      return @parent.try &.[key]?
     end
 
-    def []=(key, entry)
+    # An entry that represents a variable in the symbol table.
-      @data[key] = entry
+    class VarEntry
+      # Gets the register occupied by the variable
+      # in this entry.
+      getter register
+
+      def initialize(@register : Int32)
+      end
+
+      def to_s(io)
+        io << "[variable] " << "(R" << @register.to_s(16) << ")"
+      end
     end
 
-    def to_s(io)
+    class SpriteEntry
-      @parent.try &.to_s(io)
+      property sprite : Sprite
-      io << @data.map { |k, v| k + ": " + v.to_s }.join("\n")
+      property addr : Int32
+
+      def initialize(@sprite, @addr = -1)
+      end
+    end
+
+    # A symbol table.
+    class Table
+      # Gets the parent of this table.
+      getter parent
+      # Gets the functions hash.
+      getter functions
+      # Gets the variables hash.
+      getter vars
+      # Gets the sprites hash.
+      getter sprites
+
+      def initialize(@parent : Table? = nil)
+        @functions = {} of String => FunctionEntry
+        @vars = {} of String => VarEntry
+        @sprites = {} of String => SpriteEntry
+      end
+
+      macro table_functions(name)
+          def get_{{name}}?(key)
+             @{{name}}s[key]? || @parent.try &.get_{{name}}?(key)
+          end
+
+          def set_{{name}}(key, value)
+             @{{name}}s[key] = value
+          end
+      end
+
+      table_functions function
+      table_functions var
+      table_functions sprite
+
+      def to_s(io)
+        @parent.try &.to_s(io)
+      end
     end
   end
 end

src/chalk/tree.cr

@@ -1,224 +1,308 @@
 module Chalk
-  class Visitor
+  module Trees
-    def visit(tree)
+    # A class used to visit nodes of a tree.
-    end
+    class Visitor
-
+      def visit(tree)
-    def finish(tree)
-    end
-  end
-
-  class Transformer
-    def transform(tree)
-      return tree
-    end
-  end
-
-  class Tree
-    def accept(v)
-      v.visit(self)
-      v.finish(self)
-    end
-
-    def apply(t)
-      return t.transform(self)
-    end
-  end
-
-  class TreeId < Tree
-    property id : String
-
-    def initialize(@id)
-    end
-  end
-
-  class TreeLit < Tree
-    property lit : Int64
-
-    def initialize(@lit)
-    end
-  end
-
-  class TreeCall < Tree
-    property name : String
-    property params : Array(Tree)
-
-    def initialize(@name, @params)
-    end
-
-    def accept(v)
-      v.visit(self)
-      @params.each &.accept(v)
-      v.finish(self)
-    end
-
-    def apply(t)
-      @params.map! do |param|
-        param.apply(t)
       end
-      return t.transform(self)
-    end
-  end
 
-  class TreeOp < Tree
+      def finish(tree)
-    property op : TokenType
-    property left : Tree
-    property right : Tree
-
-    def initialize(@op, @left, @right)
-    end
-
-    def accept(v)
-      v.visit(self)
-      @left.accept(v)
-      @right.accept(v)
-      v.finish(self)
-    end
-
-    def apply(t)
-      @left = @left.apply(t)
-      @right = @right.apply(t)
-      return t.transform(self)
-    end
-  end
-
-  class TreeBlock < Tree
-    property children : Array(Tree)
-
-    def initialize(@children)
-    end
-
-    def accept(v)
-      v.visit(self)
-      @children.each &.accept(v)
-      v.finish(self)
-    end
-
-    def apply(t)
-      @children.map! do |child|
-        child.apply(t)
       end
-      return t.transform(self)
-    end
-  end
-
-  class TreeFunction < Tree
-    property name : String
-    property params : Array(String)
-    property block : Tree
-
-    def initialize(@name, @params, @block)
     end
 
-    def accept(v)
+    # A class used to transform a tree, bottom up.
-      v.visit(self)
+    # "Modern Compiler Design" refers to this technique
-      @block.accept(v)
+    # as BURS.
-      v.finish(self)
+    class Transformer
+      def transform(tree)
+        return tree
+      end
     end
 
-    def apply(t)
+    class Reducer(T)
-      @block = @block.apply(t)
+      def reduce(tree, children)
-      return t.transform(self)
+      end
-    end
-  end
-
-  class TreeVar < Tree
-    property name : String
-    property expr : Tree
-
-    def initialize(@name, @expr)
     end
 
-    def accept(v)
+    # The base class of a tree.
-      v.visit(self)
+    class Tree
-      @expr.accept(v)
+      def accept(v)
-      v.finish(self)
+        v.visit(self)
+        v.finish(self)
+      end
+
+      def apply(t)
+        return t.transform(self)
+      end
+
+      def reduce(r : Reducer(T)) forall T
+          return r.reduce(self, [] of T)
+      end
     end
 
-    def apply(t)
+    # A tree that represents an ID.
-      @expr = @expr.apply(t)
+    class TreeId < Tree
-      return t.transform(self)
+      property id : String
-    end
-  end
 
-  class TreeAssign < Tree
+      def initialize(@id)
-    property name : String
+      end
-    property expr : Tree
-
-    def initialize(@name, @expr)
     end
 
-    def accept(v)
+    # A tree that represents an integer literal.
-      v.visit(self)
+    class TreeLit < Tree
-      @expr.accept(v)
+      property lit : Int64
-      v.finish(self)
+
+      def initialize(@lit)
+      end
     end
 
-    def apply(t)
+    # A tree that represents a function call.
-      @expr = @expr.apply(t)
+    class TreeCall < Tree
-      return t.transform(self)
+      property name : String
-    end
+      property params : Array(Tree)
-  end
 
-  class TreeIf < Tree
+      def initialize(@name, @params)
-    property condition : Tree
+      end
-    property block : Tree
-    property otherwise : Tree?
 
-    def initialize(@condition, @block, @otherwise = nil)
+      def accept(v)
+        v.visit(self)
+        @params.each &.accept(v)
+        v.finish(self)
+      end
+
+      def apply(t)
+        @params.map! do |param|
+          param.apply(t)
+        end
+        return t.transform(self)
+      end
+
+      def reduce(r : Reducer(T)) forall T
+          return r.reduce(self, @params.map &.reduce(r))
+      end
     end
 
-    def accept(v)
+    # A tree that represents an operation on two values.
-      v.visit(self)
+    class TreeOp < Tree
-      @condition.accept(v)
+      property op : Compiler::TokenType
-      @block.accept(v)
+      property left : Tree
-      @otherwise.try &.accept(v)
+      property right : Tree
-      v.finish(self)
+
+      def initialize(@op, @left, @right)
+      end
+
+      def accept(v)
+        v.visit(self)
+        @left.accept(v)
+        @right.accept(v)
+        v.finish(self)
+      end
+
+      def apply(t)
+        @left = @left.apply(t)
+        @right = @right.apply(t)
+        return t.transform(self)
+      end
+
+      def reduce(r : Reducer(T)) forall T
+          return r.reduce(self, [@left.reduce(r), @right.reduce(r)])
+      end
     end
 
-    def apply(t)
+    # A tree that represents a block of statements.
-      @condition = @condition.apply(t)
+    class TreeBlock < Tree
-      @block = @block.apply(t)
+      property children : Array(Tree)
-      @otherwise = @otherwise.try &.apply(t)
-      return t.transform(self)
-    end
-  end
 
-  class TreeWhile < Tree
+      def initialize(@children)
-    property condition : Tree
+      end
-    property block : Tree
 
-    def initialize(@condition, @block)
+      def accept(v)
+        v.visit(self)
+        @children.each &.accept(v)
+        v.finish(self)
+      end
+
+      def apply(t)
+        @children.map! do |child|
+          child.apply(t)
+        end
+        return t.transform(self)
+      end
+      def reduce(r : Reducer(T)) forall T
+          return r.reduce(self, @children.map &.reduce(r))
+      end
     end
 
-    def accept(v)
+    # A tree that represents a function declaration.
-      v.visit(self)
+    class TreeFunction < Tree
-      @condition.accept(v)
+      property name : String
-      @block.accept(v)
+      property params : Array(String)
-      v.finish(self)
+      property block : Tree
+      getter type
+
+      def initialize(@name, @params, return_type : Compiler::Type, @block)
+        @type = Compiler::FunctionType.new([Compiler::Type::U8] * @params.size, return_type)
+      end
+
+      def param_count
+        return @params.size
+      end
+
+      def accept(v)
+        v.visit(self)
+        @block.accept(v)
+        v.finish(self)
+      end
+
+      def apply(t)
+        @block = @block.apply(t)
+        return t.transform(self)
+      end
+
+      def reduce(r : Reducer(T)) forall T
+          return r.reduce(self, [@block.reduce(r)])
+      end
     end
 
-    def apply(t)
+    # A tree that represents the declaration of
-      @condition = @condition.apply(t)
+    # a new variable.
-      @block = @block.apply(t)
+    class TreeVar < Tree
-      return t.transform(self)
+      property name : String
-    end
+      property expr : Tree
-  end
 
-  class TreeReturn < Tree
+      def initialize(@name, @expr)
-    property rvalue : Tree
+      end
 
-    def initialize(@rvalue)
+      def accept(v)
+        v.visit(self)
+        @expr.accept(v)
+        v.finish(self)
+      end
+
+      def apply(t)
+        @expr = @expr.apply(t)
+        return t.transform(self)
+      end
+
+      def reduce(r : Reducer(T)) forall T
+        r.reduce(self, [@expr.reduce(r)])
+      end
     end
 
-    def accept(v)
+    # A tree that represents the assignment
-      v.visit(self)
+    # to an existing variable.
-      @rvalue.accept(v)
+    class TreeAssign < Tree
-      v.finish(self)
+      property name : String
+      property expr : Tree
+
+      def initialize(@name, @expr)
+      end
+
+      def accept(v)
+        v.visit(self)
+        @expr.accept(v)
+        v.finish(self)
+      end
+
+      def apply(t)
+        @expr = @expr.apply(t)
+        return t.transform(self)
+      end
+
+      def reduce(r : Reducer(T)) forall T
+        r.reduce(self, [@expr.reduce(r)])
+      end
     end
 
-    def apply(t)
+    # A tree that represents an if statement.
-      @rvalue = @rvalue.apply(t)
+    class TreeIf < Tree
-      return t.transform(self)
+      property condition : Tree
+      property block : Tree
+      property otherwise : Tree?
+
+      def initialize(@condition, @block, @otherwise = nil)
+      end
+
+      def accept(v)
+        v.visit(self)
+        @condition.accept(v)
+        @block.accept(v)
+        @otherwise.try &.accept(v)
+        v.finish(self)
+      end
+
+      def apply(t)
+        @condition = @condition.apply(t)
+        @block = @block.apply(t)
+        @otherwise = @otherwise.try &.apply(t)
+        return t.transform(self)
+      end
+
+      def reduce(r : Reducer(T)) forall T
+          cond = @condition.reduce(r)
+          blk = @block.reduce(r)
+          if other = @otherwise
+              r.reduce(self, [cond, blk,other.reduce(r)])
+          else
+              r.reduce(self, [cond, blk])
+          end
+      end
+    end
+
+    # A tree that represents a while loop.
+    class TreeWhile < Tree
+      property condition : Tree
+      property block : Tree
+
+      def initialize(@condition, @block)
+      end
+
+      def accept(v)
+        v.visit(self)
+        @condition.accept(v)
+        @block.accept(v)
+        v.finish(self)
+      end
+
+      def apply(t)
+        @condition = @condition.apply(t)
+        @block = @block.apply(t)
+        return t.transform(self)
+      end
+
+      def reduce(r : Reducer(T)) forall T
+          r.reduce(self, [@condition.reduce(r), @block.reduce(r)])
+      end
+    end
+
+    # A tree that represents a return statement.
+    class TreeReturn < Tree
+      property rvalue : Tree
+
+      def initialize(@rvalue)
+      end
+
+      def accept(v)
+        v.visit(self)
+        @rvalue.accept(v)
+        v.finish(self)
+      end
+
+      def apply(t)
+        @rvalue = @rvalue.apply(t)
+        return t.transform(self)
+      end
+
+      def reduce(r : Reducer(T)) forall T
+        r.reduce(self, [@rvalue.reduce(r)])
+      end
+    end
+
+    class TreeSprite < Tree
+        property name : String
+        property sprite : Compiler::Sprite
+
+        def initialize(@name, @sprite)
+        end
     end
   end
 end

src/chalk/type.cr

@@ -0,0 +1,35 @@
+module Chalk
+    module Compiler
+        # Possible types of values in chalk
+        enum Type
+            U0
+            U4
+            U8
+            U12
+
+            # Checks if one value can be cast to another.
+            def casts_to?(other)
+                return false if other == Type::U0 || self == Type::U0
+                return other.value >= self.value
+            end
+        end
+
+        # A type of a function.
+        class FunctionType
+            # Gets the types of the function's parameters.
+            getter param_types
+            # Gets the return type of the function.
+            getter return_type
+
+            def initialize(@param_types : Array(Type), @return_type : Type)
+            end
+
+            def to_s(io)
+                io << "("
+                io << param_types.map(&.to_s).join(", ")
+                io << ") -> "
+                return_type.to_s(io)
+            end
+        end
+    end
+end

src/chalk/typecheck.cr

@@ -0,0 +1,58 @@
+require "./type"
+
+module Chalk
+    module Trees
+        # Reducer to check types.
+        class TypeChecker < Reducer(Compiler::Type)
+            def initialize(@table : Compiler::Table, @return_type : Compiler::Type)
+            end
+
+            def reduce(t, children)
+                return Compiler::Type::U0
+            end
+
+            def reduce(t : TreeCall, children)
+                entry = @table.get_function? t.name
+                raise "Unknwon function" unless entry
+                type = entry.function.type
+                raise "Invalid parameters" if type.param_types.size != children.size
+                children.each_with_index do |child, i|
+                    raise "Incompatible parameter" if !child.casts_to?(type.param_types[i])
+                end
+                return entry.function.type.return_type
+            end
+
+            def reduce(t : TreeId, children)
+                return Compiler::Type::U8
+            end
+
+            def reduce(t : TreeLit, children)
+                max_12 = (2 ** 12) - 1
+                max_8 = (2 ** 8) - 1
+                max_4 = (2 ** 4) - 1
+                raise "Number too big" if t.lit > max_12
+                return Compiler::Type::U12 if t.lit > max_8
+                return Compiler::Type::U8 if t.lit > max_4
+                return Compiler::Type::U4
+            end
+
+            def reduce(t : TreeOp, children)
+                left = children[0]
+                right = children[1]
+                return left if right.casts_to?(left)
+                return right if left.casts_to?(right)
+                raise "Invalid operation"
+            end
+
+            def reduce(t : TreeAssign | TreeVar, children)
+                raise "Invalid assignment" if !children[0].casts_to?(Compiler::Type::U8)
+                return Compiler::Type::U0
+            end
+
+            def reduce(t : TreeReturn, children)
+                raise "Incompatible return type" if !children[0].casts_to?(@return_type)
+                return Compiler::Type::U0
+            end
+        end
+    end
+end

src/chalk/ui.cr

@@ -1,51 +0,0 @@
-module Chalk
-  enum OutputMode
-    Tree,
-    Intermediate,
-    Binary
-  end
-
-  class Config
-    property file : String
-    property mode : OutputMode
-
-    def initialize(@file = "",
-                   @mode = OutputMode::Tree)
-    end
-
-    def self.parse!
-      config = self.new
-      OptionParser.parse! do |parser|
-        parser.banner = "Usage: chalk [arguments]"
-        parser.on("-m", "--mode=MODE", "Set the mode of the compiler.") do |mode|
-          case mode.downcase
-          when "tree", "t"
-            config.mode = OutputMode::Tree
-          when "intermediate", "i"
-            config.mode = OutputMode::Intermediate
-          when "binary", "b"
-            config.mode = OutputMode::Binary
-          else
-            puts "Invalid mode type. Using default."
-          end
-        end
-        parser.on("-f", "--file=FILE", "Set the input file to compile.") do |file|
-          config.file = file
-        end
-        parser.on("-h", "--help", "Show this message.") { puts parser }
-      end
-      return config
-    end
-
-    def validate!
-      if file == ""
-        puts "No source file specified."
-        return false
-      elsif !File.exists? file
-        puts "Unable to open source file."
-        return false
-      end
-      return true
-    end
-  end
-end

src/test.cr

@@ -0,0 +1,25 @@
+require "./chalk/*"
+
+module Chalk
+    regex = /([^.]+)\.chalk/
+    source_dir = "programs"
+    dest_dir = "out"
+
+    Dir.mkdir_p dest_dir
+    exit if !File.directory? source_dir
+    Dir.new(source_dir)
+        .children
+        .compact_map { |it| regex.match(it) }
+        .each do |match|
+        config = Ui::Config.new file: (source_dir + File::SEPARATOR + match[0]),
+                                output:  (dest_dir + File::SEPARATOR + match[1] + ".ch8"),
+                                loglevel: Logger::Severity::ERROR,
+                                mode: Ui::OutputMode::Binary
+        compiler = Compiler::Compiler.new config
+        begin
+            compiler.run
+        rescue e
+            puts "Exception compiling #{match[0]}"
+        end
+    end
+end