fiddle 1.0.0.beta2 → 1.0.4

data/bin/extlibs.rb

@@ -0,0 +1,262 @@
+#!/usr/bin/ruby
+
+# Used to download, extract and patch extension libraries (extlibs)
+# for Ruby. See common.mk for Ruby's usage.
+
+require 'digest'
+require_relative 'downloader'
+
+class Vars < Hash
+  def pattern
+    /\$\((#{Regexp.union(keys)})\)/
+  end
+
+  def expand(str)
+    if empty?
+      str
+    else
+      str.gsub(pattern) {self[$1]}
+    end
+  end
+end
+
+class ExtLibs
+  def cache_file(url, cache_dir)
+    Downloader.cache_file(url, nil, :cache_dir => cache_dir)
+  end
+
+  def do_download(url, cache_dir)
+    Downloader.download(url, nil, nil, nil, :cache_dir => cache_dir)
+  end
+
+  def do_checksum(cache, chksums)
+    chksums.each do |sum|
+      name, sum = sum.split(/:/)
+      if $VERBOSE
+        $stdout.print "checking #{name} of #{cache} ..."
+        $stdout.flush
+      end
+      hd = Digest(name.upcase).file(cache).hexdigest
+      if hd == sum
+        if $VERBOSE
+          $stdout.puts " OK"
+          $stdout.flush
+        end
+      else
+        if $VERBOSE
+          $stdout.puts " NG"
+          $stdout.flush
+        end
+        raise "checksum mismatch: #{cache}, #{name}:#{hd}, expected #{sum}"
+      end
+    end
+  end
+
+  def do_extract(cache, dir)
+    if $VERBOSE
+      $stdout.puts "extracting #{cache} into #{dir}"
+      $stdout.flush
+    end
+    ext = File.extname(cache)
+    case ext
+    when '.gz', '.tgz'
+      f = IO.popen(["gzip", "-dc", cache])
+      cache = cache.chomp('.gz')
+    when '.bz2', '.tbz'
+      f = IO.popen(["bzip2", "-dc", cache])
+      cache = cache.chomp('.bz2')
+    when '.xz', '.txz'
+      f = IO.popen(["xz", "-dc", cache])
+      cache = cache.chomp('.xz')
+    else
+      inp = cache
+    end
+    inp ||= f.binmode
+    ext = File.extname(cache)
+    case ext
+    when '.tar', /\A\.t[gbx]z\z/
+      pid = Process.spawn("tar", "xpf", "-", in: inp, chdir: dir)
+    when '.zip'
+      pid = Process.spawn("unzip", inp, "-d", dir)
+    end
+    f.close if f
+    Process.wait(pid)
+    $?.success? or raise "failed to extract #{cache}"
+  end
+
+  def do_patch(dest, patch, args)
+    if $VERBOSE
+      $stdout.puts "applying #{patch} under #{dest}"
+      $stdout.flush
+    end
+    Process.wait(Process.spawn("patch", "-d", dest, "-i", patch, *args))
+    $?.success? or raise "failed to patch #{patch}"
+  end
+
+  def do_link(file, src, dest)
+    file = File.join(dest, file)
+    if (target = src).start_with?("/")
+      target = File.join([".."] * file.count("/"), src)
+    end
+    return unless File.exist?(File.expand_path(target, File.dirname(file)))
+    File.unlink(file) rescue nil
+    begin
+      File.symlink(target, file)
+    rescue
+    else
+      if $VERBOSE
+        $stdout.puts "linked #{target} to #{file}"
+        $stdout.flush
+      end
+      return
+    end
+    begin
+      src = src.sub(/\A\//, '')
+      File.copy_stream(src, file)
+    rescue
+      if $VERBOSE
+        $stdout.puts "failed to link #{src} to #{file}: #{$!.message}"
+      end
+    else
+      if $VERBOSE
+        $stdout.puts "copied #{src} to #{file}"
+      end
+    end
+  end
+
+  def do_exec(command, dir, dest)
+    dir = dir ? File.join(dest, dir) : dest
+    if $VERBOSE
+      $stdout.puts "running #{command.dump} under #{dir}"
+      $stdout.flush
+    end
+    system(command, chdir: dir) or raise "failed #{command.dump}"
+  end
+
+  def do_command(mode, dest, url, cache_dir, chksums)
+    extracted = false
+    base = /.*(?=\.tar(?:\.\w+)?\z)/
+
+    case mode
+    when :download
+      cache = do_download(url, cache_dir)
+      do_checksum(cache, chksums)
+    when :extract
+      cache = cache_file(url, cache_dir)
+      target = File.join(dest, File.basename(cache)[base])
+      unless File.directory?(target)
+        do_checksum(cache, chksums)
+        extracted = do_extract(cache, dest)
+      end
+    when :all
+      cache = do_download(url, cache_dir)
+      target = File.join(dest, File.basename(cache)[base])
+      unless File.directory?(target)
+        do_checksum(cache, chksums)
+        extracted = do_extract(cache, dest)
+      end
+    end
+    extracted
+  end
+
+  def run(argv)
+    cache_dir = nil
+    mode = :all
+    until argv.empty?
+      case argv[0]
+      when '--download'
+        mode = :download
+      when '--extract'
+        mode = :extract
+      when '--patch'
+        mode = :patch
+      when '--all'
+        mode = :all
+      when '--cache'
+        argv.shift
+        cache_dir = argv[0]
+      when /\A--cache=/
+        cache_dir = $'
+      when '--'
+        argv.shift
+        break
+      when /\A-/
+        warn "unknown option: #{argv[0]}"
+        return false
+      else
+        break
+      end
+      argv.shift
+    end
+
+    success = true
+    argv.each do |dir|
+      Dir.glob("#{dir}/**/extlibs") do |list|
+        if $VERBOSE
+          $stdout.puts "downloading for #{list}"
+          $stdout.flush
+        end
+        vars = Vars.new
+        extracted = false
+        dest = File.dirname(list)
+        url = chksums = nil
+        IO.foreach(list) do |line|
+          line.sub!(/\s*#.*/, '')
+          if /^(\w+)\s*=\s*(.*)/ =~ line
+            vars[$1] = vars.expand($2)
+            next
+          end
+          if chksums
+            chksums.concat(line.split)
+          elsif /^\t/ =~ line
+            if extracted and (mode == :all or mode == :patch)
+              patch, *args = line.split.map {|s| vars.expand(s)}
+              do_patch(dest, patch, args)
+            end
+            next
+          elsif /^!\s*(?:chdir:\s*([^|\s]+)\|\s*)?(.*)/ =~ line
+            if extracted and (mode == :all or mode == :patch)
+              command = vars.expand($2.strip)
+              chdir = $1 and chdir = vars.expand(chdir)
+              do_exec(command, chdir, dest)
+            end
+            next
+          elsif /->/ =~ line
+            if extracted and (mode == :all or mode == :patch)
+              link, file = $`.strip, $'.strip
+              do_link(vars.expand(link), vars.expand(file), dest)
+            end
+            next
+          else
+            url, *chksums = line.split(' ')
+          end
+          if chksums.last == '\\'
+            chksums.pop
+            next
+          end
+          unless url
+            chksums = nil
+            next
+          end
+          url = vars.expand(url)
+          begin
+            extracted = do_command(mode, dest, url, cache_dir, chksums)
+          rescue => e
+            warn e.inspect
+            success = false
+          end
+          url = chksums = nil
+        end
+      end
+    end
+    success
+  end
+
+  def self.run(argv)
+    self.new.run(argv)
+  end
+end
+
+if $0 == __FILE__
+  exit ExtLibs.run(ARGV)
+end

data/ext/fiddle/closure.c

@@ -13,11 +13,12 @@ typedef struct {
     ffi_type **argv;
 } fiddle_closure;
 
-#if defined(USE_FFI_CLOSURE_ALLOC)
-#elif defined(__OpenBSD__) || defined(__APPLE__) || defined(__linux__)
+#if defined(__OpenBSD__)
 # define USE_FFI_CLOSURE_ALLOC 0
-#elif defined(RUBY_LIBFFI_MODVERSION) && RUBY_LIBFFI_MODVERSION < 3000005 && \
-	(defined(__i386__) || defined(__x86_64__) || defined(_M_IX86) || defined(_M_AMD64))
+#endif
+
+#if defined(USE_FFI_CLOSURE_ALLOC)
+#elif !defined(HAVE_FFI_CLOSURE_ALLOC)
 # define USE_FFI_CLOSURE_ALLOC 0
 #else
 # define USE_FFI_CLOSURE_ALLOC 1

data/ext/fiddle/conversions.c

@@ -1,7 +1,159 @@
 #include <fiddle.h>
 
+VALUE
+rb_fiddle_type_ensure(VALUE type)
+{
+    VALUE original_type = type;
+
+    if (!RB_SYMBOL_P(type)) {
+        VALUE type_string = rb_check_string_type(type);
+        if (!NIL_P(type_string)) {
+            type = rb_to_symbol(type_string);
+        }
+    }
+
+    if (RB_SYMBOL_P(type)) {
+        ID type_id = rb_sym2id(type);
+        ID void_id;
+        ID voidp_id;
+        ID char_id;
+        ID short_id;
+        ID int_id;
+        ID long_id;
+#ifdef TYPE_LONG_LONG
+        ID long_long_id;
+#endif
+#ifdef TYPE_INT8_T
+        ID int8_t_id;
+#endif
+#ifdef TYPE_INT16_T
+        ID int16_t_id;
+#endif
+#ifdef TYPE_INT32_T
+        ID int32_t_id;
+#endif
+#ifdef TYPE_INT64_T
+        ID int64_t_id;
+#endif
+        ID float_id;
+        ID double_id;
+        ID variadic_id;
+        ID const_string_id;
+        ID size_t_id;
+        ID ssize_t_id;
+        ID ptrdiff_t_id;
+        ID intptr_t_id;
+        ID uintptr_t_id;
+        RUBY_CONST_ID(void_id, "void");
+        RUBY_CONST_ID(voidp_id, "voidp");
+        RUBY_CONST_ID(char_id, "char");
+        RUBY_CONST_ID(short_id, "short");
+        RUBY_CONST_ID(int_id, "int");
+        RUBY_CONST_ID(long_id, "long");
+#ifdef TYPE_LONG_LONG
+        RUBY_CONST_ID(long_long_id, "long_long");
+#endif
+#ifdef TYPE_INT8_T
+        RUBY_CONST_ID(int8_t_id, "int8_t");
+#endif
+#ifdef TYPE_INT16_T
+        RUBY_CONST_ID(int16_t_id, "int16_t");
+#endif
+#ifdef TYPE_INT32_T
+        RUBY_CONST_ID(int32_t_id, "int32_t");
+#endif
+#ifdef TYPE_INT64_T
+        RUBY_CONST_ID(int64_t_id, "int64_t");
+#endif
+        RUBY_CONST_ID(float_id, "float");
+        RUBY_CONST_ID(double_id, "double");
+        RUBY_CONST_ID(variadic_id, "variadic");
+        RUBY_CONST_ID(const_string_id, "const_string");
+        RUBY_CONST_ID(size_t_id, "size_t");
+        RUBY_CONST_ID(ssize_t_id, "ssize_t");
+        RUBY_CONST_ID(ptrdiff_t_id, "ptrdiff_t");
+        RUBY_CONST_ID(intptr_t_id, "intptr_t");
+        RUBY_CONST_ID(uintptr_t_id, "uintptr_t");
+        if (type_id == void_id) {
+            return INT2NUM(TYPE_VOID);
+        }
+        else if (type_id == voidp_id) {
+            return INT2NUM(TYPE_VOIDP);
+        }
+        else if (type_id == char_id) {
+            return INT2NUM(TYPE_CHAR);
+        }
+        else if (type_id == short_id) {
+            return INT2NUM(TYPE_SHORT);
+        }
+        else if (type_id == int_id) {
+            return INT2NUM(TYPE_INT);
+        }
+        else if (type_id == long_id) {
+            return INT2NUM(TYPE_LONG);
+        }
+#ifdef TYPE_LONG_LONG
+        else if (type_id == long_long_id) {
+            return INT2NUM(TYPE_LONG_LONG);
+        }
+#endif
+#ifdef TYPE_INT8_T
+        else if (type_id == int8_t_id) {
+            return INT2NUM(TYPE_INT8_T);
+        }
+#endif
+#ifdef TYPE_INT16_T
+        else if (type_id == int16_t_id) {
+            return INT2NUM(TYPE_INT16_T);
+        }
+#endif
+#ifdef TYPE_INT32_T
+        else if (type_id == int32_t_id) {
+            return INT2NUM(TYPE_INT32_T);
+        }
+#endif
+#ifdef TYPE_INT64_T
+        else if (type_id == int64_t_id) {
+            return INT2NUM(TYPE_INT64_T);
+        }
+#endif
+        else if (type_id == float_id) {
+            return INT2NUM(TYPE_FLOAT);
+        }
+        else if (type_id == double_id) {
+            return INT2NUM(TYPE_DOUBLE);
+        }
+        else if (type_id == variadic_id) {
+            return INT2NUM(TYPE_VARIADIC);
+        }
+        else if (type_id == const_string_id) {
+            return INT2NUM(TYPE_CONST_STRING);
+        }
+        else if (type_id == size_t_id) {
+            return INT2NUM(TYPE_SIZE_T);
+        }
+        else if (type_id == ssize_t_id) {
+            return INT2NUM(TYPE_SSIZE_T);
+        }
+        else if (type_id == ptrdiff_t_id) {
+            return INT2NUM(TYPE_PTRDIFF_T);
+        }
+        else if (type_id == intptr_t_id) {
+            return INT2NUM(TYPE_INTPTR_T);
+        }
+        else if (type_id == uintptr_t_id) {
+            return INT2NUM(TYPE_UINTPTR_T);
+        }
+        else {
+            type = original_type;
+        }
+    }
+
+    return rb_to_int(type);
+}
+
 ffi_type *
-int_to_ffi_type(int type)
+rb_fiddle_int_to_ffi_type(int type)
 {
     int signed_p = 1;
 
@@ -33,66 +185,90 @@ int_to_ffi_type(int type)
 	return &ffi_type_float;
       case TYPE_DOUBLE:
 	return &ffi_type_double;
+      case TYPE_CONST_STRING:
+	return &ffi_type_pointer;
       default:
 	rb_raise(rb_eRuntimeError, "unknown type %d", type);
     }
     return &ffi_type_pointer;
 }
 
+ffi_type *
+int_to_ffi_type(int type)
+{
+    return rb_fiddle_int_to_ffi_type(type);
+}
+
 void
-value_to_generic(int type, VALUE src, fiddle_generic * dst)
+rb_fiddle_value_to_generic(int type, VALUE *src, fiddle_generic *dst)
 {
     switch (type) {
       case TYPE_VOID:
 	break;
       case TYPE_VOIDP:
-	dst->pointer = NUM2PTR(rb_Integer(src));
+	dst->pointer = NUM2PTR(rb_Integer(*src));
 	break;
       case TYPE_CHAR:
-	dst->schar = (signed char)NUM2INT(src);
+	dst->schar = (signed char)NUM2INT(*src);
 	break;
       case -TYPE_CHAR:
-	dst->uchar = (unsigned char)NUM2UINT(src);
+	dst->uchar = (unsigned char)NUM2UINT(*src);
 	break;
       case TYPE_SHORT:
-	dst->sshort = (unsigned short)NUM2INT(src);
+	dst->sshort = (unsigned short)NUM2INT(*src);
 	break;
       case -TYPE_SHORT:
-	dst->sshort = (signed short)NUM2UINT(src);
+	dst->sshort = (signed short)NUM2UINT(*src);
 	break;
       case TYPE_INT:
-	dst->sint = NUM2INT(src);
+	dst->sint = NUM2INT(*src);
 	break;
       case -TYPE_INT:
-	dst->uint = NUM2UINT(src);
+	dst->uint = NUM2UINT(*src);
 	break;
       case TYPE_LONG:
-	dst->slong = NUM2LONG(src);
+	dst->slong = NUM2LONG(*src);
 	break;
       case -TYPE_LONG:
-	dst->ulong = NUM2ULONG(src);
+	dst->ulong = NUM2ULONG(*src);
 	break;
 #if HAVE_LONG_LONG
       case TYPE_LONG_LONG:
-	dst->slong_long = NUM2LL(src);
+	dst->slong_long = NUM2LL(*src);
 	break;
       case -TYPE_LONG_LONG:
-	dst->ulong_long = NUM2ULL(src);
+	dst->ulong_long = NUM2ULL(*src);
 	break;
 #endif
       case TYPE_FLOAT:
-	dst->ffloat = (float)NUM2DBL(src);
+	dst->ffloat = (float)NUM2DBL(*src);
 	break;
       case TYPE_DOUBLE:
-	dst->ddouble = NUM2DBL(src);
+	dst->ddouble = NUM2DBL(*src);
+	break;
+      case TYPE_CONST_STRING:
+        if (NIL_P(*src)) {
+            dst->pointer = NULL;
+        }
+        else {
+            dst->pointer = rb_string_value_cstr(src);
+        }
 	break;
       default:
 	rb_raise(rb_eRuntimeError, "unknown type %d", type);
     }
 }
 
+void
+value_to_generic(int type, VALUE src, fiddle_generic *dst)
+{
+    /* src isn't safe from GC when type is TYPE_CONST_STRING and src
+     * isn't String. */
+    rb_fiddle_value_to_generic(type, &src, dst);
+}
+
 VALUE
-generic_to_value(VALUE rettype, fiddle_generic retval)
+rb_fiddle_generic_to_value(VALUE rettype, fiddle_generic retval)
 {
     int type = NUM2INT(rettype);
     VALUE cPointer;
@@ -131,6 +307,13 @@ generic_to_value(VALUE rettype, fiddle_generic retval)
 	return rb_float_new(retval.ffloat);
       case TYPE_DOUBLE:
 	return rb_float_new(retval.ddouble);
+      case TYPE_CONST_STRING:
+        if (retval.pointer) {
+            return rb_str_new_cstr(retval.pointer);
+        }
+        else {
+            return Qnil;
+        }
       default:
 	rb_raise(rb_eRuntimeError, "unknown type %d", type);
     }
@@ -138,4 +321,10 @@ generic_to_value(VALUE rettype, fiddle_generic retval)
     UNREACHABLE;
 }
 
+VALUE
+generic_to_value(VALUE rettype, fiddle_generic retval)
+{
+    return rb_fiddle_generic_to_value(rettype, retval);
+}
+
 /* vim: set noet sw=4 sts=4 */