rubex 0.0.1

data/bin/rubex

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require 'rubex'
+
+file_name = ARGV[0]
+if File.exists? file_name
+  file_name = Dir.pwd + "/#{file_name}"
+end
+
+Rubex.compile file_name

data/lib/rubex.rb

@@ -0,0 +1,56 @@
+require 'rubex/code_writer'
+require 'rubex/data_type'
+require 'rubex/constants'
+require 'rubex/ast'
+require 'rubex/symbol_table'
+require 'rubex/parser.racc.rb'
+
+module Rubex
+  class << self
+    def compile path, test=false
+      tree = ast path
+      target_name = extract_target_name path
+      code = generate_code tree, target_name
+      ext = extconf target_name
+      
+      return [code, ext] if test
+      write_files target_name, code, ext
+    end
+
+    def ast path
+      parser = Rubex::Parser.new
+      parser.parse(path)
+      parser.do_parse
+    end
+
+    def extconf target_name, dir=nil
+      extconf = ""
+      extconf << "require 'mkmf'\n"
+      extconf << "create_makefile('#{target_name}/#{target_name}')\n"
+      extconf
+    end
+
+    def generate_code tree, target_name
+      code = Rubex::CodeWriter.new target_name
+      raise "Must be a Rubex::AST::Node, not #{tree.class}" unless 
+        tree.is_a? Rubex::AST::Node
+      tree.process_statements target_name, code
+      code
+    end
+
+    def extract_target_name path
+      File.basename(path).split('.')[0]      
+    end
+
+    def write_files target_name, code, ext
+      Dir.mkdir(target_name)
+      code_file = File.new "#{target_name}/#{target_name}.c", "w+"
+      code_file.puts code.to_s
+      code_file.close
+
+      extconf_file = File.new "#{target_name}/extconf.rb", "w+"
+      extconf_file.puts ext
+      extconf_file.close
+    end
+  end
+end

data/lib/rubex/ast.rb

@@ -0,0 +1,6 @@
+require 'rubex/ast/node'
+require 'rubex/ast/ruby_method_def'
+require 'rubex/ast/c_base_type'
+require 'rubex/ast/argument_list'
+require 'rubex/ast/statement'
+require 'rubex/ast/expression'

data/lib/rubex/ast/argument_list.rb

@@ -0,0 +1,20 @@
+module Rubex
+  module AST
+    class ArgumentList
+      include Enumerable
+      attr_reader :args
+
+      def each &block
+        @args.each(&block)
+      end
+
+      def initialize
+        @args = []
+      end
+
+      def push arg
+        @args << arg
+      end
+    end
+  end
+end

data/lib/rubex/ast/c_base_type.rb

@@ -0,0 +1,11 @@
+module Rubex
+  module AST
+    class CBaseType
+      attr_reader :type, :name
+
+      def initialize type, name
+        @type, @name = type, name
+      end
+    end
+  end
+end

data/lib/rubex/ast/expression.rb

@@ -0,0 +1,13 @@
+module Rubex
+  module AST
+    class Expression
+      class Addition
+        attr_reader :left, :right
+
+        def initialize left, right
+          @left, @right = left, right
+        end
+      end
+    end
+  end
+end

data/lib/rubex/ast/node.rb

@@ -0,0 +1,71 @@
+module Rubex
+  module AST
+    class Node
+      attr_reader :statements
+
+      def initialize statements
+        @statements = statements.is_a?(Array) ? statements : [statements]
+      end
+
+      def add_child child
+        @statements.concat child
+      end
+
+      def process_statements target_name, code
+        @scope = Rubex::SymbolTable::Scope::Klass.new 'Object'
+        generate_symbol_table_entries
+        analyse_expressions
+        generate_preamble code
+        generate_code code
+        generate_init_method target_name, code
+      end
+
+      # Pretty print the AST
+      def pp
+        # TODO
+      end
+
+     private
+
+      def generate_preamble code
+        code << "#include <ruby.h>\n"
+        code << "#include <stdint.h>\n"
+        code << "\n"
+      end
+
+      def generate_symbol_table_entries
+        @statements.each do |stat|
+          stat.generate_symbol_table_entries @scope
+        end
+      end
+
+      def analyse_expressions
+        @statements.each do |stat|
+          stat.analyse_expressions @scope
+        end
+      end
+
+      def generate_code code
+        @statements.each do |stat|
+          stat.generate_code code
+        end
+      end
+
+      def generate_init_method target_name, code
+        name = "Init_#{target_name}"
+        code.new_line
+        code.write_func_declaration "void", name, "void"
+        code.write_func_definition_header "void", name, "void"
+
+        @statements.each do |stat|
+          if stat.is_a? Rubex::AST::RubyMethodDef
+            code.define_instance_method_under @scope, stat.name, stat.c_name
+          end
+        end
+
+        code << "\n"
+        code << "}\n"
+      end
+    end
+  end
+end

data/lib/rubex/ast/ruby_method_def.rb

@@ -0,0 +1,84 @@
+module Rubex
+  module AST
+    class RubyMethodDef
+      # Ruby name of the method.
+      attr_reader :name
+      # The equivalent C name of the method.
+      attr_reader :c_name
+      # Method arguments.
+      attr_reader :args
+      # The statments/expressions contained within the method.
+      attr_reader :statements
+      # Symbol Table entry.
+      attr_reader :entry
+      # Return type of the function.
+      attr_reader :return_type
+      
+      def initialize name, args
+        @name, @args = name, args
+        @c_name = Rubex::FUNC_PREFIX + name
+        @statements = []
+        @return_type = Rubex::DataType::RubyObject.new
+      end
+
+      def add_statements statements
+        statements.each { |s| @statements << s }
+      end
+
+      def generate_symbol_table_entries outer_scope
+        @scope = Rubex::SymbolTable::Scope::Local.new
+        @scope.outer_scope = outer_scope
+        @scope.return_type = @return_type.dup
+        @scope.declare_args @args
+      end
+
+      def analyse_expressions outer_scope
+        @statements.each do |stat|
+          stat.analyse_expression @scope
+        end
+      end
+
+      def generate_code code
+        code.write_func_declaration @return_type.to_s, @c_name
+        code.write_func_definition_header @return_type.to_s, @c_name
+        generate_function_definition code
+        code << "}"
+      end
+
+    private
+
+      def generate_function_definition code
+        declare_args code
+        generate_arg_checking code
+        init_args code
+        generate_statements code
+      end
+
+      def generate_statements code
+        @statements.each do |stat|
+          stat.generate_code code, @scope
+        end
+      end
+
+      def declare_args code
+        @scope.arg_entries.each do |arg|
+          code.declare_variable arg
+        end
+      end
+
+      def init_args code
+        @scope.arg_entries.each_with_index do |arg, i|
+          code << arg.c_name + '=' + arg.type.from_ruby_function + '(' + 
+            'argv[' + i.to_s + ']);' + "\n"
+        end
+      end
+
+      def generate_arg_checking code
+        code << 'if (argc != ' + @scope.arg_entries.size.to_s + ")\n"
+        code << "{\n"
+        code << %Q{rb_raise(rb_eArgError, "Need #{@scope.arg_entries.size} args, not %d", argc);\n}
+        code << "}\n"
+      end
+    end
+  end
+end

data/lib/rubex/ast/statement.rb

@@ -0,0 +1,54 @@
+module Rubex
+  module AST
+    class Statement
+      class Return
+        attr_reader :expression, :return_type
+
+        def initialize expression
+          @expression = expression
+        end
+
+        def analyse_expression local_scope
+          case @expression
+          when Rubex::AST::Expression::Addition
+            left  = @expression.left
+            right = @expression.right
+          end
+
+          left_type = local_scope[left].type
+          right_type = local_scope[right].type
+
+          @return_type = result_type_for left_type, right_type
+          # TODO: Raise error if return_type is not compatible with the return
+          # type of the function.
+        end
+
+        def generate_code code, local_scope
+          code << "return "
+          case @expression
+          when Rubex::AST::Expression::Addition
+            left  = @expression.left
+            right = @expression.right
+            code << @return_type.to_ruby_function
+            code << "("
+            code << local_scope[left].c_name
+            code << " + "
+            code << local_scope[right].c_name
+            code << ")"
+            code << ";\n"
+          end
+        end
+
+       private
+
+        def result_type_for left_type, right_type
+          dtype = Rubex::DataType
+
+          if left_type.is_a?(dtype::CInt32) && right_type.is_a?(dtype::CInt32)
+            return dtype::CInt32.new
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubex/code_writer.rb

@@ -0,0 +1,67 @@
+module Rubex
+  class CodeWriter
+    attr_reader :code
+
+    def initialize target_name
+      @code = "/* C extension for #{target_name}.\n"\
+                 "This file in generated by Rubex. Do not change!\n"\
+               "*/\n"
+      @indent = 0
+    end
+
+    def write_func_declaration return_type, c_name, args=""
+      write_func_prototype return_type, c_name, args
+      @code << ";"
+      new_line
+    end
+
+    def write_func_definition_header return_type, c_name, args=""
+      write_func_prototype return_type, c_name, args
+      @code << "\n"
+      @code << "{\n"
+    end
+
+    def declare_variable var
+      @code << "#{var.type.to_s} #{var.c_name};\n"
+    end
+    
+    def << s
+      @code << s
+    end
+
+    def new_line
+      @code << "\n"
+    end
+
+    def indent
+      @indent += 1
+    end
+
+    def dedent
+      raise "Cannot dedent, already 0." if @indent == 0
+      @indent -= 1
+    end
+
+    def define_instance_method_under scope, name, c_name
+      @code << "rb_define_method(" + scope.c_name + " ,\"" + name + "\", " + 
+        c_name + ", -1);\n"
+    end
+
+    def to_s
+      @code
+    end
+
+  private
+
+    def write_func_prototype return_type, c_name, args
+      @code << "#{return_type} #{c_name} "
+      @code << "("
+      if args.empty?
+        @code << "int argc, VALUE* argv, VALUE #{Rubex::ARG_PREFIX}self"
+      else
+        @code << args
+      end
+      @code << ")"      
+    end
+  end
+end

data/lib/rubex/constants.rb

@@ -0,0 +1,17 @@
+module Rubex
+  RUBEX_PREFIX = "__rubex_"
+
+  FUNC_PREFIX = RUBEX_PREFIX + "f_"
+  VAR_PREFIX  = RUBEX_PREFIX + "v_"
+  CLASS_PREFIX = RUBEX_PREFIX + "c_"
+  ARG_PREFIX = RUBEX_PREFIX + "arg_"
+
+  TYPE_MAPPINGS = {
+    'i32' => Rubex::DataType::CInt32,
+    'object' => Rubex::DataType::RubyObject
+  }
+
+  CLASS_MAPPINGS = {
+    'Object' => 'rb_cObject'
+  }
+end

data/lib/rubex/data_type.rb

@@ -0,0 +1,15 @@
+module Rubex
+  module DataType
+    class RubyObject
+      def to_s; "VALUE"; end
+    end
+
+    class CInt32
+      def to_s; "int32_t"; end
+
+      def to_ruby_function; "INT2NUM"; end
+
+      def from_ruby_function; "NUM2INT"; end
+    end
+  end
+end

data/lib/rubex/lexer.rex

@@ -0,0 +1,50 @@
+class Rubex::Lexer
+macros
+  DEF             /def/
+  RETURN          /return/
+
+  IDENTIFIER      /[a-z_][a-zA-Z_0-9]*/
+  LPAREN          /\(/
+  RPAREN          /\)/
+  NL              /\n/
+  COMMA           /,/
+
+  # operators
+  EXPO            /\*\*/
+  MULTIPLY        /\*/
+  DIVIDE          /\//
+  PLUS            /\+/
+  MINUS           /\-/
+  MODULUS         /%/
+  EQUAL           /=/
+rules
+  /#{DEF}/  { [:kDEF, text] }
+  /end/  { [:kEND, text]  }
+  /#{RETURN}/ { [:kRETURN, text] }
+
+  /i32/           { [:kDTYPE_I32, text] }
+
+  /#{IDENTIFIER}/ { [:tIDENTIFIER, text] }
+  /#{LPAREN}/     { [:tLPAREN, text] }
+  /#{RPAREN}/     { [:tRPAREN, text] }
+  /#{NL}/         { [:tNL, text] }
+  /#{COMMA}/      { [:tCOMMA, text] }
+
+  # operators
+
+  /#{PLUS}/       { [:tPLUS, text]}
+  /#{MINUS}/      { [:tMINUS, text]}
+  /#{MULTIPLY}/   { [:tMULTIPLY, text]}
+  /#{DIVIDE}/     { [:tDIVIDE, text]}
+  /#{EXPO}/       { [:tEXPO, text]}
+  /#{MODULUS}/    { [:tMODULUS, text]}
+  /#{EXPO}/       { [:tEXPO, text]}
+
+  # whitespace
+
+  / /             {}
+inner
+  def do_parse
+    # this is a stub since oedipus lex uses this internally.
+  end
+end # Rubex::Lexer