oryx 0.2.1 → 0.3.1

data/lib/oryx/contractor.rb

@@ -0,0 +1,185 @@
+require_relative "../oryx"
+
+require "rltk/cg/contractor"
+require "rltk/cg/llvm"
+require "rltk/cg/module"
+
+RLTK::CG::LLVM.init(:x86)
+
+module Oryx
+
+  ZERO = RLTK::CG::NativeInt.new(0)
+
+  class Contractor < RLTK::CG::Contractor
+    attr_reader :module, :st
+
+    def initialize
+      super
+      @module = RLTK::CG::Module.new('Oryx JIT')
+      @st = SymbolTable.new
+    end
+
+    def begin ast
+      ast.each {|a| dispatch a}
+    end
+
+    on Function do |node|
+      fun = nil
+      if fun = @module.functions[node.i]
+        raise GenerationError, "Redefinition of function #{node.i}."
+      else
+        st.enter_scope
+        param_types = parameter_types node.params
+        return_type = visit node.return_type
+        fun = @module.functions.add(node.i, return_type, param_types)
+        node.params.params.each {|p| visit p}
+        param_names = parameter_names node.params
+        param_names.each_with_index do |name, i|
+          st.update name.to_sym, fun.params[i]
+        end
+      end
+
+      ret (visit node.body, at: fun.blocks.append('entry'))
+      st.exit_scope
+
+      returning(fun) { fun.verify }
+    end
+
+    on ParamList do |node|
+    end
+
+    on Int do |node|
+      RLTK::CG::NativeIntType
+    end
+
+    on Variable do |node|
+      begin
+        st.lookup node.name.to_sym
+      rescue SymbolTableError => e
+        STDERR.puts e.message, "Attempting to continue without this value."
+      end
+    end
+
+    on CodeBlock do |node|
+      a = node.statements.map {|s| visit s}
+      a.first
+    end
+
+    on Return do |node|
+      result = visit node.right
+      result
+    end
+
+    on Binary do |node|
+      left = visit node.left
+      right = visit node.right
+
+      case node
+      when Add then add(left, right, 'addtmp')
+      when Sub then sub(left, right, 'subtmp')
+      when Mul then mul(left, right, 'multmp')
+      when Div then sdiv(left, right, 'divtmp')
+      when GE  then integer_cast(icmp(:sgt, left, right), RLTK::CG::NativeIntType, 'booltmp')
+      when GEQ then integer_cast(icmp(:sge, left, right), RLTK::CG::NativeIntType, 'booltmp')
+      when LE  then integer_cast(icmp(:slt, left, right), RLTK::CG::NativeIntType, 'booltmp')
+      when LEQ then integer_cast(icmp(:sle, left, right), RLTK::CG::NativeIntType, 'booltmp')
+      when EQ  then integer_cast(icmp(:eq, left, right), RLTK::CG::NativeIntType, 'booltmp')
+      when NEQ then integer_cast(icmp(:ne, left, right), RLTK::CG::NativeIntType, 'booltmp')
+      end
+    end
+
+    on Number do |node|
+      RLTK::CG::NativeInt.new(node.value)
+    end
+
+    on GInitialization do |node|
+      name = node.name.to_sym
+      value = visit node.right
+      begin
+        st.insert(name, value)
+      rescue SymbolTableError => e
+        STDERR.puts e.message, "Continuing processing without modifying the symbol table"
+      end
+    end
+
+    on GDeclaration do |node|
+      name = node.name.to_sym
+      begin
+        st.insert name
+      rescue SymbolTableError => e
+        STDERR.puts e.message, "Continuing processing without modifying the symbol table"
+      end
+    end
+
+    on Declaration do |node|
+      name = node.name.to_sym
+      begin
+        st.insert name
+      rescue SymbolTableError => e
+        STDERR.puts e.message, "Continuing processing without modifying the symbol table"
+      end
+    end
+
+    on Assign do |node|
+      value = visit node.right
+      name = node.name.to_sym
+      begin
+        st.update name, value
+      rescue SymbolTableError => e
+        STDERR.puts e.message, "Continuing processing witout modifying the symbol table"
+      end
+    end
+
+    on Call do |node|
+      callee = @module.functions[node.name]
+      raise GenerationError, "Unknown function referenced" unless callee
+
+      raise GenerationError, "Function #{node.name} expected #{callee.params.size} argument(s) but was called with #{node.args.args.length}." unless callee.params.size == node.args.args.length
+      args = node.args.args.map { |a| visit a }
+      call callee, *args.push('calltmp')
+    end
+
+    on If do |node|
+      cond_val = icmp :ne, (visit node.cond), ZERO, 'ifcond'
+      start_bb = current_block
+      fun = start_bb.parent
+      then_bb = fun.blocks.append('then')
+      then_val, new_then_bb = visit node.then, at: then_bb, rcb: true
+
+      else_bb = fun.blocks.append('else')
+      else_val, new_else_bb = visit node.else, at: else_bb, rcb: true
+
+      merge_bb = fun.blocks.append('merge', self)
+      phi_inst = build(merge_bb) { phi RLTK::CG::NativeIntType, {new_then_bb => then_val, new_else_bb => else_val}, 'iftmp' }
+
+      build(start_bb) { cond cond_val, then_bb, else_bb }
+      build(new_then_bb) { br merge_bb }
+      build(new_else_bb) { br merge_bb }
+      returning(phi_inst) { target merge_bb }
+    end
+
+
+    private
+      def dispatch node
+        case node
+        when Function then visit node
+        when GInitialization then visit node
+        when GDeclaration then visit node
+        when Call then visit node
+        else raise GenerationError "Unhandled node type #{node}"
+        end
+      end
+
+      def parameter_types node
+        node.params.map do |p|
+          t = visit p.type
+        end
+      end
+
+      def parameter_names node
+        node.params.map do |p|
+          t = p.name
+        end
+      end
+  end
+end

data/lib/oryx/error.rb

@@ -0,0 +1,8 @@
+module Oryx
+  class Error < StandardError; end
+
+  class LexError < Error; end
+  class ParseError < Error; end
+  class GenerationError < Error; end
+  class SymbolTableError < Error; end
+end

data/lib/oryx/parser.rb

@@ -27,15 +27,15 @@ module Oryx
     end
 
     production(:vdecl) do
-      clause('type_spec IDENT SEMI') { |t, i, _| Variable.new i}
+      clause('type_spec IDENT SEMI') { |t, i, _| GDeclaration.new i, t}
     end
 
     production(:vinit) do
-      clause('type_spec IDENT ASSIGN constant SEMI') { |t, i, _, c, _| Assign.new i, c}
+      clause('type_spec IDENT ASSIGN constant SEMI') { |t, i, _, c, _| GInitialization.new i, c, t }
     end
 
     production(:fdecl) do
-      clause('type_spec IDENT LPAREN opt_param_list RPAREN code_block') { |t, i, _, opl,  _, c| Function.new i, opl, c }
+      clause('type_spec IDENT LPAREN opt_param_list RPAREN code_block') { |t, i, _, opl,  _, c| Function.new i, opl, c, t }
     end
 
     production(:opt_param_list) do
@@ -49,7 +49,21 @@ module Oryx
     end
 
     production(:param) do
-      clause('type_spec IDENT') { |t, i| Variable.new i }
+      clause('type_spec IDENT') { |t, i| Declaration.new i, t }
+    end
+
+    production(:opt_arg_list) do
+      clause('') { || ArgList.new [] }
+      clause('arg_list') { |al| ArgList.new al}
+    end
+
+    production(:arg_list) do
+      clause('arg') { |a| [a] }
+      clause('arg COMMA arg_list') { |a, _, al| Array(a) + al }
+    end
+
+    production(:arg) do
+      clause('e') { |e| e }
     end
 
     production(:constant) do
@@ -80,12 +94,21 @@ module Oryx
       clause('e SEMI') { |e, _| e }
       clause('if_statement') { |i| i}
       clause('WHILE LPAREN e RPAREN code_block') {|_,_,e,_,c| While.new(e,c) }
+      clause('type_spec IDENT ASSIGN e SEMI')         { |t, e0, _, e1, _| Initialization.new t, e0, e1 }
+      clause('type_spec IDENT SEMI')                  { |t, i, _ | Declaration.new i,t }
     end
 
     production(:if_statement) do
-      clause('IF LPAREN e RPAREN statement') { |_, _, e, _, s| If.new(e, s, nil) }
-      clause('IF LPAREN e RPAREN statement ELSE statement') { |_,_,e,_,ts,_,fs| If.new(e, ts, fs) }
-      clause('IF LPAREN e RPAREN code_block ELSE code_block') {|_,_,e,_,tc,_,fc| If.new(e, tc, fc) }
+      clause('if_preamble statement')                  { |e, s|      If.new(e, s, nil) }
+      clause('if_preamble code_block')                 { |e, c|      If.new(e, c, nil) }
+      clause('if_preamble statement ELSE statement')   { |e,ts,_,fs| If.new(e, ts, fs) }
+      clause('if_preamble code_block ELSE code_block') { |e,tc,_,fc| If.new(e, tc, fc) }
+      clause('if_preamble statement ELSE code_block')  { |e,ts,_,fc| If.new(e, ts, fc) }
+      clause('if_preamble code_block ELSE statement')  { |e,tc,_,fs| If.new(e, tc, fs) }
+    end
+
+    production(:if_preamble) do
+      clause('IF LPAREN e RPAREN') { |_, _, e, _| e }
     end
 
     production(:e) do
@@ -109,6 +132,7 @@ module Oryx
 
       clause('RETURN e')  { |_, e| Return.new e }
 
+      clause('IDENT LPAREN opt_arg_list RPAREN') { |i, _, oal, _| Call.new(i, oal) }
     end
 
     finalize explain: 'explain.out'

data/lib/oryx/runner.rb

@@ -20,7 +20,16 @@ module Oryx
       puts "complete".green
 
       p = Parser.new
-      p.parse(l.lex_file(input_filename.to_s), parse_tree: 'tree.dot', verbose: 'parse.out')
+      ast = p.parse(l.lex_file(input_filename.to_s), parse_tree: 'tree.dot', verbose: 'parse.out')
+
+      c = Contractor.new
+      c.begin ast
+
+      output_ir c.module
+
+      translate_to_assembly
+      create_executable
+
     end
 
     private
@@ -38,6 +47,26 @@ module Oryx
         s
       end
 
+      def base_name
+        input_filename.to_s.split('.').first
+      end
+
+      def output_ir ir_module
+        ir_module.verify
+        orig_stderr = $stderr.clone
+        $stderr.reopen File.new("#{base_name}.ll", "w")
+        ir_module.dump
+        $stderr.reopen orig_stderr
+      end
+
+      def translate_to_assembly
+        `llc -disable-cfi #{base_name}.ll`
+      end
+
+      def create_executable
+        `gcc #{base_name}.s -o #{base_name}.out`
+      end
+
       def table_header
         s = center "TYPE", 10
         s += "|"

data/lib/oryx/symbol_table.rb

@@ -0,0 +1,48 @@
+require_relative '../oryx'
+
+module Oryx
+  class SymbolTable
+    def initialize
+      @values = [{}]
+    end
+
+    def enter_scope
+      values.push Hash.new
+    end
+
+    def exit_scope
+      raise SymbolTableError, "Cannot exit global scope." if current_scope == 0
+      values.pop
+    end
+
+    def lookup variable
+      return values[scope_level_of variable][variable.to_sym]
+    end
+
+    def update variable, value=nil
+      level = scope_level_of variable
+      values[level][variable.to_sym] = value
+    end
+
+    def insert variable, value=nil
+      raise SymbolTableError, "Re-definition of #{variable} not allowed" if values.last.include? variable.to_sym
+
+      values[current_scope][variable.to_sym] = value
+    end
+
+    def current_scope
+      values.length - 1
+    end
+
+    private
+      attr_accessor :values
+
+      def scope_level_of variable
+        values.reverse.each_with_index do |v, i|
+          return current_scope - i if v.include? variable.to_sym
+        end
+
+        raise SymbolTableError, "Variable #{variable} not found in symbol table."
+      end
+  end
+end

data/lib/oryx/version.rb

@@ -1,3 +1,3 @@
 module Oryx
-  VERSION = "0.2.1"
+  VERSION = "0.3.1"
 end

data/lib/oryx.rb

@@ -4,6 +4,9 @@ require "oryx/runner"
 require "oryx/lexer"
 require "oryx/parser"
 require "oryx/ast"
+require "oryx/symbol_table"
+require "oryx/error"
+require "oryx/contractor"
 
 module Oryx
   # Your code goes here...

data/test/data/add.c

@@ -0,0 +1,3 @@
+int main(){
+  return 7 + 5;
+}

data/test/data/div.c

@@ -0,0 +1,3 @@
+int main(){
+  return 15/7;
+}

data/test/data/eq.c

@@ -0,0 +1,6 @@
+int main(){
+  if(5 == 5)
+    return 5;
+  else
+    return 4;
+}

data/test/data/fib.c

@@ -0,0 +1,8 @@
+int fib(int x) {
+  if (x < 2) return 1;
+  else return fib(x-1)+fib(x-2);
+}
+
+int main() {
+  return fib(8);
+}

data/test/data/fun_1.c

@@ -0,0 +1,7 @@
+int fun_1(){
+  return 1;
+}
+
+int main(){
+  return fun_1() + 8;
+}

data/test/data/ge.c

@@ -0,0 +1,6 @@
+int main(){
+  if( 15 > 8)
+    return 7;
+  else
+    return 8;
+}

data/test/data/geq.c

@@ -0,0 +1,6 @@
+int main(){
+  if(15 >= 16)
+    return 7;
+  else
+    return 9;
+}

data/test/data/gvar_1.c

@@ -0,0 +1,5 @@
+int a = 7;
+
+int main(){
+  return a;
+}

data/test/data/gvar_2.c

@@ -0,0 +1,6 @@
+int a = 19;
+int b = 23;
+
+int main(){
+  return a+b;
+}

data/test/data/gvar_3.c

@@ -0,0 +1,6 @@
+int a;
+
+int main(){
+  a = 15;
+  return a;
+}

data/test/data/if.c

@@ -0,0 +1,15 @@
+int a = 8;
+int b = 13;
+
+int main(){
+  if(a < b){
+    a = a + b;
+    b = 1;
+    if (b < a)
+      return b;
+    else
+      return a;
+  }
+  else
+    return a;
+}

data/test/data/le.c

@@ -0,0 +1,6 @@
+int main(){
+  if( 15 < 8 )
+    return 7;
+  else
+    return 8;
+}

data/test/data/leq.c

@@ -0,0 +1,6 @@
+int main(){
+  if( 15 <= 15 )
+    return 15;
+  else
+    return 3;
+}

data/test/data/mul.c

@@ -0,0 +1,3 @@
+int main(){
+  return 25*7;
+}

data/test/data/neq.c

@@ -0,0 +1,6 @@
+int main(){
+  if(5 != 5)
+    return 5;
+  else
+    return 4;
+}

data/test/data/return.c

@@ -0,0 +1,3 @@
+int main(){
+  return 42;
+}

data/test/data/sub.c

@@ -0,0 +1,3 @@
+int main(){
+  return 10-17;
+}

data/test/lib/oryx/error_test.rb

@@ -0,0 +1,19 @@
+require_relative '../../test_helper'
+
+module Oryx
+  class TestError < Test::Unit::TestCase
+    context "Error Hierarchy" do
+      should "be subclasssed from standard error" do
+        assert Error.ancestors.include? StandardError
+      end
+
+      should "be namespaced" do
+        assert Error.name.include? "::"
+      end
+
+      should "have Oryx namespace" do
+        assert_equal Error.name.to_s.split("::").first, "Oryx"
+      end
+    end
+  end
+end

data/test/lib/oryx/runner_test.rb

@@ -0,0 +1,25 @@
+require_relative '../../test_helper'
+
+module Oryx
+  class TestRunner < Test::Unit::TestCase
+    context "test runner with many different files" do
+      should_generate_toolchain_output("return", 42)
+      should_generate_toolchain_output("add", 12)
+      should_generate_toolchain_output("sub", (-7)%256)
+      should_generate_toolchain_output("mul", 175)
+      should_generate_toolchain_output("div", 2)
+      should_generate_toolchain_output("gvar_1", 7)
+      should_generate_toolchain_output("gvar_2", 42)
+      should_generate_toolchain_output("gvar_3", 15)
+      should_generate_toolchain_output("fun_1", 9)
+      should_generate_toolchain_output("ge", 7)
+      should_generate_toolchain_output("le", 8)
+      should_generate_toolchain_output("leq", 15)
+      should_generate_toolchain_output("geq", 9)
+      should_generate_toolchain_output("eq", 5)
+      should_generate_toolchain_output("neq", 4)
+      should_generate_toolchain_output("if", 21)
+      should_generate_toolchain_output("fib", 34)
+    end
+  end
+end