Object
TRANSFER_TYPE = $TESTING ? 'unsigned long' : 'VALUE'
# File lib/inline_acceleration.rb, line 121 def self.internal_c_functions @@internal_c_functions end
# File lib/inline_acceleration.rb, line 125 def self.internal_c_functions_module @@internal_c_functions_module end
# File lib/inline_acceleration.rb, line 134 def initialize(mod) initialize_orig(mod) if @@internal_c_functions_module.nil? @@internal_c_functions.each { |function| self.c_singleton(function) } @@internal_c_functions_module = mod end @eval_on_load = '' end
# File lib/inline_acceleration.rb, line 310 def link_constants(type, names) names.each do |name| get_constant_method = "get_constant_#{name}" self.c_singleton #{type} #{get_constant_method}(void) { return #{name}; } @eval_on_load << #{@mod.name}.const_set(:#{name}, #{get_constant_method}) end end
# File lib/inline_acceleration.rb, line 184 def link_fields(struct_name, field_hash) field_hash.each do |field_name, c_type| delegate_function_name = "#{struct_name.gsub(' ', '_')}_#{field_name}" type = Type.new(c_type, link_type(c_type)) #build c delegate c_code = #{type.c_transfer_type} #{delegate_function_name}(#{TRANSFER_TYPE} pointer) { #{type.c_transfer_type} result = (#{type.c_transfer_type}) ((#{struct_name}*) pointer)->#{field_name}; #{type.is_simple_type? ? 'return result;' : "if(result) { return result; } else { return(Qfalse); }"} } # puts c_code self.c_singleton c_code #build ruby delegate line = __LINE__; ruby_code = def #{field_name} result = (#{@mod.name}.#{delegate_function_name}(memory_address)) #{type.is_pointer_type? ? 'return nil if !result' : ''} #{type.ruby_type_conversion}(result) end # puts ruby_code link_type("#{struct_name}*").class_eval ruby_code, __FILE__, line + 1 end end
# File lib/inline_acceleration.rb, line 149 def link_function(c_return_type, function_name, parameter_types) delegate_function_name = "C_delegate_#{function_name}" return_type = Type.new(c_return_type, link_type(c_return_type)) parameters = parameter_types.map_with_indices { |type, index| Parameter.new(type, link_type(type), index) } #build c delegate c_code = #{return_type.c_transfer_type} #{delegate_function_name}(#{parameters.c_method_parameters.join(', ')}) { #{return_type.void? ? '' : "return (#{return_type.c_transfer_type})"} #{function_name}(#{parameters.c_casted_call_args.join(', ')}); } # puts c_code self.c_singleton c_code #build ruby delegate line = __LINE__; ruby_code = def self.#{function_name}(#{parameters.ruby_method_parameters.join(', ')}) #{parameters.ruby_ref_assigns.reject_nils.join('; ')} return_values = [] #{return_type.void? ? '' : ('return_values << ' + return_type.ruby_type_conversion)}(#{delegate_function_name}(#{parameters.ruby_transformed_call_args.join(', ')})) #{parameters.ruby_converted_return_values.reject_nils.prefix('return_values << ').join('; ')} case return_values.size when 0: nil when 1: return_values[0] else return_values end end def #{function_name}(#{parameters.ruby_method_parameters.join(', ')}) self.class.#{function_name}(#{parameters.arg_names.join(', ')}) end # puts ruby_code @mod.class_eval ruby_code, __FILE__, line + 1 end
# File lib/inline_acceleration.rb, line 212 def link_type(c_type, reallocate_pointers=false, &block) is_simple_type = @@type_map.has_key?(c_type) is_pointer = c_type[-1..-1] == '*' return nil if is_simple_type return Value if !is_pointer c_inner_type = c_type[0..-2].strip class_name = c_inner_type.gsub(' ', '_').capitalize klass = "#{@mod.name}::#{class_name}".to_class if !klass inner_type = Type.new(c_inner_type, nil) is_simple_type = @@type_map.has_key?(c_inner_type) klass = Class.new() @mod.const_set(class_name.to_sym, klass) line = __LINE__; ruby_code = include Inline::C::Pointer def dereference #{link_type('void *').name}.new(Inline::C.internal_c_functions_module.C_Pointer_dereference_to_pointer(memory_address)) end alias_method :throw_method_missing, :method_missing def method_missing(name, *args, &block) if name.to_s[0..2] == 'to_' type = name.to_s[3..-1] klass = ("#{@mod.name}::" + type.capitalize).to_class return klass.new(memory_address, ruby_managed) end throw_method_missing(name, *args, &block) end klass.class_eval ruby_code, __FILE__, line + 1 if !inner_type.void? create_pointer_from_data_function_name = "#{class_name}_create_pointer_from_data" create_pointer_from_pointer_function_name = "#{class_name}_create_pointer_from_pointer" get_array_entry_function_name = "#{class_name}_get_array_entry" #create pointer from data c_code = #{TRANSFER_TYPE} #{create_pointer_from_data_function_name}(#{is_simple_type ? c_inner_type : TRANSFER_TYPE} source) { #{c_type} pointer = (#{c_type}) malloc(sizeof(#{c_inner_type})); memcpy(pointer, &source, sizeof(#{c_inner_type})); return (#{TRANSFER_TYPE}) pointer; } self.c_singleton c_code #create pointer from pointer c_code = #{TRANSFER_TYPE} #{create_pointer_from_pointer_function_name}(#{TRANSFER_TYPE} source) { #{c_type} pointer = (#{c_type}) malloc(sizeof(#{c_inner_type})); *pointer = *((#{c_type}) source); return (#{TRANSFER_TYPE}) pointer; } self.c_singleton c_code #array delegate c_code = #{TRANSFER_TYPE} #{get_array_entry_function_name}(#{TRANSFER_TYPE} source, long index) { return (#{TRANSFER_TYPE}) &((#{c_type}) source)[index]; } self.c_singleton c_code line = __LINE__; ruby_code = @@reallocate_pointers = #{reallocate_pointers} def self.reallocate_pointers? @@reallocate_pointers end def self.create(source=0) if source.is_a? Inline::C::Pointer if !@@reallocate_pointers source else self.new(#{@mod.name}.#{create_pointer_from_pointer_function_name}(source.memory_address), true) end else self.new(#{@mod.name}.#{create_pointer_from_data_function_name}(Inline::C::Value.get_data(source)), true) end end def [](index) self.class.new(#{@mod.name}.#{get_array_entry_function_name}(self.memory_address, index), self.ruby_managed) end klass.class_eval ruby_code, __FILE__, line + 1 end end klass.class_eval(&block) if block klass end
# File lib/inline_acceleration.rb, line 144 def load load_orig @mod.class_eval(@eval_on_load) end
Generated with the Darkfish Rdoc Generator 2.