fiddle 1.0.0.beta1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2fe43921484c5d31435a574dfefe01f997a7d32d
+  data.tar.gz: e03146994af328004ad234e857040db4820f3734
+SHA512:
+  metadata.gz: a5ba7ff66c1000fbc80c61294523e9acba69f39bdce1f168dd748821a1fa2213204b69a3174ab74274e1343f936a8fe0a78053d4b43c6736ac7232e38e6a70d8
+  data.tar.gz: b650a3bb827441f5a34e51e66df247c8c707383de10083f717a15500fffa020d1f5704b53558ea1b5338a3481fa968a17f2ddfa63ec51ab5b3b7c1f3fbf5a052

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.dll

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.5.0
+before_install: gem install bundler -v 1.14.6

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in fiddle.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 SHIBATA Hiroshi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,41 @@
+# Fiddle
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/fiddle`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'fiddle'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install fiddle
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/hsbt/fiddle.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,13 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test" << "test/lib"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/test_*.rb']
+end
+
+require 'rake/extensiontask'
+Rake::ExtensionTask.new("fiddle")
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "fiddle"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/ext/fiddle/closure.c

@@ -0,0 +1,345 @@
+#include <fiddle.h>
+#include <ruby/thread.h>
+
+int ruby_thread_has_gvl_p(void); /* for ext/fiddle/closure.c */
+
+VALUE cFiddleClosure;
+
+typedef struct {
+    void * code;
+    ffi_closure *pcl;
+    ffi_cif cif;
+    int argc;
+    ffi_type **argv;
+} fiddle_closure;
+
+#if defined(USE_FFI_CLOSURE_ALLOC)
+#elif defined(__OpenBSD__) || defined(__APPLE__) || defined(__linux__)
+# 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))
+# define USE_FFI_CLOSURE_ALLOC 0
+#else
+# define USE_FFI_CLOSURE_ALLOC 1
+#endif
+
+static void
+dealloc(void * ptr)
+{
+    fiddle_closure * cls = (fiddle_closure *)ptr;
+#if USE_FFI_CLOSURE_ALLOC
+    ffi_closure_free(cls->pcl);
+#else
+    munmap(cls->pcl, sizeof(*cls->pcl));
+#endif
+    if (cls->argv) xfree(cls->argv);
+    xfree(cls);
+}
+
+static size_t
+closure_memsize(const void * ptr)
+{
+    fiddle_closure * cls = (fiddle_closure *)ptr;
+    size_t size = 0;
+
+    size += sizeof(*cls);
+#if !defined(FFI_NO_RAW_API) || !FFI_NO_RAW_API
+    size += ffi_raw_size(&cls->cif);
+#endif
+    size += sizeof(*cls->argv);
+    size += sizeof(ffi_closure);
+
+    return size;
+}
+
+const rb_data_type_t closure_data_type = {
+    "fiddle/closure",
+    {0, dealloc, closure_memsize,},
+};
+
+struct callback_args {
+    ffi_cif *cif;
+    void *resp;
+    void **args;
+    void *ctx;
+};
+
+static void *
+with_gvl_callback(void *ptr)
+{
+    struct callback_args *x = ptr;
+
+    VALUE self      = (VALUE)x->ctx;
+    VALUE rbargs    = rb_iv_get(self, "@args");
+    VALUE ctype     = rb_iv_get(self, "@ctype");
+    int argc        = RARRAY_LENINT(rbargs);
+    VALUE params    = rb_ary_tmp_new(argc);
+    VALUE ret;
+    VALUE cPointer;
+    int i, type;
+
+    cPointer = rb_const_get(mFiddle, rb_intern("Pointer"));
+
+    for (i = 0; i < argc; i++) {
+        type = NUM2INT(RARRAY_AREF(rbargs, i));
+        switch (type) {
+	  case TYPE_VOID:
+	    argc = 0;
+	    break;
+	  case TYPE_INT:
+	    rb_ary_push(params, INT2NUM(*(int *)x->args[i]));
+	    break;
+	  case -TYPE_INT:
+	    rb_ary_push(params, UINT2NUM(*(unsigned int *)x->args[i]));
+	    break;
+	  case TYPE_VOIDP:
+	    rb_ary_push(params,
+			rb_funcall(cPointer, rb_intern("[]"), 1,
+				   PTR2NUM(*(void **)x->args[i])));
+	    break;
+	  case TYPE_LONG:
+	    rb_ary_push(params, LONG2NUM(*(long *)x->args[i]));
+	    break;
+	  case -TYPE_LONG:
+	    rb_ary_push(params, ULONG2NUM(*(unsigned long *)x->args[i]));
+	    break;
+	  case TYPE_CHAR:
+	    rb_ary_push(params, INT2NUM(*(signed char *)x->args[i]));
+	    break;
+	  case -TYPE_CHAR:
+	    rb_ary_push(params, UINT2NUM(*(unsigned char *)x->args[i]));
+	    break;
+	  case TYPE_SHORT:
+	    rb_ary_push(params, INT2NUM(*(signed short *)x->args[i]));
+	    break;
+	  case -TYPE_SHORT:
+	    rb_ary_push(params, UINT2NUM(*(unsigned short *)x->args[i]));
+	    break;
+	  case TYPE_DOUBLE:
+	    rb_ary_push(params, rb_float_new(*(double *)x->args[i]));
+	    break;
+	  case TYPE_FLOAT:
+	    rb_ary_push(params, rb_float_new(*(float *)x->args[i]));
+	    break;
+#if HAVE_LONG_LONG
+	  case TYPE_LONG_LONG:
+	    rb_ary_push(params, LL2NUM(*(LONG_LONG *)x->args[i]));
+	    break;
+	  case -TYPE_LONG_LONG:
+	    rb_ary_push(params, ULL2NUM(*(unsigned LONG_LONG *)x->args[i]));
+	    break;
+#endif
+	  default:
+	    rb_raise(rb_eRuntimeError, "closure args: %d", type);
+        }
+    }
+
+    ret = rb_funcall2(self, rb_intern("call"), argc, RARRAY_CONST_PTR(params));
+    RB_GC_GUARD(params);
+
+    type = NUM2INT(ctype);
+    switch (type) {
+      case TYPE_VOID:
+	break;
+      case TYPE_LONG:
+	*(long *)x->resp = NUM2LONG(ret);
+	break;
+      case -TYPE_LONG:
+	*(unsigned long *)x->resp = NUM2ULONG(ret);
+	break;
+      case TYPE_CHAR:
+      case TYPE_SHORT:
+      case TYPE_INT:
+	*(ffi_sarg *)x->resp = NUM2INT(ret);
+	break;
+      case -TYPE_CHAR:
+      case -TYPE_SHORT:
+      case -TYPE_INT:
+	*(ffi_arg *)x->resp = NUM2UINT(ret);
+	break;
+      case TYPE_VOIDP:
+	*(void **)x->resp = NUM2PTR(ret);
+	break;
+      case TYPE_DOUBLE:
+	*(double *)x->resp = NUM2DBL(ret);
+	break;
+      case TYPE_FLOAT:
+	*(float *)x->resp = (float)NUM2DBL(ret);
+	break;
+#if HAVE_LONG_LONG
+      case TYPE_LONG_LONG:
+	*(LONG_LONG *)x->resp = NUM2LL(ret);
+	break;
+      case -TYPE_LONG_LONG:
+	*(unsigned LONG_LONG *)x->resp = NUM2ULL(ret);
+	break;
+#endif
+      default:
+	rb_raise(rb_eRuntimeError, "closure retval: %d", type);
+    }
+    return 0;
+}
+
+static void
+callback(ffi_cif *cif, void *resp, void **args, void *ctx)
+{
+    struct callback_args x;
+
+    x.cif = cif;
+    x.resp = resp;
+    x.args = args;
+    x.ctx = ctx;
+
+    if (ruby_thread_has_gvl_p()) {
+	(void)with_gvl_callback(&x);
+    } else {
+	(void)rb_thread_call_with_gvl(with_gvl_callback, &x);
+    }
+}
+
+static VALUE
+allocate(VALUE klass)
+{
+    fiddle_closure * closure;
+
+    VALUE i = TypedData_Make_Struct(klass, fiddle_closure,
+	    &closure_data_type, closure);
+
+#if USE_FFI_CLOSURE_ALLOC
+    closure->pcl = ffi_closure_alloc(sizeof(ffi_closure), &closure->code);
+#else
+    closure->pcl = mmap(NULL, sizeof(ffi_closure), PROT_READ | PROT_WRITE,
+        MAP_ANON | MAP_PRIVATE, -1, 0);
+#endif
+
+    return i;
+}
+
+static VALUE
+initialize(int rbargc, VALUE argv[], VALUE self)
+{
+    VALUE ret;
+    VALUE args;
+    VALUE abi;
+    fiddle_closure * cl;
+    ffi_cif * cif;
+    ffi_closure *pcl;
+    ffi_status result;
+    int i, argc;
+
+    if (2 == rb_scan_args(rbargc, argv, "21", &ret, &args, &abi))
+	abi = INT2NUM(FFI_DEFAULT_ABI);
+
+    Check_Type(args, T_ARRAY);
+
+    argc = RARRAY_LENINT(args);
+
+    TypedData_Get_Struct(self, fiddle_closure, &closure_data_type, cl);
+
+    cl->argv = (ffi_type **)xcalloc(argc + 1, sizeof(ffi_type *));
+
+    for (i = 0; i < argc; i++) {
+        int type = NUM2INT(RARRAY_AREF(args, i));
+        cl->argv[i] = INT2FFI_TYPE(type);
+    }
+    cl->argv[argc] = NULL;
+
+    rb_iv_set(self, "@ctype", ret);
+    rb_iv_set(self, "@args", args);
+
+    cif = &cl->cif;
+    pcl = cl->pcl;
+
+    result = ffi_prep_cif(cif, NUM2INT(abi), argc,
+                INT2FFI_TYPE(NUM2INT(ret)),
+		cl->argv);
+
+    if (FFI_OK != result)
+	rb_raise(rb_eRuntimeError, "error prepping CIF %d", result);
+
+#if USE_FFI_CLOSURE_ALLOC
+    result = ffi_prep_closure_loc(pcl, cif, callback,
+		(void *)self, cl->code);
+#else
+    result = ffi_prep_closure(pcl, cif, callback, (void *)self);
+    cl->code = (void *)pcl;
+    i = mprotect(pcl, sizeof(*pcl), PROT_READ | PROT_EXEC);
+    if (i) {
+	rb_sys_fail("mprotect");
+    }
+#endif
+
+    if (FFI_OK != result)
+	rb_raise(rb_eRuntimeError, "error prepping closure %d", result);
+
+    return self;
+}
+
+static VALUE
+to_i(VALUE self)
+{
+    fiddle_closure * cl;
+    void *code;
+
+    TypedData_Get_Struct(self, fiddle_closure, &closure_data_type, cl);
+
+    code = cl->code;
+
+    return PTR2NUM(code);
+}
+
+void
+Init_fiddle_closure(void)
+{
+#if 0
+    mFiddle = rb_define_module("Fiddle"); /* let rdoc know about mFiddle */
+#endif
+
+    /*
+     * Document-class: Fiddle::Closure
+     *
+     * == Description
+     *
+     * An FFI closure wrapper, for handling callbacks.
+     *
+     * == Example
+     *
+     *   closure = Class.new(Fiddle::Closure) {
+     *     def call
+     *       10
+     *     end
+     *   }.new(Fiddle::TYPE_INT, [])
+     *	    #=> #<#<Class:0x0000000150d308>:0x0000000150d240>
+     *   func = Fiddle::Function.new(closure, [], Fiddle::TYPE_INT)
+     *	    #=> #<Fiddle::Function:0x00000001516e58>
+     *   func.call
+     *	    #=> 10
+     */
+    cFiddleClosure = rb_define_class_under(mFiddle, "Closure", rb_cObject);
+
+    rb_define_alloc_func(cFiddleClosure, allocate);
+
+    /*
+     * Document-method: new
+     *
+     * call-seq: new(ret, args, abi = Fiddle::DEFAULT)
+     *
+     * Construct a new Closure object.
+     *
+     * * +ret+ is the C type to be returned
+     * * +args+ is an Array of arguments, passed to the callback function
+     * * +abi+ is the abi of the closure
+     *
+     * If there is an error in preparing the ffi_cif or ffi_prep_closure,
+     * then a RuntimeError will be raised.
+     */
+    rb_define_method(cFiddleClosure, "initialize", initialize, -1);
+
+    /*
+     * Document-method: to_i
+     *
+     * Returns the memory address for this closure
+     */
+    rb_define_method(cFiddleClosure, "to_i", to_i, 0);
+}
+/* vim: set noet sw=4 sts=4 */