rubex 0.1.1 → 0.1.2

data/lib/rubex/ast/node/file_node.rb

@@ -0,0 +1,25 @@
+module Rubex
+  module AST
+    module Node
+      # Class for denoting a rubex file that is required from another rubex file.
+      #   Takes the Object scope from the MainNode or other FileNode objects and
+      #   uses that for storing any symbols that it encounters.
+      class FileNode < Base
+        def analyse_statement(_local_scope)
+          add_top_statements_to_object_scope
+          super()
+          rescan_declarations @scope
+        end
+
+        def generate_code(supervisor)
+          supervisor.init_file(@file_name)
+          code_writer = supervisor.code(@file_name)
+          code_writer.write_include @file_name
+          generate_header_file @file_name, supervisor.header(@file_name)
+          super
+          generate_init_method code_writer
+        end
+      end
+    end
+  end
+end

data/lib/rubex/ast/node/main_node.rb

@@ -0,0 +1,56 @@
+module Rubex
+  module AST
+    module Node
+      # Main class that acts as the apex node of the Rubex AST.
+      class MainNode < Base
+
+        # Central method that starts that processing of the AST. Called by Compiler.
+        #
+        # @param target_name [String] Target file name of the extension. The Init_
+        #   method is named after this.
+        # @param supervisor [Rubex::CodeSupervisor] Object for holding output code
+        #   for header and implementation code of each rubex file.
+        def process_statements(target_name, supervisor)
+          if target_name != @file_name
+            raise Rubex::TargetFileMismatchError,
+                  "target_name #{target_name} does not match @file_name #{@file_name}"
+          end
+          @scope = Rubex::SymbolTable::Scope::Klass.new('Object', nil)
+          add_top_statements_to_object_scope
+          create_symtab_entries_for_top_statements(@scope)
+          analyse_statement
+          rescan_declarations @scope
+          generate_common_utils_files supervisor
+          generate_header_and_implementation supervisor
+        end
+
+        def generate_common_utils_files supervisor
+          supervisor.init_file(Rubex::COMMON_UTILS_FILE)
+          header = supervisor.header(Rubex::COMMON_UTILS_FILE)
+          header.in_header_guard(Rubex::COMMON_UTILS_CONST) do
+            header << "#include <ruby.h>\n"
+            header << "#include <stdint.h>\n"
+            header << "#include <stdbool.h>\n"
+            header << "#include <math.h>\n"
+            write_usability_functions_header header
+            write_usability_macros header
+          end
+
+          code = supervisor.code(Rubex::COMMON_UTILS_FILE)
+          code.write_include(Rubex::COMMON_UTILS_FILE)
+          write_usability_functions_code code
+
+          Rubex::Compiler::CONFIG.add_dep(Rubex::COMMON_UTILS_FILE)
+        end
+
+        def generate_header_and_implementation(supervisor)
+          generate_header_file @file_name, supervisor.header(@file_name)
+          code_writer = supervisor.code(@file_name)
+          code_writer.write_include @file_name
+          generate_code supervisor
+          generate_init_method code_writer
+        end
+      end
+    end
+  end
+end

data/lib/rubex/ast/statement/begin_block/begin.rb

@@ -160,16 +160,17 @@ module Rubex
             'begin_block_' + local_scope.klass_name + '_' + local_scope.name + '_' +
               local_scope.begin_block_counter.to_s
           end
-
+          
           def create_c_function_to_house_statements(scope)
             func_name = @block_scope.name
             arg_list = Statement::ArgumentList.new([
                                                      AST::Expression::ArgDeclaration.new(
-                                                       { dtype: 'object', variables: [{ ident: 'dummy' }] }
+                                                     { dtype: 'object',
+                                                       variables: [{ ident: 'dummy' }] }
                                                      )
                                                    ])
             @begin_func = TopStatement::CFunctionDef.new(
-              'object', '', func_name, arg_list, @statements
+              'object', '', func_name, arg_list, nil, @statements
             )
             arg_list.analyse_statement @block_scope
             add_to_symbol_table @begin_func.name, arg_list, scope

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

@@ -8,7 +8,7 @@ module Rubex
           super(location)
           @name = array_ref.name
           @array_list = array_list
-          @dimension = array_ref.pos
+          @dimension = array_ref.pos[0]
           @type = Rubex::TYPE_MAPPINGS[type].new
         end
 

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

@@ -17,7 +17,9 @@ module Rubex
           @type = Helpers.determine_dtype @type, @ptr_level
           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
 
           @entry = local_scope.declare_var name: @name, c_name: @c_name,

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

@@ -0,0 +1,70 @@
+module Rubex
+  module AST
+    module Statement
+      class NoGilBlock < Base
+        def initialize statements
+          @statements = statements
+        end
+
+        def analyse_statement(local_scope)
+          local_scope.found_no_gil_block
+          @block_scope = Rubex::SymbolTable::Scope::NoGilBlock.new(
+            block_name(local_scope), local_scope)
+          create_c_function_to_house_statements local_scope.outer_scope
+          # TODO: check if ruby objects exist in the block. Raise error if yes.
+        end
+
+        def generate_code(code, local_scope)
+          code.nl
+          code << "/* no_gil block: */"
+          code.nl
+          super
+          cb_c_name = local_scope.find(@no_gil_func.name).c_name
+          code << "rb_thread_call_without_gvl(#{cb_c_name}, NULL, RUBY_UBF_PROCESS, NULL);"
+          code.nl
+        end
+
+        private
+
+        def block_name(local_scope)
+          "no_gil_block_" + local_scope.klass_name + "_" + local_scope.name + "_" +
+            local_scope.no_gil_block_counter.to_s
+        end
+
+        def create_c_function_to_house_statements(outer_scope)
+          func_name = @block_scope.name
+          arg_list = Statement::ArgumentList.new([
+                                                   AST::Expression::ArgDeclaration.new(
+                                                   {
+                                                     dtype: 'void',
+                                                     variables:
+                                                       [{
+                                                          ptr_level: "*",
+                                                          ident: 'dummy'
+                                                        }]
+                                                   })
+                                                 ])
+          @no_gil_func = TopStatement::CFunctionDef.new(
+            'void', '*', func_name, arg_list, nil, @statements)
+          arg_list.analyse_statement @block_scope
+          add_to_symbol_table @no_gil_func.name, arg_list, outer_scope
+          @no_gil_func.analyse_statement @block_scope
+          @block_scope.upgrade_symbols_to_global
+          outer_scope.add_no_gil_block_callback @no_gil_func
+        end
+
+        def add_to_symbol_table(func_name, arg_list, outer_scope)
+          c_name = Rubex::C_FUNC_PREFIX + func_name
+          outer_scope.add_c_method(
+            name: func_name,
+            c_name: c_name,
+            extern: false,
+            return_type: DataType::RubyObject.new,
+            arg_list: arg_list,
+            scope: @block_scope
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -27,6 +27,7 @@ module Rubex
             else
               t
             end
+
           @expression = @expression.to_ruby_object if local_scope.type.type.object?
 
           # TODO: Raise error if type as inferred from the

data/lib/rubex/ast/top_statement.rb

@@ -1 +1 @@
-Dir['./lib/rubex/ast/top_statement/**/*.rb'].sort.each { |f| require f }
+Dir[File.join(File.dirname(File.dirname(__FILE__)), "ast", "top_statement", "**", "*.rb" )].sort.each { |f| require f }

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

@@ -47,6 +47,10 @@ module Rubex
             cb.generate_code code
           end
 
+          @scope.no_gil_block_callbacks.each do |cb|
+            cb.generate_code code
+          end
+
           @statements.each do |stat|
             stat.generate_code code
           end

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

@@ -17,13 +17,13 @@ module Rubex
 
         def analyse_statement(outer_scope)
           super(outer_scope, attach_klass: true)
-          prepare_data_holding_struct
+          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)
+            if ruby_method_or_c_func_without_gil_lock?(stmt)
               rewrite_method_with_data_fetching stmt
             end
             stmt.analyse_statement @scope
@@ -72,6 +72,7 @@ module Rubex
               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 @@ module Rubex
             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 @@ module Rubex
           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 @@ module Rubex
               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
@@ -131,7 +144,7 @@ module Rubex
         # 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"
+         "data->#{Rubex::POINTER_PREFIX + @attached_type} = (#{c_name}*)xmalloc(sizeof(#{c_name}));\n"
         end
 
         # Actually write the dealloc function into C code.
@@ -198,7 +211,7 @@ module Rubex
 
         # 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
+        def prepare_data_holding_struct!
           struct_name = @name + '_data_struct'
           declarations = declarations_for_data_struct
           @data_struct = Statement::CStructOrUnionDef.new(
@@ -230,8 +243,8 @@ module Rubex
           prepare_get_struct_c_function
         end
 
-        def ruby_method_or_c_func?(stmt)
-          stmt.is_a?(RubyMethodDef) || stmt.is_a?(CFunctionDef)
+        def ruby_method_or_c_func_without_gil_lock?(stmt)
+          stmt.is_a?(RubyMethodDef) || (stmt.is_a?(CFunctionDef) && !stmt.no_gil)
         end
 
         # Rewrite method `stmt` so that the `data` variable becomes available
@@ -368,6 +381,71 @@ module Rubex
           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

data/lib/rubex/ast/top_statement/method_def.rb

@@ -6,7 +6,7 @@ module Rubex
         # 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.
+        #   case of auxillary C functions of attach classes.
         attr_accessor :arg_list
         # The statments/expressions contained within the method.
         attr_reader :statements
@@ -53,7 +53,7 @@ module Rubex
         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
@@ -104,7 +104,6 @@ module Rubex
           end
         end
       end
-
     end
   end
 end

data/lib/rubex/ast/top_statement/method_def/c_function_def.rb

@@ -2,25 +2,31 @@ module Rubex
   module AST
     module TopStatement
       class CFunctionDef < MethodDef
-        attr_reader :type, :return_ptr_level
+        attr_reader :type, :return_ptr_level, :no_gil
 
-        def initialize(type, return_ptr_level, name, arg_list, statements)
+        def initialize(type, return_ptr_level, name, arg_list, function_tags, statements)
           super(name, arg_list, statements)
           @type = type
           @return_ptr_level = return_ptr_level
+          @function_tags = function_tags
+          @no_gil = false
+          if @function_tags == "no_gil"
+            @no_gil = true
+          end
         end
 
         def analyse_statement(outer_scope, extern: false)
           super(outer_scope)
+          @entry.no_gil = @no_gil
         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))
+                                     c_name: @entry.c_name,
+                                     args: Helpers.create_arg_arrays(@arg_list))
           super code, c_function: true
         end
       end
-
     end
   end
 end