rubex 0.1 → 0.1.1

data/lib/rubex/ast/statement/if_block/elsif.rb

@@ -0,0 +1,22 @@
+require_relative 'helper'
+module Rubex
+  module AST
+    module Statement
+      class IfBlock < Base
+        class Elsif < Base
+          attr_reader :expr, :statements, :if_tail
+          include Rubex::AST::Statement::IfBlock::Helper
+
+          def initialize(expr, statements, if_tail, location)
+            super(location)
+            @expr = expr
+            @statements = statements
+            @if_tail = if_tail
+          end
+
+          def generate_code(code, local_scope); end
+        end
+      end
+    end
+  end
+end

data/lib/rubex/ast/statement/if_block/helper.rb

@@ -0,0 +1,38 @@
+module Rubex
+  module AST
+    module Statement
+      class IfBlock < Base
+        module Helper
+          def analyse_statement(local_scope)
+            @statements.each do |stat|
+              stat.analyse_statement local_scope
+            end
+
+            @if_tail&.analyse_statement(local_scope)
+          end
+
+          def generate_code_for_statement(stat, code, local_scope, node)
+            if stat != 'else'
+              condition = node.expr.c_code(local_scope)
+              expr_condition = node.expr.type.object? ? "RTEST(#{condition})" : condition
+              code << "#{stat} (#{expr_condition}) "
+            else
+              code << stat.to_s
+            end
+
+            code.block do
+              node.statements.each do |stat|
+                stat.generate_code code, local_scope
+                code.nl
+              end
+            end
+
+            if stat != 'else'
+              node.if_tail&.generate_code(code, local_scope)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubex/ast/statement/print.rb

@@ -0,0 +1,49 @@
+module Rubex
+  module AST
+    module Statement
+      class Print < Base
+        def initialize(expressions, location)
+          super(location)
+          @expressions = expressions
+        end
+
+        def analyse_statement(local_scope)
+          @expressions.each do |expr|
+            expr.analyse_types local_scope
+            expr.allocate_temps local_scope
+            expr.release_temps local_scope
+          end
+        end
+
+        def generate_code(code, local_scope)
+          super
+          @expressions.each do |expr|
+            expr.generate_evaluation_code code, local_scope
+
+            str = 'printf('
+            str << "\"#{expr.type.p_formatter}\""
+            str << ", #{inspected_expr(expr, local_scope)}"
+            str << ');'
+            code << str
+            code.nl
+
+            expr.generate_disposal_code code
+          end
+
+          code.nl
+        end
+
+        private
+
+        def inspected_expr(expr, local_scope)
+          obj = expr.c_code(local_scope)
+          if expr.type.object?
+            "RSTRING_PTR(rb_funcall(#{obj}, rb_intern(\"inspect\"), 0, NULL))"
+          else
+            obj
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubex/ast/statement/raise.rb

@@ -0,0 +1,66 @@
+module Rubex
+  module AST
+    module Statement
+      class Raise < Base
+        def initialize(args)
+          @args = args
+        end
+
+        def analyse_statement(local_scope)
+          @args.analyse_types local_scope
+          @args.allocate_temps local_scope
+          @args.release_temps local_scope
+          unless @args.empty? || @args[0].is_a?(AST::Expression::Name) ||
+                 @args[0].is_a?(AST::Expression::Literal::StringLit)
+            raise Rubex::TypeMismatchError, "Wrong argument list #{@args.inspect} for raise."
+          end
+        end
+
+        def generate_code(code, local_scope)
+          @args.generate_evaluation_code code, local_scope
+          str = ''
+          str << 'rb_raise('
+
+          if @args[0].is_a?(AST::Expression::Name)
+            str << @args[0].c_code(local_scope) + ','
+            args = @args[1..-1]
+          else
+            str << Rubex::DEFAULT_CLASS_MAPPINGS['RuntimeError'] + ','
+            args = @args
+          end
+
+          unless args.empty?
+            str << "\"#{prepare_format_string(args)}\" ,"
+            str << args.map { |arg| (inspected_expr(arg, local_scope)).to_s }.join(',')
+          else
+            str << '""'
+          end
+          str << ');'
+          code << str
+          code.nl
+          @args.generate_disposal_code code
+        end
+
+        private
+
+        def prepare_format_string(args)
+          format_string = ''
+          args.each do |expr|
+            format_string << expr.type.p_formatter
+          end
+
+          format_string
+        end
+
+        def inspected_expr(expr, local_scope)
+          obj = expr.c_code(local_scope)
+          if expr.type.object?
+            "RSTRING_PTR(rb_funcall(#{obj}, rb_intern(\"inspect\"), 0, NULL))"
+          else
+            obj
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubex/ast/statement/return.rb

@@ -0,0 +1,45 @@
+module Rubex
+  module AST
+    module Statement
+      class Return < Base
+        def initialize(expression, location)
+          super(location)
+          @expression = expression
+        end
+
+        def analyse_statement(local_scope)
+          unless @expression
+            if local_scope.type.ruby_method?
+              @expression = Rubex::AST::Expression::Literal::Nil.new 'Qnil'
+            elsif local_scope.type.c_function?
+              @expression = Rubex::AST::Expression::Empty.new
+            end # FIXME: print a warning for type mismatch if none of above
+          end
+
+          @expression.analyse_types local_scope
+          @expression.allocate_temps local_scope
+          @expression.release_temps local_scope
+          t = @expression.type
+
+          @type =
+            if t.c_function? || t.alias_type?
+              t.type
+            else
+              t
+            end
+          @expression = @expression.to_ruby_object if local_scope.type.type.object?
+
+          # TODO: Raise error if type as inferred from the
+          # is not compatible with the return statement type.
+        end
+
+        def generate_code(code, local_scope)
+          super
+          @expression.generate_evaluation_code code, local_scope
+          code << "return #{@expression.c_code(local_scope)};"
+          code.nl
+        end
+      end
+    end
+  end
+end

data/lib/rubex/ast/statement/var_decl.rb

@@ -0,0 +1,49 @@
+module Rubex
+  module AST
+    module Statement
+      class VarDecl < Base
+        attr_reader :type, :value
+
+        def initialize(type, name, value, location)
+          super(location)
+          @name = name
+          @value = value
+          @type = type
+        end
+
+        def analyse_statement(local_scope, extern: false)
+          # TODO: Have type checks for knowing if correct literal assignment
+          # is taking place. For example, a char should not be assigned a float.
+          @type = Helpers.determine_dtype @type, ''
+          c_name = extern ? @name : Rubex::VAR_PREFIX + @name
+          if @value
+            @value.analyse_for_target_type(@type, local_scope)
+            @value.allocate_temps local_scope
+            @value = Helpers.to_lhs_type(self, @value)
+            @value.release_temps local_scope
+          end
+
+          local_scope.declare_var name: @name, c_name: c_name, type: @type,
+                                  value: @value, extern: extern
+        end
+
+        def rescan_declarations(scope)
+          if @type.is_a? String
+            @type = Rubex::CUSTOM_TYPES[@type]
+            scope[@name].type = @type
+          end
+        end
+
+        def generate_code(code, local_scope)
+          if @value
+            @value.generate_evaluation_code code, local_scope
+            lhs = local_scope.find(@name).c_name
+            code << "#{lhs} = #{@value.c_code(local_scope)};"
+            code.nl
+            @value.generate_disposal_code code
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubex/ast/statement/while.rb

@@ -0,0 +1,34 @@
+module Rubex
+  module AST
+    module Statement
+      class While < Base
+        def initialize(expr, statements, location)
+          super(location)
+          @expr = expr
+          @statements = statements
+        end
+
+        def analyse_statement(local_scope)
+          @expr.analyse_types local_scope
+          @expr.release_temps local_scope
+          @statements.each do |stat|
+            stat.analyse_statement local_scope
+          end
+          @expr.release_temps local_scope
+        end
+
+        def generate_code(code, local_scope)
+          @expr.generate_evaluation_code code, local_scope
+          stmt = "while (#{@expr.c_code(local_scope)})"
+          code << stmt
+          code.block do
+            @statements.each do |stat|
+              stat.generate_code code, local_scope
+            end
+          end
+          @expr.generate_disposal_code code
+        end
+      end
+    end
+  end
+end

data/lib/rubex/ast/statement/yield.rb

@@ -0,0 +1,41 @@
+module Rubex
+  module AST
+    module Statement
+      class Yield < Base
+        def initialize(args)
+          @args = args
+        end
+
+        def analyse_statement(local_scope)
+          @args = @args.map do |arg|
+            arg.analyse_types local_scope
+            arg.allocate_temps local_scope
+            arg.to_ruby_object
+          end
+          @args.each do |arg|
+            arg.release_temps local_scope
+          end
+        end
+
+        def generate_code(code, local_scope)
+          @args.each do |a|
+            a.generate_evaluation_code code, local_scope
+          end
+
+          if !@args.empty?
+            code << "rb_yield_values(#{@args.size}, "
+            code << (@args.map { |a| a.c_code(local_scope) }.join(',')).to_s
+            code << ');'
+          else
+            code << 'rb_yield(Qnil);'
+          end
+          code.nl
+
+          @args.each do |a|
+            a.generate_disposal_code code
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubex/ast/top_statement.rb

@@ -1,815 +1 @@
-module Rubex
-  module AST
-    module TopStatement
-      class CBindings
-        attr_reader :lib, :declarations, :location
-
-        def initialize lib, comp_opts, declarations, location
-          @lib, @comp_opts, @declarations, @location = lib, comp_opts, 
-            declarations, location
-        end
-
-        def analyse_statement local_scope
-          unless @declarations
-            @declarations = []
-            load_predecided_declarations
-          end
-          @declarations.each do |stat|
-            stat.analyse_statement local_scope, extern: true
-          end
-          local_scope.include_files.push @lib
-          update_compiler_config
-        end
-
-        def generate_code code
-
-        end
-
-      private
-        def update_compiler_config
-          @comp_opts.each do |h|
-            if h[:link]
-              Rubex::Compiler::CONFIG.add_link h[:link]
-            end
-          end
-        end
-
-        def load_predecided_declarations
-          if @lib == 'rubex/ruby'
-            load_ruby_functions_and_types
-            @lib = '<ruby.h>'
-          elsif @lib == 'rubex/ruby/encoding'
-            load_ruby_encoding_functions_and_type
-            @lib = '<ruby/encoding.h>'
-          elsif @lib == 'rubex/stdlib'
-            load_stdlib_functions_and_types
-            @lib = '<stdlib.h>'
-          else
-            raise Rubex::LibraryNotFoundError, "Cannot find #{@lib}."
-          end
-        end
-
-        def load_ruby_functions_and_types
-          @declarations << xmalloc
-          @declarations << xfree
-          @declarations << type_get
-          @declarations.concat type_identifiers
-          @declarations << rb_str_new
-          @declarations << rb_ary_includes
-        end
-
-        def load_ruby_encoding_functions_and_type
-          @declarations << rb_enc_associate_index
-          @declarations << rb_enc_find_index
-        end
-
-        def load_stdlib_functions_and_types
-          @declarations.concat atox_functions
-        end
-
-        def rb_ary_includes
-          cfunc_decl('object', '', 'rb_ary_includes', 
-            arg_list([arg('object', '','ary'), arg('object', '','item')]))
-        end
-
-        def atox_functions
-          [
-            ['int', 'atoi'], ['long', 'atol'], ['long long', 'atoll'],
-            ['double', 'atof']
-          ].map do |type, ident|
-            cfunc_decl(type, '', ident, arg_list([arg('char', '*', 'str')]))
-          end
-        end
-
-        def rb_enc_find_index
-          cfunc_decl('int', '', 'rb_enc_find_index', 
-            arg_list([arg('char', '*', 'enc')]))
-        end
-
-        def rb_enc_associate_index
-          args = arg_list([arg('object', '', 'string'), arg('int', '', 'enc')])
-          cfunc_decl('object', '', 'rb_enc_associate_index', args)
-        end
-
-        def rb_str_new
-          args = arg_list([arg('char', '*', 'str'), arg('long', '', 'length')])
-          cfunc_decl('object', '', 'rb_str_new', args)
-        end
-
-        def type_get
-          cfunc_decl('int', '', 'TYPE', arg_list([arg('object', '', 'dummy')]))
-        end
-
-        def type_identifiers
-          stmts = [
-            'T_ARRAY', 'T_NIL', 'T_TRUE', 'T_FALSE', 'T_FLOAT', 'T_FIXNUM',
-            'T_BIGNUM', 'T_REGEXP', 'T_STRING'
-          ].map do |ident|
-            Statement::VarDecl.new('int', ident, nil, @location)
-          end
-
-          stmts
-        end
-
-        def xmalloc
-          args = Statement::ArgumentList.new([
-            Expression::ArgDeclaration.new({ 
-              dtype: 'size_t', variables: [{ident: 'dummy'}] })
-          ])
-          Statement::CFunctionDecl.new('void', '*', 'xmalloc', args)  
-        end
-
-        def xfree
-          cfunc_decl 'void', '', 'xfree', arg_list([arg('void', '*', 'dummy')])
-        end
-
-      private
-
-        def arg type, ptr_level, ident
-          Expression::ArgDeclaration.new({
-            dtype: type, variables: [{ ident: ident, ptr_level: ptr_level }]
-            })
-        end
-
-        def cfunc_decl return_type, return_ptr_level, ident, args
-          Statement::CFunctionDecl.new(return_type, return_ptr_level, ident, args)
-        end
-
-        def arg_list args
-          Statement::ArgumentList.new args
-        end
-      end # class CBindings
-
-      class MethodDef
-        include Rubex::Helpers::Writers
-        # Ruby name of the method.
-        attr_reader :name
-        # Method arguments. Accessor because arguments need to be modified in
-        # case of auxillary C functions of attach classes.
-        attr_accessor :arg_list
-        # The statments/expressions contained within the method.
-        attr_reader :statements
-        # Symbol Table entry.
-        attr_reader :entry
-        # Instance of Scope::Local for this method.
-        attr_reader :scope
-        # Variable name that identifies 'self'
-        attr_reader :self_name
-
-        def initialize name, arg_list, statements
-          @name, @arg_list, @statements = name, arg_list, statements
-          @self_name = Rubex::ARG_PREFIX + "self"
-        end
-
-        def analyse_statement outer_scope
-          @entry = outer_scope.find @name
-          @scope = @entry.type.scope
-          @scope.type = @entry.type
-          @scope.self_name = @self_name
-          @arg_list = @entry.type.arg_list
-          @statements.each do |stat|
-            stat.analyse_statement @scope
-          end
-        end
-
-        # Option c_function - When set to true, certain code that is not required
-        #   for Ruby methods will be generated too.
-        def generate_code code, c_function: false
-          code.block do
-            generate_function_definition code, c_function: c_function
-          end
-        end
-
-        def rescan_declarations scope
-          @statements.each do |stat|
-            stat.respond_to?(:rescan_declarations) and
-            stat.rescan_declarations(@scope)
-          end
-        end
-
-      private
-        def generate_function_definition code, c_function:
-          declare_types code, @scope
-          declare_args code unless c_function
-          declare_vars code, @scope
-          declare_carrays code, @scope
-          declare_ruby_objects code, @scope
-          declare_temps code, @scope
-          generate_arg_checking code unless c_function
-          init_args code unless c_function
-          declare_carrays_using_init_var_value code
-          generate_statements code
-        end
-
-        def declare_args code
-          @scope.arg_entries.each do |arg|
-            code.declare_variable type: arg.type.to_s, c_name: arg.c_name
-          end
-        end
-
-        def generate_statements code
-          @statements.each do |stat|
-            stat.generate_code code, @scope
-          end
-        end
-
-        def init_args code
-          @scope.arg_entries.each_with_index do |arg, i|
-            code << arg.c_name + '=' + arg.type.from_ruby_object("argv[#{i}]") + ';'
-            code.nl
-          end
-        end
-
-        def declare_carrays_using_init_var_value code
-          @scope.carray_entries.select { |s|
-            !s.type.dimension.is_a?(Rubex::AST::Expression::Literal::Base)
-          }. each do |arr|
-            type = arr.type.type.to_s
-            c_name = arr.c_name
-            dimension = arr.type.dimension.c_code(@scope)
-            value = arr.value.map { |a| a.c_code(@scope) } if arr.value
-            code.declare_carray(type: type, c_name: c_name, dimension: dimension,
-              value: value)
-          end
-        end
-
-        def generate_arg_checking code
-          code << 'if (argc < ' + @scope.arg_entries.size.to_s + ")"
-          code.block do
-            code << %Q{rb_raise(rb_eArgError, "Need #{@scope.arg_entries.size} args, not %d", argc);\n}
-          end
-        end
-      end
-
-      class RubyMethodDef < MethodDef
-        attr_reader :singleton
-
-        def initialize name, arg_list, statements, singleton: false
-          super(name, arg_list, statements)
-          @singleton = singleton
-        end
-
-        def analyse_statement local_scope
-          super
-          @entry.singleton = @singleton
-        end
-
-        def generate_code code
-          code.write_ruby_method_header(type: @entry.type.type.to_s,
-            c_name: @entry.c_name)
-          super
-        end
-
-        def == other
-          self.class == other.class && @name == other.name &&
-          @c_name == other.c_name && @arg_list == other.arg_list &&
-          @statements == other.statements && @entry == other.entry &&
-          @type == other.type
-        end
-      end # class RubyMethodDef
-
-      class CFunctionDef < MethodDef
-        attr_reader :type, :return_ptr_level
-
-        def initialize type, return_ptr_level, name, arg_list, statements
-          super(name, arg_list, statements)
-          @type = type
-          @return_ptr_level = return_ptr_level
-        end
-
-        def analyse_statement outer_scope, extern: false
-          super(outer_scope)
-        end
-
-        def generate_code code
-          code.write_c_method_header(type: @entry.type.type.to_s, 
-            c_name: @entry.c_name, args: Helpers.create_arg_arrays(@arg_list))
-          super code, c_function: true
-        end
-      end # class CFunctionDef
-
-      class Klass
-        include Rubex::Helpers::Writers
-        # Stores the scope of the class. Rubex::SymbolTable::Scope::Klass.
-        attr_reader :scope
-
-        attr_reader :name
-
-        attr_reader :ancestor
-
-        attr_reader :statements
-
-        attr_reader :entry
-
-        # Name of the class. Ancestor can be Scope::Klass or String object 
-        #   depending on whether invoker is another higher level scope or
-        #   the parser. Statements are the statements inside the class.
-        def initialize name, ancestor, statements
-          @name, @ancestor, @statements = name, ancestor, statements
-          @ancestor = 'Object' if @ancestor.nil?
-        end
-
-        def analyse_statement local_scope, attach_klass: false
-          @entry = local_scope.find(@name)
-          @scope = @entry.type.scope
-          @ancestor = @entry.type.ancestor
-          add_statement_symbols_to_symbol_table
-          if !attach_klass
-            @statements.each do |stat|
-              stat.analyse_statement @scope
-            end
-          end
-        end
-
-        def rescan_declarations local_scope
-          @statements.each do |stat|
-            stat&.rescan_declarations(@scope)
-          end
-        end
-
-        def generate_code code
-          @scope.begin_block_callbacks.each do |cb|
-            cb.generate_code code
-          end
-
-          @statements.each do |stat|
-            stat.generate_code code
-          end
-        end
-
-      protected
-
-        def add_statement_symbols_to_symbol_table
-          @statements.each do |stmt|
-            if ruby_method_or_c_function?(stmt)
-              f_name, f_scope = prepare_name_and_scope_of_functions(stmt)
-              if !auxillary_c_function_for_attached_klass?(f_name)
-                stmt.arg_list.analyse_statement(f_scope)
-                if stmt.is_a? Rubex::AST::TopStatement::RubyMethodDef
-                  add_ruby_method_to_scope f_name, f_scope, stmt.arg_list
-                elsif stmt.is_a? Rubex::AST::TopStatement::CFunctionDef
-                  return_type = Helpers.determine_dtype(stmt.type, stmt.return_ptr_level)
-                  add_c_function_to_scope f_name, f_scope, stmt.arg_list, return_type
-                end
-              end
-            end
-          end
-        end
-
-        def auxillary_c_function_for_attached_klass? f_name
-          self.is_a?(AttachedKlass) and [
-            Rubex::ALLOC_FUNC_NAME, Rubex::DEALLOC_FUNC_NAME, 
-            Rubex::MEMCOUNT_FUNC_NAME, Rubex::GET_STRUCT_FUNC_NAME
-          ].include?(f_name)
-        end
-
-        def add_c_function_to_scope f_name, f_scope, arg_list, return_type
-          c_name = c_func_c_name(f_name)
-          arg_list.each do |arg|
-            if arg.entry.value
-              e = arg.entry
-              e.value = Rubex::Helpers.to_lhs_type(e, e.value)
-            end
-          end
-          @scope.add_c_method(
-            name: f_name, 
-            c_name: c_name, 
-            extern: false,
-            return_type: return_type,
-            arg_list: arg_list,
-            scope: f_scope
-          )
-        end
-
-        def add_ruby_method_to_scope f_name, f_scope, arg_list
-          c_name = Rubex::RUBY_FUNC_PREFIX + @name + "_" +
-            f_name.gsub("?", "_qmark").gsub("!", "_bang")
-          @scope.add_ruby_method(
-            name: f_name,
-            c_name: c_name, 
-            scope: f_scope,
-            arg_list: arg_list
-          )
-        end
-
-        def prepare_name_and_scope_of_functions stmt
-          f_name = stmt.name
-          f_scope = Rubex::SymbolTable::Scope::Local.new f_name, @scope
-          [f_name, f_scope]
-        end
-
-        def ruby_method_or_c_function? stmt
-          stmt.is_a?(Rubex::AST::TopStatement::RubyMethodDef) ||
-          stmt.is_a?(Rubex::AST::TopStatement::CFunctionDef)
-        end
-
-        def c_func_c_name name
-          Rubex::C_FUNC_PREFIX + @name + "_" + name
-        end
-      end # class Klass
-
-      class AttachedKlass < Klass
-
-        attr_reader :attached_type
-
-        ALLOC_FUNC_NAME      = Rubex::ALLOC_FUNC_NAME          
-        DEALLOC_FUNC_NAME    = Rubex::DEALLOC_FUNC_NAME        
-        MEMCOUNT_FUNC_NAME   = Rubex::MEMCOUNT_FUNC_NAME      
-        GET_STRUCT_FUNC_NAME = Rubex::GET_STRUCT_FUNC_NAME  
-
-        def initialize name, attached_type, ancestor, statements, location
-          @attached_type = attached_type
-          @location = location
-          super(name, ancestor, statements)
-        end
-
-        def analyse_statement outer_scope
-          super(outer_scope, attach_klass: true)
-          prepare_data_holding_struct
-          prepare_rb_data_type_t_struct
-          detach_and_modify_auxillary_c_functions_from_statements
-          add_auxillary_functions_to_klass_scope
-          prepare_auxillary_c_functions
-          @statements[1..-1].each do |stmt| # 0th stmt is the data struct
-            if ruby_method_or_c_func?(stmt)
-              rewrite_method_with_data_fetching stmt
-            end
-            stmt.analyse_statement @scope
-          end
-          analyse_auxillary_c_functions
-        end
-
-        def generate_code code
-          write_auxillary_c_functions code
-          write_data_type_t_struct code
-          write_get_struct_c_function code
-          write_alloc_c_function code
-          super
-        end
-
-      private
-
-        # Since auxillary functions are detached from the klass statements,
-        #   analyse their arg_list separately and add function names to the
-        #   class scope so that their statements can be analysed properly later.
-        def add_auxillary_functions_to_klass_scope
-          @auxillary_c_functions.each_value do |func|
-            f_name, f_scope = prepare_name_and_scope_of_functions func
-            func.arg_list.analyse_statement(f_scope)
-            return_type = Helpers.determine_dtype(func.type, func.return_ptr_level)
-            add_c_function_to_scope f_name, f_scope, func.arg_list, return_type
-          end
-        end
-
-        def analyse_auxillary_c_functions
-          @auxillary_c_functions.each_value do |func|
-            func.analyse_statement(@scope)
-          end
-        end
-
-        # Detach the user-supplied auxlically C functions from the class and
-        #   store them in Hash @auxillary_c_functions. Make modifications to
-        #   them if necessary and also set an ivar that indicates if an
-        #   auxillary function is user-supplied or not.
-        def detach_and_modify_auxillary_c_functions_from_statements
-          @auxillary_c_functions = {}
-
-          indexes = []
-          @statements.each_with_index do |stmt, idx|
-            if stmt.is_a?(CFunctionDef)
-              if stmt.name == ALLOC_FUNC_NAME
-                @auxillary_c_functions[ALLOC_FUNC_NAME] = stmt
-                @user_defined_alloc = true
-                indexes << idx
-              elsif stmt.name == DEALLOC_FUNC_NAME
-                @auxillary_c_functions[DEALLOC_FUNC_NAME] = stmt
-                @user_defined_dealloc = true
-                modify_dealloc_func stmt
-                indexes << idx
-              elsif stmt.name == MEMCOUNT_FUNC_NAME
-                @auxillary_c_functions[MEMCOUNT_FUNC_NAME] = stmt
-                @user_defined_memcount = true
-                indexes << idx
-              elsif stmt.name == GET_STRUCT_FUNC_NAME
-                @auxillary_c_functions[GET_STRUCT_FUNC_NAME] = stmt
-                @user_defined_get_struct = true
-                indexes << idx
-              end
-            end 
-          end
-
-          indexes.each do |idx|
-            @statements.delete_at idx
-          end
-        end
-
-        def write_auxillary_c_functions code
-          write_dealloc_c_function code
-          write_memcount_c_function code
-        end
-
-        # Actually write the alloc function into C code.
-        def write_alloc_c_function code
-          if user_defined_alloc?
-            @auxillary_c_functions[ALLOC_FUNC_NAME].generate_code code
-          else
-            code.write_c_method_header(
-              type: @alloc_c_func.type.type.to_s, 
-              c_name: @alloc_c_func.c_name, 
-              args: Helpers.create_arg_arrays(@alloc_c_func.type.arg_list))
-            code.block do
-              lines = ""
-              lines << "#{@data_struct.entry.c_name} *data;\n\n"
-
-              lines << "data = (#{@data_struct.entry.c_name}*)xmalloc("
-              lines << "sizeof(#{@data_struct.entry.c_name}));\n"
-
-              lines << member_struct_allocations
-
-              lines << "return TypedData_Wrap_Struct("
-              lines << "#{@alloc_c_func.type.arg_list[0].entry.c_name},"
-              lines << "&#{@data_type_t}, data);\n"
-
-              code << lines
-            end
-          end
-        end
-
-        #TODO: modify for supporting inheritance
-        def member_struct_allocations
-          c_name = @scope.find(@attached_type).c_name
-          "data->#{Rubex::POINTER_PREFIX + @attached_type} = (#{c_name}*)xmalloc(sizeof(#{c_name}));\n"
-        end
-
-        # Actually write the dealloc function into C code.
-        def write_dealloc_c_function code
-          if user_defined_dealloc?
-            @auxillary_c_functions[DEALLOC_FUNC_NAME].generate_code code
-          else
-            # TODO: define dealloc if user hasnt supplied.
-          end
-        end
-
-        # Actually write the memcount function into C code.
-        def write_memcount_c_function code
-          if user_defined_memcount?
-            @auxillary_c_functions[MEMCOUNT_FUNC_NAME].generate_code code
-          else
-            code.write_c_method_header(
-              type: @memcount_c_func.type.type.to_s, 
-              c_name: @memcount_c_func.c_name, 
-              args: Helpers.create_arg_arrays(@memcount_c_func.type.arg_list))
-            code.block do
-              code << "return sizeof(#{@memcount_c_func.type.arg_list[0].entry.c_name})"
-              code.colon
-              code.nl
-            end
-          end
-        end
-
-        # Actually write the get_struct function into C code.
-        def write_get_struct_c_function code
-          if user_defined_get_struct?
-            @auxillary_c_functions[GET_STRUCT_FUNC_NAME].generate_code code
-          else
-            code.write_c_method_header(
-              type: @get_struct_c_func.type.type.to_s, 
-              c_name: @get_struct_c_func.c_name, 
-              args: Helpers.create_arg_arrays(@get_struct_c_func.type.arg_list))
-            code.block do
-              lines = ""
-              lines << "#{@data_struct.entry.c_name} *data;\n\n"
-              lines << "TypedData_Get_Struct("
-              lines << "#{@get_struct_c_func.type.arg_list[0].entry.c_name}, "
-              lines << "#{@data_struct.entry.c_name}, &#{@data_type_t}, data);\n"
-              lines << "return data;\n"
-
-              code << lines
-            end
-          end
-        end
-
-        def write_data_type_t_struct code
-          decl = ""
-          decl << "static const rb_data_type_t #{@data_type_t} = {\n"
-          decl << "  \"#{@name}\",\n"
-          decl << "  {0, #{@dealloc_c_func.c_name}, #{@memcount_c_func.c_name},\n"
-          decl << "  0}, 0, 0, RUBY_TYPED_FREE_IMMEDIATELY\n"
-          decl << "};\n"
-
-          code << decl
-          code.new_line
-        end
-
-        # Prepare the data holding struct 'data' that will hold a pointer to the
-        #   struct that is attached to this class.
-        def prepare_data_holding_struct
-          struct_name = @name + "_data_struct"
-          declarations = declarations_for_data_struct
-          @data_struct = Statement::CStructOrUnionDef.new(
-            :struct, struct_name, declarations, @location)
-          @data_struct.analyse_statement(@scope)
-          @statements.unshift @data_struct
-        end
-
-        # TODO: support inherited attached structs.
-        def declarations_for_data_struct
-          stmts = []
-          stmts << Statement::CPtrDecl.new(@attached_type, @attached_type, nil, 
-            "*", @location)
-
-          stmts
-        end
-
-        def prepare_rb_data_type_t_struct
-          @data_type_t = Rubex::ATTACH_CLASS_PREFIX + "_" + @name + "_data_type_t"
-        end
-
-        # Prepare auxillary function in case they have not been supplied by user
-        #   and create ivars for their Symbol Table entries for easy accesss later.
-        def prepare_auxillary_c_functions
-          prepare_alloc_c_function
-          prepare_memcount_c_function
-          prepare_deallocation_c_function
-          prepare_get_struct_c_function
-        end
-
-        def ruby_method_or_c_func? stmt
-          stmt.is_a?(RubyMethodDef) || stmt.is_a?(CFunctionDef)
-        end
-
-        # Rewrite method `stmt` so that the `data` variable becomes available
-        #   inside the scope of the method.
-        def rewrite_method_with_data_fetching stmt
-          data_stmt = Statement::CPtrDecl.new(@data_struct.name, 'data', 
-            get_struct_func_call(stmt), "*", @location)
-          stmt.statements.unshift data_stmt
-        end
-
-        def get_struct_func_call stmt
-          Expression::CommandCall.new(nil, @get_struct_c_func.name, 
-            Statement::ArgumentList.new([]))
-        end
-
-        # Create an alloc function if it is not supplied by user.
-        def prepare_alloc_c_function
-          if user_defined_alloc?
-            @alloc_c_func = @scope.find(ALLOC_FUNC_NAME)
-          else
-            c_name = c_func_c_name(ALLOC_FUNC_NAME)
-            scope = Rubex::SymbolTable::Scope::Local.new(ALLOC_FUNC_NAME, @scope)
-            arg_list = Statement::ArgumentList.new([
-              Expression::ArgDeclaration.new({
-                dtype: 'object',
-                variables: [
-                  {
-                    ident: 'self'
-                  }
-                ]
-              })
-            ])
-            arg_list.analyse_statement(scope)
-            @alloc_c_func = @scope.add_c_method(
-              name: ALLOC_FUNC_NAME,
-              c_name: c_name, 
-              arg_list: arg_list,
-              return_type: DataType::RubyObject.new,
-              scope: scope)
-          end
-        end
-
-        # Create a memcount function if it is not supplied by user.
-        def prepare_memcount_c_function
-          if user_defined_memcount?
-            @memcount_c_func = @scope.find(MEMCOUNT_FUNC_NAME)
-          else
-            c_name = c_func_c_name(MEMCOUNT_FUNC_NAME)
-            scope = Rubex::SymbolTable::Scope::Local.new(MEMCOUNT_FUNC_NAME, @scope)
-            arg_list = Statement::ArgumentList.new([
-              Expression::ArgDeclaration.new({ 
-                dtype: "void", 
-                variables: [
-                    {
-                      ptr_level: "*",
-                      ident: "raw_data"
-                    }
-                  ]
-                })
-              ])
-            arg_list.analyse_statement(scope)
-            @memcount_c_func = @scope.add_c_method(
-              name: MEMCOUNT_FUNC_NAME,
-              c_name: c_name,
-              arg_list: arg_list,
-              return_type: DataType::Size_t.new,
-              scope: scope)
-          end
-        end
-
-        # Create a deallocate function if it is not supplied by user.
-        def prepare_deallocation_c_function
-          if user_defined_dealloc?
-            @dealloc_c_func = @scope.find(DEALLOC_FUNC_NAME)
-          else
-            c_name = c_func_c_name(DEALLOC_FUNC_NAME)
-            scope = Rubex::SymbolTable::Scope::Local.new(DEALLOC_FUNC_NAME, @scope)
-            arg_list = Statement::ArgumentList.new([
-              Expression::ArgDeclaration.new({
-                dtype: "void",
-                variables: [
-                    {
-                      ptr_level: "*",
-                      ident: "raw_data"
-                    }
-                  ]
-                })
-              ])
-            arg_list.analyse_statement(scope)
-            @dealloc_c_func = @scope.add_c_method(
-              name: DEALLOC_FUNC_NAME,
-              c_name: c_name, 
-              return_type: DataType::Void.new,
-              scope: scope,
-              arg_list: arg_list)
-          end
-        end
-
-        # Create a get_struct function if it is not supplied by user.
-        def prepare_get_struct_c_function
-          if user_defined_get_struct?
-            @get_struct_c_func = @scope.find(GET_STRUCT_FUNC_NAME)
-          else
-            c_name = c_func_c_name(GET_STRUCT_FUNC_NAME)
-            scope = Rubex::SymbolTable::Scope::Local.new(
-              GET_STRUCT_FUNC_NAME, @scope)
-            arg_list = Statement::ArgumentList.new([
-              Expression::ArgDeclaration.new({
-                  dtype: "object",
-                  variables: [
-                    {
-                      ident: "obj"
-                    }
-                  ]
-                })
-              ])
-            arg_list.analyse_statement(scope)
-            return_type = DataType::CPtr.new(
-                            DataType::CStructOrUnion.new(
-                    :struct, @data_struct.name, @data_struct.entry.c_name, nil)
-              )
-            @get_struct_c_func = @scope.add_c_method(
-              name: GET_STRUCT_FUNC_NAME,
-              c_name: c_name,
-              return_type: return_type,
-              arg_list: arg_list,
-              scope: scope
-            )
-          end
-        end
-
-        # Modify the dealloc function by adding an argument of type void* so
-        #   that it is compatible with what Ruby expects. This is done so that
-        #   the user is not burdened with additional knowledge of knowing the
-        #   the correct argument for deallocate.
-        def modify_dealloc_func func
-          func.arg_list = Statement::ArgumentList.new([
-              Expression::ArgDeclaration.new({
-                dtype: "void",
-                variables: [
-                    {
-                      ptr_level: "*",
-                      ident: "raw_data"
-                    }
-                  ]
-                })
-              ])
-          value = Expression::Name.new('raw_data')
-          value.typecast = Expression::Typecast.new(@data_struct.name, "*")
-          data_var = Statement::CPtrDecl.new(@data_struct.name, 'data', value, 
-            "*", @location)
-          xfree = Expression::CommandCall.new(nil, 'xfree', 
-            [Expression::Name.new('data')])
-          data_xfree = Statement::Expression.new xfree, @location
-          func.statements.unshift data_var
-          func.statements.push data_xfree
-        end
-
-        def user_defined_dealloc?
-          @user_defined_dealloc
-        end
-
-        def user_defined_alloc?
-          @user_defined_alloc
-        end
-
-        def user_defined_memcount?
-          @user_defined_memcount
-        end
-
-        def user_defined_get_struct?
-          @user_defined_get_struct
-        end
-      end # class AttachedKlass
-    end # module TopStatement
-  end # module AST
-end # module Rubex
+Dir['./lib/rubex/ast/top_statement/**/*.rb'].sort.each { |f| require f }