rubex 0.1.1 → 0.1.2

data/lib/rubex/ast/expression/command_call/yield.rb

@@ -0,0 +1,36 @@
+module Rubex
+  module AST
+    module Expression
+      class Yield < Base
+        def initialize(args)
+          @args = args
+        end
+
+        def analyse_types(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
+          @subexprs = @args
+        end
+
+        def generate_evaluation_code(code, local_scope)
+          generate_and_dispose_subexprs(code, local_scope) do
+            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
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rubex/ast/expression/element_ref.rb

@@ -5,12 +5,17 @@ module Rubex
         # Readers needed for accessing elements due to delegator classes.
         attr_reader :entry, :pos, :name, :subexprs
         extend Forwardable
-        def_delegators :@element_ref, :generate_disposal_code, :generate_evaluation_code,
-        :analyse_statement, :generate_element_ref_code,
-        :generate_assignment_code, :has_temp, :c_code,
-        :allocate_temps, :release_temps, :to_ruby_object,
-        :from_ruby_object
+        def_delegators :@element_ref, :generate_disposal_code,
+                       :generate_evaluation_code,
+                       :analyse_statement, :generate_element_ref_code,
+                       :generate_assignment_code, :has_temp, :c_code,
+                       :allocate_temps, :release_temps, :to_ruby_object,
+                       :from_ruby_object
 
+        # Initialize an array_ref. Can be in an expression or variable decl.
+        #
+        # @param name [String] The name in the code of the variable.
+        # @param pos [Expression::ActualArgList] Position information.
         def initialize(name, pos)
           @name = name
           @pos = pos

data/lib/rubex/ast/expression/instance_var.rb

@@ -0,0 +1,33 @@
+module Rubex
+  module AST
+    module Expression
+      class InstanceVar < Base
+        def initialize(name)
+          @name = name
+        end
+
+        def analyse_types(local_scope)
+          @type = DataType::RubyObject.new
+          @has_temp = true
+        end
+
+        def generate_evaluation_code(code, local_scope)
+          code << "#{@c_code} = rb_iv_get(#{local_scope.self_name}, \"#{@name}\");"
+          code.nl
+        end
+
+        def generate_assignment_code(rhs, code, local_scope)
+          code << "rb_iv_set(#{local_scope.self_name}, \"#{@name}\","
+          code << "#{rhs.c_code(local_scope)});"
+          code.nl
+        end
+        
+        def c_code(local_scope)
+          code = super
+          code << @c_code
+          code
+        end
+      end # class InstanceVar
+    end # module Expression
+  end # module AST
+end # module Rubex

data/lib/rubex/ast/expression/method_call.rb

@@ -22,8 +22,10 @@ module Rubex
         private
 
         def type_check_arg_types(entry)
-          @arg_list.map!.with_index do |arg, idx|
-            Helpers.to_lhs_type(entry.type.base_type.arg_list[idx], arg)
+          unless @arg_list.empty?
+            @arg_list.map!.with_index do |arg, idx|
+              Helpers.to_lhs_type(entry.type.base_type.arg_list[idx], arg)
+            end
           end
         end
 

data/lib/rubex/ast/expression/method_call/c_function_call.rb

@@ -5,11 +5,12 @@ module Rubex
         def analyse_types(local_scope)
           @entry = local_scope.find(@method_name)
           super
-          append_self_argument unless @entry.extern?
-          @arg_list.analyse_types local_scope
+          append_self_argument if  !@entry.extern? && !@entry.no_gil
+          @type = @entry.type.base_type
+          @arg_list.analyse_for_target_type @type.arg_list, local_scope
           @arg_list.allocate_temps local_scope
           @arg_list.release_temps local_scope
-          @type = @entry.type.base_type
+
           type_check_arg_types @entry
         end
 

data/lib/rubex/ast/expression/method_call/ruby_method_call.rb

@@ -6,6 +6,7 @@ module Rubex
           @entry = local_scope.find(@method_name)
           add_as_ruby_method_to_symtab(local_scope) unless @entry
           super
+          @entry.times_called += 1
           @arg_list.analyse_types local_scope
           @type = Rubex::DataType::RubyObject.new
           @arg_list.map! { |a| a.to_ruby_object }
@@ -37,7 +38,7 @@ module Rubex
         end
 
         def prepare_arg_list(local_scope)
-          @arg_list_var = @entry.c_name + Rubex::ACTUAL_ARGS_SUFFIX
+          @arg_list_var = @entry.c_name + "_#{@entry.times_called}_" + Rubex::ACTUAL_ARGS_SUFFIX
           args_size = @entry.type.arg_list&.size || 0
           local_scope.add_carray(name: @arg_list_var, c_name: @arg_list_var,
                                  dimension: Literal::Int.new(args_size.to_s),
@@ -45,25 +46,26 @@ module Rubex
         end
 
         def code_for_ruby_method_call(code, local_scope)
-          str = "#{@c_code} = "
+          str = ""
           if @entry.extern?
-            str << "rb_funcall(#{@invoker.c_code(local_scope)}, "
+            str << "#{@c_code} = rb_funcall(#{@invoker.c_code(local_scope)}, "
             str << "rb_intern(\"#{@method_name}\"), "
             str << @arg_list.size.to_s
             @arg_list.each do |arg|
               str << " ,#{arg.c_code(local_scope)}"
             end
             str << ', NULL' if @arg_list.empty?
-            str << ");\n"
+            str << ");"
           else
             str << populate_method_args_into_value_array(local_scope)
             str << actual_ruby_method_call(local_scope)
           end
+          str << "\n"
           code << str
         end
 
         def actual_ruby_method_call(local_scope)
-          str = "#{@entry.c_name}(#{@arg_list.size}, #{@arg_list_var || 'NULL'},"
+          str = "#{@c_code} = #{@entry.c_name}(#{@arg_list.size}, #{@arg_list_var || 'NULL'},"
           str << "#{local_scope.self_name});"
         end
 

data/lib/rubex/ast/expression/name.rb

@@ -47,8 +47,9 @@ module Rubex
               add_as_ruby_method_to_scope local_scope
             end
           end
-          analyse_as_ruby_method(local_scope) if @entry.type.ruby_method?
           assign_type_based_on_whether_wrapped_type
+          analyse_as_ruby_method(local_scope) if @entry.type.ruby_method?
+          analyse_as_c_function(local_scope) if @entry.type.c_function?
           if @name.is_a?(Expression::Base)
             @name.allocate_temps local_scope
             @name.release_temps local_scope
@@ -56,6 +57,14 @@ module Rubex
           super
         end
 
+        def analyse_as_c_function(local_scope)
+          @name = Rubex::AST::Expression::CFunctionCall.new(
+            Expression::Self.new, @name,
+            Expression::ActualArgList.new([])
+          )
+          @name.analyse_types(local_scope)
+        end
+
         def generate_evaluation_code(code, local_scope)
           if @name.respond_to? :generate_evaluation_code
             @name.generate_evaluation_code code, local_scope

data/lib/rubex/ast/expression/ruby_object_element_ref/ruby_array_element_ref.rb

@@ -7,10 +7,13 @@ module Rubex
           @pos.analyse_types local_scope
           @subexprs << @pos
         end
-        
+
+        # FIXME: If there are multiple arguments specified for array_ref,
+        #   we cannot use RARRAY_REF.
         def generate_evaluation_code(code, local_scope)
           generate_and_dispose_subexprs(code, local_scope) do
-            code << "#{@c_code} = RARRAY_AREF(#{@entry.c_name}, #{@pos.c_code(local_scope)});"
+            code << "#{@c_code} = RARRAY_AREF(#{@entry.c_name},"
+            code << "#{@pos[0].c_code(local_scope)});"
             code.nl
           end
         end

data/lib/rubex/ast/expression/ruby_object_element_ref/ruby_hash_element_ref.rb

@@ -2,16 +2,24 @@ module Rubex
   module AST
     module Expression
       class RubyHashElementRef < RubyObjectElementRef
+        def analyse_types(local_scope)
+          if @pos.size > 1
+            raise "Ruby Hash#[] expects 1 argument. Not #{@pos.size}."
+          end
+          super
+        end
+        
         def generate_evaluation_code(code, local_scope)
           generate_and_dispose_subexprs(code, local_scope) do
-            code << "#{@c_code} = rb_hash_aref(#{@entry.c_name}, #{@pos.c_code(local_scope)});"
+            code << "#{@c_code} = rb_hash_aref(#{@entry.c_name}, "
+            code << "#{@pos[0].c_code(local_scope)});"
             code.nl
           end
         end
 
         def generate_assignment_code(rhs, code, local_scope)
           generate_and_dispose_subexprs(code, local_scope) do
-            code << "rb_hash_aset(#{@entry.c_name}, #{@pos.c_code(local_scope)},"
+            code << "rb_hash_aset(#{@entry.c_name}, #{@pos[0].c_code(local_scope)},"
             code << "#{rhs.c_code(local_scope)});"
             code.nl
           end

data/lib/rubex/ast/expression/to_ruby_object.rb

@@ -3,6 +3,7 @@ module Rubex
     module Expression
       # internal node for converting to ruby object.
       class ToRubyObject < CoerceObject
+        #attr_reader :expr
         attr_reader :type
 
         def initialize(expr)

data/lib/rubex/ast/expression/unary.rb

@@ -1,5 +1,5 @@
 require_relative 'unary_base'
-Dir['./lib/rubex/ast/expression/unary_base/*.rb'].each { |f| require f }
+Dir[File.join(File.dirname(File.dirname(__FILE__)), "expression", "unary_base", "*.rb" )].each { |f| require f }
 module Rubex
   module AST
     module Expression
@@ -13,16 +13,20 @@ module Rubex
 
         def initialize(operator, expr)
           @operator = operator
-          @expr = expr
+          @expr = OP_CLASS_MAP[@operator].new(expr)
         end
 
         def analyse_types(local_scope)
-          @expr = OP_CLASS_MAP[@operator].new(@expr)
           @expr.analyse_types local_scope
           @type = @expr.type
           super
         end
 
+        def analyse_for_target_type(target_type, local_scope)
+          @expr.analyse_for_target_type(target_type, local_scope)
+          @type = @expr.type
+        end
+
         def generate_evaluation_code(code, local_scope)
           @expr.generate_evaluation_code code, local_scope
         end

data/lib/rubex/ast/expression/unary_base/ampersand.rb

@@ -7,6 +7,11 @@ module Rubex
           @type = DataType::CPtr.new @expr.type
         end
 
+        def analyse_for_target_type(target_type, local_scope)
+          @expr.analyse_for_target_type(target_type, local_scope)
+          @type = DataType::CPtr.new @expr.type
+        end
+        
         def c_code(local_scope)
           "&#{@expr.c_code(local_scope)}"
         end

data/lib/rubex/ast/node.rb

@@ -1,231 +1,228 @@
 require 'rubex/helpers'
 module Rubex
   module AST
-    class Node
-      include Rubex::Helpers::Writers
-      attr_reader :statements
-
-      def initialize(statements)
-        @statements = statements.flatten
-      end
-
-      def process_statements(target_name, code)
-        @scope = Rubex::SymbolTable::Scope::Klass.new('Object', nil)
-        add_top_statements_to_object_scope
-        analyse_statement
-        rescan_declarations @scope
-        generate_preamble code
-        generate_code code
-        generate_init_method target_name, code
-      end
+    module Node
+      class Base
+        include Rubex::Helpers::Writers
+        attr_reader :statements, :file_name
+        
+        def initialize(statements, file_name)
+          @statements = statements.flatten
+          @file_name = file_name
+          @dependent_files = []
+        end
 
-      def ==(other)
-        self.class == other.class
-      end
+        def ==(other)
+          self.class == other.class
+        end
 
-      private
+        def analyse_statement
+          @statements.each do |stat|
+          @dependent_files << stat.file_name if stat.is_a?(Node::FileNode)
+          stat.analyse_statement @scope         
+          end
+          @outside_statements.each do |stmt|
+            stmt.analyse_statement @scope
+          end
+        end
+        
+        # Scan all the statements that do not belong to any particular class
+        #   (meaning that they belong to Object) and add them to the Object class,
+        #   which becomes the class from which all other classes will inherit from.
+        #
+        # Top-level statements that do not belong inside classes and which do not
+        #   have any relevance inside a class at the level of a C extension are
+        #   added to a different array and are analysed differently. For example
+        #   'require' statements that are top level statements but cannot be 'defined'
+        #   inside the Init_ method the way a ruby class or method can be. These are
+        #   stored in @outside_statements.
+        #
+        # If the user defines multiple Object classes, they will share the same @scope
+        #   object and will therefore have accessible members between each other. Since
+        #   Ruby also allows users to open classes whenever and wherever they want, this
+        #   behaviour is conformant with actual Ruby behaviour. It also implies that a
+        #   FileNode can basically create an Object class of its own and the scope will
+        #   shared between FileNode and MainNode and other FileNodes as long as the FileNode
+        #   shares the same @scope object.
+        def add_top_statements_to_object_scope
+          temp = []
+          combined_statements = []
+          @outside_statements = []
+          @statements.each do |stmt|
+            if stmt.is_a?(TopStatement::Klass) || stmt.is_a?(TopStatement::CBindings)
+              if !temp.empty?
+                object_klass = TopStatement::Klass.new('Object', @scope, temp)
+                combined_statements << object_klass
+              end
 
-      # Scan all the statements that do not belong to any particular class
-      #   (meaning that they belong to Object) and add them to the Object class,
-      #   which becomes the class from which all other classes will inherit from.
-      def add_top_statements_to_object_scope
-        temp = []
-        combined_statements = []
-        @statements.each do |stmt|
-          if stmt.is_a?(TopStatement::Klass) || stmt.is_a?(TopStatement::CBindings)
-            unless temp.empty?
-              object_klass = TopStatement::Klass.new('Object', @scope, temp)
-              combined_statements << object_klass
+              combined_statements << stmt
+              temp = []
+            elsif outside_statement?(stmt)
+              @outside_statements << stmt
+            elsif stmt.is_a?(Node::FileNode)
+              combined_statements << stmt
+            else
+              temp << stmt
             end
+          end
 
-            combined_statements << stmt
-            temp = []
-          else
-            temp << stmt
+          unless temp.empty?
+            combined_statements << TopStatement::Klass.new('Object', @scope, temp)
           end
-        end
 
-        unless temp.empty?
-          combined_statements << TopStatement::Klass.new('Object', @scope, temp)
+          @statements = combined_statements
         end
 
-        @statements = combined_statements
-      end
+        # TODO: accomodate all sorts of outside stmts like if blocks/while/for etc
+        def outside_statement?(stmt)
+          stmt.is_a?(Statement::Expression)
+        end
 
-      def generate_preamble(code)
-        code << "#include <ruby.h>\n"
-        code << "#include <stdint.h>\n"
-        code << "#include <stdbool.h>\n"
-        @scope.include_files.each do |name|
-          code <<
-            if name[0] == '<' && name[-1] == '>'
-              "#include #{name}\n"
-            else
-              "#include \"#{name}\"\n"
-            end
+        def declare_unique_types header
+          types = []
+          @statements.grep(Rubex::AST::TopStatement::Klass).each do |klass|
+            types.concat klass.scope.type_entries
+          end
+          types.uniq!
+          declare_types header, types
         end
-        write_usability_macros code
-        @statements.grep(Rubex::AST::TopStatement::Klass).each do |klass|
-          declare_types code, klass.scope
+        
+        def generate_header_file(target_name, header)
+          header_def_name = target_name.gsub("/", "_").gsub(".", "_").upcase + "_H"
+          header.in_header_guard(header_def_name) do
+            header.write_include Rubex::COMMON_UTILS_FILE
+            @scope.include_files.each do |name|
+              header <<
+                if name[0] == '<' && name[-1] == '>'
+                  "#include #{name}\n"
+                else
+                  "#include \"#{name}\"\n"
+                end
+            end
+            declare_unique_types header
+            write_user_klasses header
+            write_global_variable_declarations header
+            write_function_declarations header
+            header.write_func_declaration type: 'void', c_name: init_function,
+                                          args: [], static: false
+          end
         end
-        write_user_klasses code
-        write_global_variable_declarations code
-        write_function_declarations code
-        write_usability_functions code
-        code.nl
-      end
 
-      def write_global_variable_declarations(code)
-        @statements.each do |stmt|
-          next unless stmt.is_a?(TopStatement::Klass)
-          stmt.statements.each do |s|
-            next unless s.is_a?(TopStatement::MethodDef)
-            s.scope.global_entries.each do |g|
-              code << "static #{g.type} #{g.c_name};"
-              code.nl
+        def write_global_variable_declarations(code)
+          @statements.each do |stmt|
+            next unless stmt.is_a?(TopStatement::Klass)
+            stmt.statements.each do |s|
+              next unless s.is_a?(TopStatement::MethodDef)
+              s.scope.global_entries.each do |g|
+                code << "static #{g.type} #{g.c_name};"
+                code.nl
+              end
             end
           end
         end
-      end
 
-      def write_user_klasses(code)
-        code.nl
-        @scope.ruby_class_entries.each do |klass|
-          unless Rubex::DEFAULT_CLASS_MAPPINGS.has_key?(klass.name)
-            code << "VALUE #{klass.c_name};" 
-            code.nl
+        def write_user_klasses(code)
+          code.nl
+          @scope.ruby_class_entries.each do |klass|
+            unless Rubex::DEFAULT_CLASS_MAPPINGS.has_key?(klass.name)
+              code << "VALUE #{klass.c_name};" 
+              code.nl
+            end
           end
         end
-      end
-
-      def write_usability_macros(code)
-        code.nl
-        code.c_macro Rubex::RUBEX_PREFIX + 'INT2BOOL(arg) (arg ? Qtrue : Qfalse)'
-        code.nl
-      end
 
-      def write_usability_functions(code)
-        code.nl
-        write_char_2_ruby_str code
-      end
+        def write_function_declarations(code)
+          @statements.each do |stmt|
+            next unless stmt.is_a?(Rubex::AST::TopStatement::Klass)
+            stmt.scope.ruby_method_entries.each do |entry|
+              code.write_ruby_method_header(
+                type: entry.type.type.to_s, c_name: entry.c_name
+              )
+              code.colon
+            end
 
-      def write_char_2_ruby_str(code)
-        code << "VALUE #{Rubex::C_FUNC_CHAR2RUBYSTR}(char ch);"
-        code.nl
-        code << "VALUE #{Rubex::C_FUNC_CHAR2RUBYSTR}(char ch)"
-        code.block do
-          code << "char s[2];\n"
-          code << "s[0] = ch;\n"
-          code << "s[1] = '\\0';\n"
-          code << "return rb_str_new2(s);\n"
+            stmt.scope.c_method_entries.each do |entry|
+              next if entry.extern?
+              code.write_c_method_header(
+                type: entry.type.type.to_s,
+                c_name: entry.c_name,
+                args: Helpers.create_arg_arrays(entry.type.arg_list)
+              )
+              code.colon
+            end
+          end
         end
-      end
 
-      def write_function_declarations(code)
-        @statements.each do |stmt|
-          next unless stmt.is_a?(Rubex::AST::TopStatement::Klass)
-          stmt.scope.ruby_method_entries.each do |entry|
-            code.write_ruby_method_header(
-              type: entry.type.type.to_s, c_name: entry.c_name
-            )
-            code.colon
-          end
+        def create_symtab_entries_for_top_statements(s)
+          @scope = s
+          @statements.each do |stat|
+            stat.create_symtab_entries_for_top_statements(@scope) if stat.is_a?(Node::FileNode)
+            next unless stat.is_a? Rubex::AST::TopStatement::Klass
+            name = stat.name
+            # The top level scope in Ruby is Object. The Object class's immediate
+            # ancestor is also Object. Hence, it is important to set the class
+            # scope and ancestor scope of Object as Object, and make sure that
+            # the same scope object is used for 'Object' class every single time
+            # throughout the compilation process.
+            if name != 'Object'
+              ancestor_entry = @scope.find(stat.ancestor)
+              if !ancestor_entry && Rubex::DEFAULT_CLASS_MAPPINGS[stat.ancestor]
+                ancestor_c_name = Rubex::DEFAULT_CLASS_MAPPINGS[stat.ancestor]
+                ancestor_scope = object_or_stdlib_klass_scope stat.ancestor
+                @scope.add_ruby_class(name: stat.ancestor, c_name: ancestor_c_name,
+                                      scope: @scope, ancestor: nil, extern: true)
+              else
+                ancestor_scope = ancestor_entry&.type&.scope || @scope
+              end
+              klass_scope = Rubex::SymbolTable::Scope::Klass.new(
+                name, ancestor_scope
+              )
+            else
+              ancestor_scope = @scope
+              klass_scope = @scope
+            end
+            c_name = c_name_for_class name
 
-          stmt.scope.c_method_entries.each do |entry|
-            next if entry.extern?
-            code.write_c_method_header(
-              type: entry.type.type.to_s,
-              c_name: entry.c_name,
-              args: Helpers.create_arg_arrays(entry.type.arg_list)
-            )
-            code.colon
+            @scope.add_ruby_class(name: name, c_name: c_name, scope: klass_scope,
+                                  ancestor: ancestor_scope, extern: false)
           end
         end
-      end
 
-      def analyse_statement
-        create_symtab_entries_for_top_statements
-        @statements.each do |stat|
-          stat.analyse_statement @scope
+        def object_or_stdlib_klass_scope(name)
+          name != 'Object' ? Rubex::SymbolTable::Scope::Klass.new(name, nil) :
+            @scope
         end
-      end
 
-      def create_symtab_entries_for_top_statements
-        @statements.each do |stat|
-          next unless stat.is_a? Rubex::AST::TopStatement::Klass
-          name = stat.name
-          # The top level scope in Ruby is Object. The Object class's immediate
-          # ancestor is also Object. Hence, it is important to set the class
-          # scope and ancestor scope of Object as Object, and make sure that
-          # the same scope object is used for 'Object' class every single time
-          # throughout the compilation process.
-          if name != 'Object'
-            ancestor_entry = @scope.find(stat.ancestor)
-            if !ancestor_entry && Rubex::DEFAULT_CLASS_MAPPINGS[stat.ancestor]
-              ancestor_c_name = Rubex::DEFAULT_CLASS_MAPPINGS[stat.ancestor]
-              ancestor_scope = object_or_stdlib_klass_scope stat.ancestor
-              @scope.add_ruby_class(name: stat.ancestor, c_name: ancestor_c_name,
-                                    scope: @scope, ancestor: nil, extern: true)
+        def c_name_for_class(name)
+          c_name =
+            if Rubex::DEFAULT_CLASS_MAPPINGS.key? name
+              Rubex::DEFAULT_CLASS_MAPPINGS[name]
             else
-              ancestor_scope = ancestor_entry&.type&.scope || @scope
+              Rubex::RUBY_CLASS_PREFIX + name
             end
-            klass_scope = Rubex::SymbolTable::Scope::Klass.new(
-              name, ancestor_scope
-            )
-          else
-            ancestor_scope = @scope
-            klass_scope = @scope
-          end
-          c_name = c_name_for_class name
 
-          @scope.add_ruby_class(name: name, c_name: c_name, scope: klass_scope,
-                                ancestor: ancestor_scope, extern: false)
+          c_name
         end
-      end
-
-      def object_or_stdlib_klass_scope(name)
-        name != 'Object' ? Rubex::SymbolTable::Scope::Klass.new(name, nil) :
-          @scope
-      end
 
-      def c_name_for_class(name)
-        c_name =
-          if Rubex::DEFAULT_CLASS_MAPPINGS.key? name
-            Rubex::DEFAULT_CLASS_MAPPINGS[name]
-          else
-            Rubex::RUBY_CLASS_PREFIX + name
+        def rescan_declarations(_scope)
+          @statements.each do |stat|
+            stat.respond_to?(:rescan_declarations) &&
+              stat.rescan_declarations(@scope)
           end
-
-        c_name
-      end
-
-      def rescan_declarations(_scope)
-        @statements.each do |stat|
-          stat.respond_to?(:rescan_declarations) &&
-            stat.rescan_declarations(@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 type: 'void', c_name: name, args: [], static: false
-        code.write_c_method_header type: 'void', c_name: name, args: [], static: false
-        code.block do
-          @statements.each do |top_stmt|
-            if top_stmt.is_a?(TopStatement::Klass) && top_stmt.name != 'Object'
-              entry = @scope.find top_stmt.name
-              code.declare_variable type: 'VALUE', c_name: entry.c_name
+        # FIXME: Find a way to eradicate the if statement.
+        def generate_code(supervisor)
+          @statements.each do |stat|
+            if stat.is_a?(Rubex::AST::Node::FileNode)
+              stat.generate_code supervisor
+            else
+              stat.generate_code supervisor.code(@file_name)
             end
           end
-          code.nl
+        end
 
+        def define_classes(code)
           @statements.each do |top_stmt|
             # define a class
             if top_stmt.is_a?(TopStatement::Klass) && top_stmt.name != 'Object'
@@ -247,7 +244,9 @@ module Rubex
             code << alloc
           end
           code.nl
+        end
 
+        def define_instance_and_singleton_methods_for_all_classes(code)
           @statements.each do |top_stmt|
             next unless top_stmt.is_a? TopStatement::Klass
             entry = @scope.find top_stmt.name
@@ -261,6 +260,35 @@ module Rubex
                                            method_name: meth.name, method_c_name: meth.c_name
               end
             end
+          end        
+        end
+
+        def write_outside_statements(code)
+          @outside_statements.each do |stmt|
+            stmt.generate_code(code, @scope)
+          end
+        end
+
+        def init_function
+          "Init_#{@file_name}"
+        end
+
+        def call_dependent_init_methods(code)
+          @dependent_files.each do |dep|
+            code << "Init_#{dep}();"
+            code.nl
+          end
+        end
+        
+        def generate_init_method(code)
+          name = init_function
+          code.new_line
+          code.write_c_method_header type: 'void', c_name: name, args: [], static: false
+          code.block do
+            call_dependent_init_methods(code)
+            write_outside_statements(code)
+            define_classes(code)
+            define_instance_and_singleton_methods_for_all_classes(code)
           end
         end
       end