allow custom allocate function for attached classes

Author: v0dro

REFERENCE.md

@@ -644,6 +644,25 @@ The `xfree` function, which is the standard memory freeing function provided by
 
 ### allocate
 
+The `allocate` function is called by the Ruby interpreter before it initializes the class
+using `initialize`. It is here that the C level memory allocations that are assigned to a
+particular class via attached structs should be `xmalloc`'d. The correponding data should be
+freed using `xfree` inside the `deallocate` function that is documented below.
+
+Keep in mind that if you choose to define your own `allocate` function, it must have a return
+type `object`. An example `deallocate` would look like so:
+``` ruby
+struct test
+  int *a
+end
+
+class A attach test
+  cfunc object allocate
+    data$.test.a = <int*>xmalloc(sizeof(int)*100)
+  end
+end
+```
+
 ### memcount
 
 ### get_struct

lib/rubex/ast/node.rb

@@ -78,6 +78,15 @@ def outside_statement?(stmt)
           stmt.is_a?(Statement::Expression)
         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
+        
         def generate_header_file(target_name, header)
           header_def_name = target_name.gsub("/", "_").gsub(".", "_").upcase + "_H"
           header.in_header_guard(header_def_name) do
@@ -90,9 +99,7 @@ def generate_header_file(target_name, header)
                   "#include \"#{name}\"\n"
                 end
             end
-            @statements.grep(Rubex::AST::TopStatement::Klass).each do |klass|
-              declare_types header, klass.scope
-            end
+            declare_unique_types header
             write_user_klasses header
             write_global_variable_declarations header
             write_function_declarations header

lib/rubex/ast/top_statement/klass/attached_klass.rb

@@ -72,6 +72,7 @@ def detach_and_modify_auxillary_c_functions_from_statements
               if stmt.name == ALLOC_FUNC_NAME
                 @auxillary_c_functions[ALLOC_FUNC_NAME] = stmt
                 @user_defined_alloc = true
+                modify_alloc_func stmt
                 indexes << idx
               elsif stmt.name == DEALLOC_FUNC_NAME
                 @auxillary_c_functions[DEALLOC_FUNC_NAME] = stmt
@@ -90,8 +91,8 @@ def detach_and_modify_auxillary_c_functions_from_statements
             end
           end
 
-          indexes.each do |idx|
-            @statements.delete_at idx
+          @statements.delete_if.with_index do |s, i|
+            indexes.include? i
           end
         end
 
@@ -100,10 +101,22 @@ def write_auxillary_c_functions(code)
           write_memcount_c_function code
         end
 
+        # FIXME : change this. its too ugly.
+        def ugly_code_mod_hack code
+          ret = ""
+          ret << 'return TypedData_Wrap_Struct('
+          ret << "#{@alloc_c_func.type.arg_list[0].entry.c_name},"
+          ret << "&#{@data_type_t}, #{Rubex::POINTER_PREFIX}data);\n"
+
+          c = code.instance_variable_get(:@code)
+          c.insert -4, ret
+        end
+        
         # Actually write the alloc function into C code.
-        def write_alloc_c_function(code)
+        def write_alloc_c_function(code)          
           if user_defined_alloc?
             @auxillary_c_functions[ALLOC_FUNC_NAME].generate_code code
+            ugly_code_mod_hack code
           else
             code.write_c_method_header(
               type: @alloc_c_func.type.type.to_s,
@@ -122,7 +135,7 @@ def write_alloc_c_function(code)
               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
@@ -368,6 +381,71 @@ def prepare_get_struct_c_function
           end
         end
 
+        # In case of user supplied allocate function, add a statement at the
+        #   beginning to declare and obtain the data variable and also add a
+        #   return statement involving TypedDataStruct at the end so that the
+        #   user is freed from needing to write these.
+        def modify_alloc_func(func)
+          stmts = []
+          stmts << data_var_cptr_decl(nil)
+          stmts.concat data_struct_allocations
+          stmts.reverse.each do |s|
+            func.statements.unshift s
+          end
+        end
+
+        # declare a pointer to a data struct.
+        def data_var_cptr_decl(value = nil)
+          Statement::CPtrDecl.new(
+            @data_struct.entry.name, 'data', value, '*', @location)
+        end
+
+        def data_struct_allocations
+          stmts = []
+          # assign malloc for top level data struct
+          rhs = Expression::CommandCall.new(
+            nil, 'xmalloc',
+            Expression::ActualArgList.new(
+              [
+                Expression::SizeOf.new(@data_struct.entry.name, '')
+              ])
+          )
+          rhs.typecast = Expression::Typecast.new(@data_struct.entry.name, '*')
+          assign_data_struct = Statement::Assign.new(
+            Expression::Name.new('data'), rhs, @location
+          )
+
+          stmts << assign_data_struct
+          stmts << xmalloc_inner_struct_member
+          stmts
+        end
+
+        def xmalloc_inner_struct_member
+          t = @scope.find(@attached_type).name
+          lhs = Expression::CommandCall.new(
+            Expression::ElementRef.new(
+              'data',
+              Expression::ActualArgList.new(
+                [
+                  Expression::Literal::Int.new('0')
+                ]
+              )
+            ),
+            t,
+            nil
+          )
+          rhs = Expression::CommandCall.new(
+            nil, 'xmalloc',
+            Expression::ActualArgList.new(
+              [
+                Expression::SizeOf.new(t, '')
+              ]
+            )
+          )
+          rhs.typecast = Expression::Typecast.new(t, '*')
+          Statement::Assign.new(lhs, rhs, @location)
+        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

lib/rubex/ast/top_statement/method_def.rb

@@ -53,7 +53,7 @@ def rescan_declarations(_scope)
         private
 
         def generate_function_definition(code, c_function:)
-          declare_types code, @scope
+          declare_types code, @scope.type_entries
           declare_args code unless c_function
           declare_vars code, @scope
           declare_carrays code, @scope

lib/rubex/helpers/writers.rb

@@ -29,8 +29,8 @@ def declare_carrays(code, scope)
         end
       end
 
-      def declare_types(code, scope)
-        scope.type_entries.each do |entry|
+      def declare_types(code, type_entries)
+        type_entries.each do |entry|
           type = entry.type
 
           if type.alias_type?

spec/c_struct_interface_spec.rb

@@ -17,8 +17,7 @@
 
     context ".compile", hell: true do
       it "generates valid C code" do
-        t, c, e = Rubex::Compiler.compile @path + ".rubex", test: true
-        puts c
+        t, c, e, h = Rubex::Compiler.compile @path + ".rubex", test: true
       end
     end
 

spec/fixtures/c_struct_interface/c_struct_interface.rubex

@@ -47,13 +47,13 @@ struct test
 end
 
 class A attach test
-  cfunc void allocate
+  cfunc object allocate
     data$.test.a = <int*>xmalloc(sizeof(int)*100)
   end
 
   def foo
     data$.test.a[3] = 55
-    return data$.test.a
+    return data$.test.a[3]
   end
 
   cfunc void deallocate