RubyInline 3.7.0 → 3.8.0

data/History.txt

@@ -1,3 +1,21 @@
+=== 3.8.0 / 2008-10-22
+
+* 8 minor enhancements:
+
+  * Inline::C now uses ZenTestMapping to automatically map C functions to ruby
+    names.
+  * Inline::C#map_c_const can now map to a ruby constant name.
+  * Added accessors for members of Data_Wrap_Structs.  See Inline::C#accessor.
+  * Added long long, unsigned long long, off_t types to built-in type map.
+  * Added #alias_type_converter and #remove_type_converter.
+  * Consider MinGW (mingw) as valid Windows platform.
+  * Properly fallback to all the environment options under Windows. #22511.
+  * Properly join path under OS with drive letters. #22292.
+
+* 1 bug fixes:
+
+  * Inline::C now uses rb_define_alloc_func().
+
 === 3.7.0 / 2008-06-09
 
 * 1 major enhancements:

data/Rakefile

@@ -3,6 +3,8 @@
 require 'rubygems'
 require 'hoe'
 
+Hoe.add_include_dirs "../../ZenTest/dev/lib"
+
 require './lib/inline.rb'
 
 Hoe.new("RubyInline", Inline::VERSION) do |inline|
@@ -11,6 +13,7 @@ Hoe.new("RubyInline", Inline::VERSION) do |inline|
   inline.clean_globs << File.expand_path("~/.ruby_inline")
   inline.spec_extras[:requirements] =
     "A POSIX environment and a compiler for your language."
+  inline.extra_deps << 'ZenTest' # ZenTest mapping
 end
 
 task :test => :clean

data/lib/inline.rb

@@ -52,6 +52,8 @@ require "digest/md5"
 require 'fileutils'
 require 'rubygems'
 
+require 'zentest_mapping'
+
 $TESTING = false unless defined? $TESTING
 
 class CompilationError < RuntimeError; end
@@ -63,9 +65,9 @@ class CompilationError < RuntimeError; end
 # the current namespace.
 
 module Inline
-  VERSION = '3.7.0'
+  VERSION = '3.8.0'
 
-  WINDOZE  = /win(32|64)/ =~ RUBY_PLATFORM
+  WINDOZE  = /mswin|mingw/ =~ RUBY_PLATFORM
   RUBINIUS = defined? RUBY_ENGINE
   DEV_NULL = (WINDOZE ? 'nul'      : '/dev/null')
   GEM      = (WINDOZE ? 'gem.bat'  : 'gem')
@@ -82,12 +84,34 @@ module Inline
 
   protected
 
+  # rootdir can be forced using INLINEDIR variable
+  # if not defined, it should store in user HOME folder
+  #
+  # Under Windows user data can be stored in several locations:
+  #
+  #  HOME
+  #  HOMEDRIVE + HOMEPATH
+  #  APPDATA
+  #  USERPROFILE
+  #
+  # Perform a check in that other to see if the environment is defined
+  # and if so, use it. only try this on Windows.
+
   def self.rootdir
     env = ENV['INLINEDIR'] || ENV['HOME']
 
-    # in case both INLINEDIR and HOME aren't defined, and under Windows
-    # default to HOMEDRIVE + HOMEPATH values
-    env = ENV['HOMEDRIVE'] + ENV['HOMEPATH'] if env.nil? and WINDOZE
+    if env.nil? and WINDOZE then
+      # try HOMEDRIVE + HOMEPATH combination
+      if ENV['HOMEDRIVE'] && ENV['HOMEPATH'] then
+        env = ENV['HOMEDRIVE'] + ENV['HOMEPATH']
+      end
+
+      # no HOMEDRIVE? use APPDATA
+      env = ENV['APPDATA'] if env.nil? and ENV['APPDATA']
+
+      # bummer, still no env? then fall to USERPROFILE
+      env = ENV['USERPROFILE'] if env.nil? and ENV['USERPROFILE']
+    end
 
     if env.nil? then
       abort "Define INLINEDIR or HOME in your environment and try again"
@@ -112,41 +136,46 @@ module Inline
     @@directory
   end
 
+  ##
   # Inline::C is the default builder used and the only one provided by
   # Inline. It can be used as a template to write builders for other
   # languages. It understands type-conversions for the basic types and
-  # can be extended as needed.
+  # can be extended as needed using #add_type_converter, #alias_type_converter
+  # and #remove_type_converter.
 
   class C
 
-    protected unless $TESTING
+    include ZenTestMapping
 
     MAGIC_ARITY_THRESHOLD = 15
     MAGIC_ARITY = -1
 
-    @@type_map = {
-      'char'          => [ 'NUM2CHR',  'CHR2FIX' ],
-      'char *'        => [ 'STR2CSTR', 'rb_str_new2' ],
-      'double'        => [ 'NUM2DBL',  'rb_float_new' ],
-      'int'           => [ 'F'+'IX2INT',  'INT2FIX' ],
-      'long'          => [ 'NUM2INT',  'INT2NUM' ],
-      'unsigned int'  => [ 'NUM2UINT', 'UINT2NUM' ],
-      'unsigned long' => [ 'NUM2UINT', 'UINT2NUM' ],
-      'unsigned'      => [ 'NUM2UINT', 'UINT2NUM' ],
-      'VALUE'         => [ '', '' ],
-      # Can't do these converters because they conflict with the above:
-      # ID2SYM(x), SYM2ID(x), NUM2DBL(x), F\IX2UINT(x)
-    }
+    ##
+    # Default C to ruby and ruby to C type map
 
-    def ruby2c(type)
-      raise ArgumentError, "Unknown type #{type.inspect}" unless @@type_map.has_key? type
-      @@type_map[type].first
-    end
+    TYPE_MAP = {
+      'char'               => [ 'NUM2CHR',        'CHR2FIX'      ],
 
-    def c2ruby(type)
-      raise ArgumentError, "Unknown type #{type.inspect}" unless @@type_map.has_key? type
-      @@type_map[type].last
-    end
+      'char *'             => [ 'StringValuePtr', 'rb_str_new2'  ],
+
+      'double'             => [ 'NUM2DBL',        'rb_float_new' ],
+
+      'int'                => [ "FI\X2INT",       'INT2FIX'      ],
+      'unsigned int'       => [ 'NUM2UINT',       'UINT2NUM'     ],
+      'unsigned'           => [ 'NUM2UINT',       'UINT2NUM'     ],
+
+      'long'               => [ 'NUM2LONG',       'LONG2NUM'     ],
+      'unsigned long'      => [ 'NUM2ULONG',      'ULONG2NUM'    ],
+
+      'long long'          => [ 'NUM2LL',         'LL2NUM'       ],
+      'unsigned long long' => [ 'NUM2ULL',        'ULL2NUM'      ],
+
+      'off_t'              => [ 'NUM2OFFT',       'OFFT2NUM'     ],
+
+      'VALUE'              => [ '',               ''             ],
+      # Can't do these converters because they conflict with the above:
+      # ID2SYM(x), SYM2ID(x), F\IX2UINT(x)
+    }
 
     def strip_comments(src)
       # strip c-comments
@@ -168,7 +197,7 @@ module Inline
       sig.gsub!(/\s+/, ' ')
 
       unless defined? @types then
-        @types = 'void|' + @@type_map.keys.map{|x| Regexp.escape(x)}.join('|')
+        @types = 'void|' + @type_map.keys.map{|x| Regexp.escape(x)}.join('|')
       end
 
       if /(#{@types})\s*(\w+)\s*\(([^)]*)\)/ =~ sig then
@@ -209,7 +238,8 @@ module Inline
 
       signature = parse_signature(src, !expand_types)
       function_name = signature['name']
-      method_name = options[:method_name] || function_name
+      method_name = options[:method_name]
+      method_name ||= test_to_normal function_name
       return_type = signature['return']
       arity = signature['arity']
 
@@ -262,6 +292,68 @@ module Inline
       return result if $TESTING
     end # def generate
 
+    ##
+    # Builds a complete C extension suitable for writing to a file and
+    # compiling.
+
+    def generate_ext
+      ext = []
+
+      if @include_ruby_first
+        @inc.unshift "#include \"ruby.h\""
+      else
+        @inc.push "#include \"ruby.h\""
+      end
+
+      ext << @inc
+      ext << nil
+      ext << @src.join("\n\n")
+      ext << nil
+      ext << nil
+      ext << "#ifdef __cplusplus"
+      ext << "extern \"C\" {"
+      ext << "#endif"
+      ext << "  __declspec(dllexport)" if WINDOZE
+      ext << "  void Init_#{module_name}() {"
+      ext << "    VALUE c = rb_cObject;"
+
+      # TODO: use rb_class2path
+      # ext << "    VALUE c = rb_path2class(#{@mod.name.inspect});"
+      ext << @mod.name.split("::").map { |n|
+        "    c = rb_const_get(c, rb_intern(\"#{n}\"));"
+      }.join("\n")
+
+      ext << nil
+
+      @sig.keys.sort.each do |name|
+        method = ''
+        arity, singleton, method_name = @sig[name]
+        if singleton then
+          if method_name == 'allocate' then
+            raise "#{@mod}::allocate must have an arity of zero" if arity > 0
+            ext << "    rb_define_alloc_func(c, (VALUE(*)(VALUE))#{name});"
+            next
+          end
+          method << "    rb_define_singleton_method(c, \"#{method_name}\", "
+        else
+          method << "    rb_define_method(c, \"#{method_name}\", "
+        end
+        method << "(VALUE(*)(ANYARGS))#{name}, #{arity});"
+        ext << method
+      end
+
+      ext << @init_extra.join("\n") unless @init_extra.empty?
+
+      ext << nil
+      ext << "  }"
+      ext << "#ifdef __cplusplus"
+      ext << "}"
+      ext << "#endif"
+      ext << nil
+
+      ext.join "\n"
+    end
+
     def module_name
       unless defined? @module_name then
         module_name = @mod.name.gsub('::','__')
@@ -280,12 +372,14 @@ module Inline
     end
 
     attr_reader :rb_file, :mod
-    if $TESTING then
-      attr_writer :mod
-      attr_accessor :src, :sig, :flags, :libs
-    end
+    attr_writer :mod
+    attr_accessor :src, :sig, :flags, :libs, :init_extra
 
-    public
+    ##
+    # Sets the name of the C struct for generating accessors.  Used with
+    # #accessor, #reader, #writer.
+
+    attr_accessor :struct_name
 
     def initialize(mod)
       raise ArgumentError, "Class/Module arg is required" unless Module === mod
@@ -295,9 +389,9 @@ module Inline
       raise "Couldn't discover caller" if stack.empty?
       real_caller = stack.first
       real_caller = stack[3] if real_caller =~ /\(eval\)/
-      real_caller = real_caller.split(/:/, 3)[0..1]
-      @real_caller = real_caller.join ':'
-      @rb_file = File.expand_path real_caller.first
+      real_caller =~ /(.*):(\d+)/
+      real_caller = $1
+      @rb_file = File.expand_path real_caller
 
       @mod = mod
       @src = []
@@ -307,6 +401,87 @@ module Inline
       @libs = []
       @init_extra = []
       @include_ruby_first = true
+      @inherited_methods = {}
+      @struct_name = nil
+
+      @type_map = TYPE_MAP.dup
+    end
+
+    ##
+    # Adds a #reader and #writer for a C struct member wrapped via
+    # Data_Wrap_Struct.  +method+ is the ruby name to give the accessor,
+    # +type+ is the C type.  Unless the C member name is overridden with
+    # +member+, the method name is used as the struct member.
+    #
+    #   builder.struct_name = 'MyStruct'
+    #   builder.accessor :title,        'char *'
+    #   builder.accessor :stream_index, 'int',   :index
+    #
+    # The latter accesses MyStruct->index via the stream_index method.
+
+    def accessor(method, type, member = method)
+      reader method, type, member
+      writer method, type, member
+    end
+
+    ##
+    # Adds a reader for a C struct member wrapped via Data_Wrap_Struct.
+    # +method+ is the ruby name to give the reader, +type+ is the C type.
+    # Unless the C member name is overridden with +member+, the method
+    # name is used as the struct member.  See #accessor for an example.
+
+    def reader(method, type, member = method)
+      raise "struct name not set for reader #{method} #{type}" unless
+        @struct_name
+
+      c <<-C
+VALUE #{method}() {
+  #{@struct_name} *pointer;
+
+  Data_Get_Struct(self, #{@struct_name}, pointer);
+
+  return #{c2ruby type}(pointer->#{member});
+}
+      C
+    end
+
+    ##
+    # Adds a writer for a C struct member wrapped via Data_Get_Struct.
+    # +method+ is the ruby name to give the writer, +type+ is the C type.
+    # Unless the C member name is overridden with +member+, the method
+    # name is used as the struct member.  See #accessor for an example.
+
+    def writer(method, type, member = method)
+      raise "struct name not set for writer #{method} #{type}" unless
+        @struct_name
+
+      c <<-C
+VALUE #{method}_equals(VALUE value) {
+  #{@struct_name} *pointer;
+
+  Data_Get_Struct(self, #{@struct_name}, pointer);
+
+  pointer->#{member} = #{ruby2c type}(value);
+
+  return value;
+}
+      C
+    end
+
+    ##
+    # Converts ruby type +type+ to a C type
+
+    def ruby2c(type)
+      raise ArgumentError, "Unknown type #{type.inspect}" unless @type_map.has_key? type
+      @type_map[type].first
+    end
+
+    ##
+    # Converts C type +type+ to a ruby type
+
+    def c2ruby(type)
+      raise ArgumentError, "Unknown type #{type.inspect}" unless @type_map.has_key? type
+      @type_map[type].last
     end
 
     ##
@@ -348,48 +523,7 @@ module Inline
         src_name = "#{Inline.directory}/#{module_name}.c"
         old_src_name = "#{src_name}.old"
         should_compare = File.write_with_backup(src_name) do |io|
-          if @include_ruby_first
-            @inc.unshift "#include \"ruby.h\""
-          else
-            @inc.push "#include \"ruby.h\""
-          end
-
-          io.puts
-          io.puts @inc.join("\n")
-          io.puts
-          io.puts @src.join("\n\n")
-          io.puts
-          io.puts
-          io.puts "#ifdef __cplusplus"
-          io.puts "extern \"C\" {"
-          io.puts "#endif"
-          io.puts "  __declspec(dllexport)" if WINDOZE
-          io.puts "  void Init_#{module_name}() {"
-          io.puts "    VALUE c = rb_cObject;"
-
-          # TODO: use rb_class2path
-          # io.puts "    VALUE c = rb_path2class(#{@mod.name.inspect});"
-          io.puts @mod.name.split("::").map { |n|
-            "    c = rb_const_get(c,rb_intern(\"#{n}\"));"
-          }.join("\n")
-
-          @sig.keys.sort.each do |name|
-            arity, singleton, method_name = @sig[name]
-            if singleton then
-              io.print "    rb_define_singleton_method(c, \"#{method_name}\", "
-            else
-              io.print "    rb_define_method(c, \"#{method_name}\", "
-            end
-            io.puts  "(VALUE(*)(ANYARGS))#{name}, #{arity});"
-          end
-          io.puts @init_extra.join("\n") unless @init_extra.empty?
-
-          io.puts
-          io.puts "  }"
-          io.puts "#ifdef __cplusplus"
-          io.puts "}"
-          io.puts "#endif"
-          io.puts
+          io.puts generate_ext
         end
 
         # recompile only if the files are different
@@ -518,8 +652,25 @@ module Inline
     # Registers C type-casts +r2c+ and +c2r+ for +type+.
 
     def add_type_converter(type, r2c, c2r)
-      warn "WAR\NING: overridding #{type} on #{caller[0]}" if @@type_map.has_key? type
-      @@type_map[type] = [r2c, c2r]
+      warn "WAR\NING: overridding #{type} on #{caller[0]}" if @type_map.has_key? type
+      @type_map[type] = [r2c, c2r]
+    end
+
+    ##
+    # Registers C type +alias_type+ as an alias of +existing_type+
+
+    def alias_type_converter(existing_type, alias_type)
+      warn "WAR\NING: overridding #{type} on #{caller[0]}" if
+        @type_map.has_key? alias_type
+
+      @type_map[alias_type] = @type_map[existing_type]
+    end
+
+    ##
+    # Unregisters C type-casts for +type+.
+
+    def remove_type_converter(type)
+      @type_map.delete type
     end
 
     ##
@@ -533,13 +684,19 @@ module Inline
     end
 
     ##
-    # Maps a C constant to ruby (with the same
-    # name). +names_and_types+ is a hash that maps the name of the
-    # constant to its C type.
+    # Maps a C constant to ruby. +names_and_types+ is a hash that maps the
+    # name of the constant to its C type.
+    #
+    #   builder.map_c_const :C_NAME => :int
+    #
+    # If you wish to give the constant a different ruby name:
+    #
+    #   builder.map_c_const :C_NAME => [:int, :RUBY_NAME]
 
     def map_c_const(names_and_types)
       names_and_types.each do |name, typ|
-        self.add_to_init "    rb_define_const(c, #{name.to_s.inspect}, #{c2ruby(typ.to_s)}(#{name}));"
+        typ, ruby_name = Array === typ ? typ : [typ, name]
+        self.add_to_init "    rb_define_const(c, #{ruby_name.to_s.inspect}, #{c2ruby(typ.to_s)}(#{name}));"
       end
     end
 

data/test/test_inline.rb

@@ -16,7 +16,6 @@ class InlineTestCase < Test::Unit::TestCase
     @rootdir = File.join(Dir.tmpdir, "test_inline.#{$$}")
     Dir.mkdir @rootdir, 0700 unless test ?d, @rootdir
     ENV['INLINEDIR'] = @rootdir
-    Dir.mkdir Inline.directory, 0700
   end
 
   def teardown
@@ -101,16 +100,265 @@ class TestC < InlineTestCase
     assert_equal [], x.libs
   end
 
+  def test_accessor
+    builder = Inline::C.new self.class
+
+    builder.struct_name = 'MyStruct'
+    builder.accessor 'method_name', 'int'
+
+    source = util_strip_lines builder.src
+
+    expected = []
+    expected << <<-READER
+# line N "./lib/inline.rb"
+static VALUE method_name(VALUE self) {
+
+  MyStruct *pointer;
+
+  Data_Get_Struct(self, MyStruct, pointer);
+
+  return (INT2FIX(pointer->method_name));
+}
+    READER
+
+    expected << <<-WRITER
+# line N "./lib/inline.rb"
+static VALUE method_name_equals(VALUE self, VALUE _value) {
+  VALUE value = (_value);
+
+  MyStruct *pointer;
+
+  Data_Get_Struct(self, MyStruct, pointer);
+
+  pointer->method_name = FIX2INT(value);
+
+  return (value);
+}
+    WRITER
+
+    assert_equal expected, source
+  end
+
+  def test_accessor_member_name
+    builder = Inline::C.new self.class
+
+    builder.struct_name = 'MyStruct'
+    builder.accessor 'method_name', 'int', 'member_name'
+
+    source = util_strip_lines builder.src
+
+    expected = []
+    expected << <<-READER
+# line N "./lib/inline.rb"
+static VALUE method_name(VALUE self) {
+
+  MyStruct *pointer;
+
+  Data_Get_Struct(self, MyStruct, pointer);
+
+  return (INT2FIX(pointer->member_name));
+}
+    READER
+
+    expected << <<-WRITER
+# line N "./lib/inline.rb"
+static VALUE method_name_equals(VALUE self, VALUE _value) {
+  VALUE value = (_value);
+
+  MyStruct *pointer;
+
+  Data_Get_Struct(self, MyStruct, pointer);
+
+  pointer->member_name = FIX2INT(value);
+
+  return (value);
+}
+    WRITER
+
+    assert_equal expected, source
+  end
+
+  def test_accessor_no_struct_name
+    builder = Inline::C.new self.class
+
+    e = assert_raises RuntimeError do
+      builder.accessor 'method_name', 'int'
+    end
+
+    assert_equal "struct name not set for reader method_name int", e.message
+  end
+
+  def test_add_type_converter
+    builder = Inline::C.new self.class
+
+    builder.add_type_converter 'my_type', 'ruby_type2my_type',
+                               'my_type2ruby_type'
+
+    assert_equal 'my_type2ruby_type', builder.c2ruby('my_type')
+    assert_equal 'ruby_type2my_type', builder.ruby2c('my_type')
+  end
+
+  def test_alias_type_converter
+    builder = Inline::C.new self.class
+
+    builder.alias_type_converter 'long long', 'int64_t'
+
+    assert_equal 'LL2NUM', builder.c2ruby('int64_t')
+    assert_equal 'NUM2LL', builder.ruby2c('int64_t')
+  end
+
+  def test_reader
+    builder = Inline::C.new self.class
+
+    builder.struct_name = 'MyStruct'
+    builder.reader 'method_name', 'int'
+
+    source = util_strip_lines builder.src
+
+    expected = []
+    expected << <<-READER
+# line N "./lib/inline.rb"
+static VALUE method_name(VALUE self) {
+
+  MyStruct *pointer;
+
+  Data_Get_Struct(self, MyStruct, pointer);
+
+  return (INT2FIX(pointer->method_name));
+}
+    READER
+
+    assert_equal expected, source
+  end
+
+  def test_reader_member_name
+    builder = Inline::C.new self.class
+
+    builder.struct_name = 'MyStruct'
+    builder.reader 'method_name', 'int', 'member_name'
+
+    source = util_strip_lines builder.src
+
+    expected = []
+    expected << <<-READER
+# line N "./lib/inline.rb"
+static VALUE method_name(VALUE self) {
+
+  MyStruct *pointer;
+
+  Data_Get_Struct(self, MyStruct, pointer);
+
+  return (INT2FIX(pointer->member_name));
+}
+    READER
+
+    assert_equal expected, source
+  end
+
+  def test_reader_no_struct_name
+    builder = Inline::C.new self.class
+
+    e = assert_raises RuntimeError do
+      builder.reader 'method_name', 'int'
+    end
+
+    assert_equal "struct name not set for reader method_name int", e.message
+  end
+
+  def test_remove_type_converter
+    builder = Inline::C.new self.class
+
+    builder.remove_type_converter 'long'
+
+    assert_raises ArgumentError do
+      builder.c2ruby 'long'
+    end
+  end
+
+  def test_writer
+    builder = Inline::C.new self.class
+
+    builder.struct_name = 'MyStruct'
+    builder.writer 'method_name', 'int'
+
+    source = util_strip_lines builder.src
+
+    expected = []
+    expected << <<-WRITER
+# line N "./lib/inline.rb"
+static VALUE method_name_equals(VALUE self, VALUE _value) {
+  VALUE value = (_value);
+
+  MyStruct *pointer;
+
+  Data_Get_Struct(self, MyStruct, pointer);
+
+  pointer->method_name = FIX2INT(value);
+
+  return (value);
+}
+    WRITER
+
+    assert_equal expected, source
+  end
+
+  def test_writer_member_name
+    builder = Inline::C.new self.class
+
+    builder.struct_name = 'MyStruct'
+    builder.writer 'method_name', 'int', 'member_name'
+
+    source = util_strip_lines builder.src
+
+    expected = []
+    expected << <<-WRITER
+# line N "./lib/inline.rb"
+static VALUE method_name_equals(VALUE self, VALUE _value) {
+  VALUE value = (_value);
+
+  MyStruct *pointer;
+
+  Data_Get_Struct(self, MyStruct, pointer);
+
+  pointer->member_name = FIX2INT(value);
+
+  return (value);
+}
+    WRITER
+
+    assert_equal expected, source
+  end
+
+  def test_writer_no_struct_name
+    builder = Inline::C.new self.class
+
+    e = assert_raises RuntimeError do
+      builder.writer 'method_name', 'int'
+    end
+
+    assert_equal "struct name not set for writer method_name int", e.message
+  end
+
   def test_ruby2c
     x = Inline::C.new(self.class)
-    assert_equal 'NUM2CHR',  x.ruby2c("char")
-    assert_equal 'STR2CSTR', x.ruby2c("char *")
-    assert_equal 'FIX2INT',  x.ruby2c("int")
-    assert_equal 'NUM2INT',  x.ruby2c("long")
-    assert_equal 'NUM2UINT', x.ruby2c("unsigned int")
-    assert_equal 'NUM2UINT', x.ruby2c("unsigned long")
-    assert_equal 'NUM2UINT', x.ruby2c("unsigned")
-    assert_equal '',         x.ruby2c("VALUE")
+    assert_equal 'NUM2CHR',        x.ruby2c("char")
+    assert_equal 'StringValuePtr', x.ruby2c("char *")
+
+    assert_equal "FI\X2INT",       x.ruby2c("int")
+    assert_equal 'NUM2UINT',       x.ruby2c("unsigned")
+    assert_equal 'NUM2UINT',       x.ruby2c("unsigned int")
+
+    assert_equal 'NUM2LONG',       x.ruby2c("long")
+    assert_equal 'NUM2ULONG',      x.ruby2c("unsigned long")
+
+    assert_equal 'NUM2LL',         x.ruby2c("long long")
+    assert_equal 'NUM2ULL',        x.ruby2c("unsigned long long")
+
+    assert_equal 'NUM2DBL',        x.ruby2c("double")
+
+    assert_equal 'NUM2OFFT',       x.ruby2c("off_t")
+
+    assert_equal '',               x.ruby2c("VALUE")
 
     assert_raises ArgumentError do
       x.ruby2c('blah')
@@ -119,14 +367,25 @@ class TestC < InlineTestCase
 
   def test_c2ruby
     x = Inline::C.new(self.class)
-    assert_equal 'CHR2FIX',     x.c2ruby("char")
-    assert_equal 'rb_str_new2', x.c2ruby("char *")
-    assert_equal 'INT2FIX',     x.c2ruby("int")
-    assert_equal 'INT2NUM',     x.c2ruby("long")
-    assert_equal 'UINT2NUM',    x.c2ruby("unsigned int")
-    assert_equal 'UINT2NUM',    x.c2ruby("unsigned long")
-    assert_equal 'UINT2NUM',    x.c2ruby("unsigned")
-    assert_equal '',            x.c2ruby("VALUE")
+    assert_equal 'CHR2FIX',      x.c2ruby("char")
+
+    assert_equal 'rb_str_new2',  x.c2ruby("char *")
+
+    assert_equal 'INT2FIX',      x.c2ruby("int")
+    assert_equal 'UINT2NUM',     x.c2ruby("unsigned int")
+    assert_equal 'UINT2NUM',     x.c2ruby("unsigned")
+
+    assert_equal 'LONG2NUM',     x.c2ruby("long")
+    assert_equal 'ULONG2NUM',    x.c2ruby("unsigned long")
+
+    assert_equal 'LL2NUM',       x.c2ruby("long long")
+    assert_equal 'ULL2NUM',      x.c2ruby("unsigned long long")
+
+    assert_equal 'rb_float_new', x.c2ruby("double")
+
+    assert_equal 'OFFT2NUM',     x.c2ruby("off_t")
+
+    assert_equal '',             x.c2ruby("VALUE")
 
     assert_raises ArgumentError do
       x.c2ruby('blah')
@@ -244,11 +503,12 @@ class TestC < InlineTestCase
 
 
     util_parse_signature(src, expected,
-             "register int", 'FIX2INT', 'INT2FIX')
+             "register int", "FI\X2INT", "INT2FI\X")
   end
 
   def util_generate(src, expected, expand_types=true)
     result = @builder.generate src, expand_types
+    result = util_strip_lines result
     result.gsub!(/\# line \d+/, '# line N')
     expected = "# line N \"#{$0}\"\n" + expected
     assert_equal(expected, result)
@@ -258,6 +518,17 @@ class TestC < InlineTestCase
     util_generate(src, expected, false)
   end
 
+  def util_strip_lines(src)
+    case src
+    when String then
+      src.gsub(/\# line \d+/, '# line N')
+    when Array then
+      src.map do |chunk|
+        util_strip_lines chunk
+      end
+    end
+  end
+
   # Ruby Arity Rules, from the mouth of Matz:
   # -2 = ruby array argv
   # -1 = c array argv
@@ -409,6 +680,16 @@ static VALUE add(VALUE self, VALUE _x, VALUE _y) {
     util_generate(src, expected)
   end
 
+  def test_generate_map_name
+    src = "VALUE y_equals(VALUE self) {blah;}"
+
+    expected = "static VALUE y_equals(VALUE self) {blah;}"
+
+    util_generate_raw(src, expected)
+
+    assert_equal [-1, nil, 'y='], @builder.sig['y_equals']
+  end
+
   def test_generate_system_header
     src = "// stupid cpp comment
 #include <header>
@@ -433,7 +714,7 @@ static VALUE add(VALUE self, VALUE _x, VALUE _y) {
     src = "unsigned\nlong z(void) {return 42}"
 
     expected = "static VALUE z(VALUE self) {
-return UINT2NUM(42)}"
+return ULONG2NUM(42)}"
 
     util_generate(src, expected)
   end
@@ -453,12 +734,62 @@ return INT2FIX(x+y)}"
     src = "char\n\*\n  blah(  char*s) {puts(s); return s}"
 
     expected = "static VALUE blah(VALUE self, VALUE _s) {
-  char * s = STR2CSTR(_s);
+  char * s = StringValuePtr(_s);
 puts(s); return rb_str_new2(s)}"
 
     util_generate(src, expected)
   end
 
+  def test_generate_ext
+    @builder.c_singleton "VALUE allocate() { return Qnil; }"
+
+    @builder.c "VALUE my_method() { return Qnil; }"
+
+    windoze = "\n  __declspec(dllexport)" if Inline::WINDOZE
+
+    expected = <<-EXT
+#include "ruby.h"
+
+# line N "./test/test_inline.rb"
+static VALUE allocate(VALUE self) {
+ return (Qnil); }
+
+# line N "./test/test_inline.rb"
+static VALUE my_method(VALUE self) {
+ return (Qnil); }
+
+
+#ifdef __cplusplus
+extern \"C\" {
+#endif#{windoze}
+  void Init_Inline_TestInline__TestC_eba5() {
+    VALUE c = rb_cObject;
+    c = rb_const_get(c, rb_intern("TestInline"));
+    c = rb_const_get(c, rb_intern("TestC"));
+
+    rb_define_alloc_func(c, (VALUE(*)(VALUE))allocate);
+    rb_define_method(c, "my_method", (VALUE(*)(ANYARGS))my_method, 0);
+
+  }
+#ifdef __cplusplus
+}
+#endif
+    EXT
+
+    assert_equal expected, util_strip_lines(@builder.generate_ext)
+  end
+
+  def test_generate_ext_bad_allocate
+    @builder.c_singleton "VALUE allocate(VALUE bad) { return Qnil; }"
+
+    e = assert_raise RuntimeError do
+      @builder.generate_ext
+    end
+
+    assert_equal 'TestInline::TestC::allocate must have an arity of zero',
+                 e.message
+  end
+
   def test_c
     result = @builder.c "int add(int a, int b) { return a + b; }"
 
@@ -481,6 +812,26 @@ puts(s); return rb_str_new2(s)}"
     assert_equal [expected], @builder.src
   end
 
+  def test_map_c_const
+    @builder.map_c_const :C_NAME => :int
+
+    expected = [
+      "    rb_define_const(c, \"C_NAME\", INT2FIX(C_NAME));"
+    ]
+
+    assert_equal expected, @builder.init_extra
+  end
+
+  def test_map_c_const_named
+    @builder.map_c_const :C_NAME => [:int, :RUBY_NAME]
+
+    expected = [
+      "    rb_define_const(c, \"RUBY_NAME\", INT2FIX(C_NAME));"
+    ]
+
+    assert_equal expected, @builder.init_extra
+  end
+
   # TODO: fix ?
   def util_simple_code(klassname, c_src)
     result = "

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: RubyInline
 version: !ruby/object:Gem::Version 
-  version: 3.7.0
+  version: 3.8.0
 platform: ruby
 authors: 
 - Ryan Davis
@@ -9,17 +9,28 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-06-09 00:00:00 -07:00
+date: 2008-10-22 00:00:00 -05:00
 default_executable: 
 dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ZenTest
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
 - !ruby/object:Gem::Dependency 
   name: hoe
+  type: :development
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        version: 1.5.3
+        version: 1.8.0
     version: 
 description: Inline allows you to write foreign code within your ruby code. It automatically determines if the code in question has changed and builds it only when necessary. The extensions are then automatically loaded into the class/module that defines it.  You can even write extra builders that will allow you to write inlined code in any language. Use Inline::C as a template and look at Module#inline for the required API.
 email: 
@@ -68,7 +79,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: 
 - A POSIX environment and a compiler for your language.
 rubyforge_project: rubyinline
-rubygems_version: 1.1.1
+rubygems_version: 1.3.0
 signing_key: 
 specification_version: 2
 summary: Inline allows you to write foreign code within your ruby code