299 lines
9.6 KiB
C
299 lines
9.6 KiB
C
|
/*
|
||
|
|
* Copyright (c) 2008-2010 Wayne Meissner
|
||
|
|
* Copyright (C) 2009 Andrea Fazzi <andrea.fazzi@alcacoop.it>
|
||
|
|
* Copyright (c) 2008-2013, Ruby FFI project contributors
|
||
|
|
* All rights reserved.
|
||
|
|
*
|
||
|
|
* Redistribution and use in source and binary forms, with or without
|
||
|
|
* modification, are permitted provided that the following conditions are met:
|
||
|
|
* * Redistributions of source code must retain the above copyright
|
||
|
|
* notice, this list of conditions and the following disclaimer.
|
||
|
|
* * Redistributions in binary form must reproduce the above copyright
|
||
|
|
* notice, this list of conditions and the following disclaimer in the
|
||
|
|
* documentation and/or other materials provided with the distribution.
|
||
|
|
* * Neither the name of the Ruby FFI project nor the
|
||
|
|
* names of its contributors may be used to endorse or promote products
|
||
|
|
* derived from this software without specific prior written permission.
|
||
|
|
*
|
||
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
||
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
||
|
|
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
||
|
|
* DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
|
||
|
|
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
||
|
|
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
||
|
|
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
||
|
|
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
||
|
|
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
||
|
|
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
||
|
|
*/
|
||
|
|
|
||
|
|
#ifndef _MSC_VER
|
||
|
|
#include <sys/param.h>
|
||
|
|
#endif
|
||
|
|
#include <sys/types.h>
|
||
|
|
|
||
|
|
#include <stdio.h>
|
||
|
|
#ifndef _MSC_VER
|
||
|
|
# include <stdint.h>
|
||
|
|
# include <stdbool.h>
|
||
|
|
#else
|
||
|
|
# include "win32/stdbool.h"
|
||
|
|
# include "win32/stdint.h"
|
||
|
|
#endif
|
||
|
|
#include <ruby.h>
|
||
|
|
|
||
|
|
#include <ffi.h>
|
||
|
|
#include "rbffi.h"
|
||
|
|
#include "compat.h"
|
||
|
|
|
||
|
|
#include "AbstractMemory.h"
|
||
|
|
#include "Pointer.h"
|
||
|
|
#include "Types.h"
|
||
|
|
#include "Type.h"
|
||
|
|
#include "LastError.h"
|
||
|
|
#include "MethodHandle.h"
|
||
|
|
#include "Call.h"
|
||
|
|
#include "Thread.h"
|
||
|
|
|
||
|
|
typedef struct VariadicInvoker_ {
|
||
|
|
VALUE rbAddress;
|
||
|
|
VALUE rbReturnType;
|
||
|
|
VALUE rbEnums;
|
||
|
|
|
||
|
|
Type* returnType;
|
||
|
|
ffi_abi abi;
|
||
|
|
void* function;
|
||
|
|
int paramCount;
|
||
|
|
bool blocking;
|
||
|
|
} VariadicInvoker;
|
||
|
|
|
||
|
|
|
||
|
|
static VALUE variadic_allocate(VALUE klass);
|
||
|
|
static VALUE variadic_initialize(VALUE self, VALUE rbFunction, VALUE rbParameterTypes,
|
||
|
|
VALUE rbReturnType, VALUE options);
|
||
|
|
static void variadic_mark(VariadicInvoker *);
|
||
|
|
|
||
|
|
static VALUE classVariadicInvoker = Qnil;
|
||
|
|
|
||
|
|
|
||
|
|
static VALUE
|
||
|
|
variadic_allocate(VALUE klass)
|
||
|
|
{
|
||
|
|
VariadicInvoker *invoker;
|
||
|
|
VALUE obj = Data_Make_Struct(klass, VariadicInvoker, variadic_mark, -1, invoker);
|
||
|
|
|
||
|
|
invoker->rbAddress = Qnil;
|
||
|
|
invoker->rbEnums = Qnil;
|
||
|
|
invoker->rbReturnType = Qnil;
|
||
|
|
invoker->blocking = false;
|
||
|
|
|
||
|
|
return obj;
|
||
|
|
}
|
||
|
|
|
||
|
|
static void
|
||
|
|
variadic_mark(VariadicInvoker *invoker)
|
||
|
|
{
|
||
|
|
rb_gc_mark(invoker->rbEnums);
|
||
|
|
rb_gc_mark(invoker->rbAddress);
|
||
|
|
rb_gc_mark(invoker->rbReturnType);
|
||
|
|
}
|
||
|
|
|
||
|
|
static VALUE
|
||
|
|
variadic_initialize(VALUE self, VALUE rbFunction, VALUE rbParameterTypes, VALUE rbReturnType, VALUE options)
|
||
|
|
{
|
||
|
|
VariadicInvoker* invoker = NULL;
|
||
|
|
VALUE retval = Qnil;
|
||
|
|
VALUE convention = Qnil;
|
||
|
|
VALUE fixed = Qnil;
|
||
|
|
#if defined(X86_WIN32)
|
||
|
|
VALUE rbConventionStr;
|
||
|
|
#endif
|
||
|
|
int i;
|
||
|
|
|
||
|
|
Check_Type(options, T_HASH);
|
||
|
|
convention = rb_hash_aref(options, ID2SYM(rb_intern("convention")));
|
||
|
|
|
||
|
|
Data_Get_Struct(self, VariadicInvoker, invoker);
|
||
|
|
invoker->rbEnums = rb_hash_aref(options, ID2SYM(rb_intern("enums")));
|
||
|
|
invoker->rbAddress = rbFunction;
|
||
|
|
invoker->function = rbffi_AbstractMemory_Cast(rbFunction, rbffi_PointerClass)->address;
|
||
|
|
invoker->blocking = RTEST(rb_hash_aref(options, ID2SYM(rb_intern("blocking"))));
|
||
|
|
|
||
|
|
#if defined(X86_WIN32)
|
||
|
|
rbConventionStr = rb_funcall2(convention, rb_intern("to_s"), 0, NULL);
|
||
|
|
invoker->abi = (RTEST(convention) && strcmp(StringValueCStr(rbConventionStr), "stdcall") == 0)
|
||
|
|
? FFI_STDCALL : FFI_DEFAULT_ABI;
|
||
|
|
#else
|
||
|
|
invoker->abi = FFI_DEFAULT_ABI;
|
||
|
|
#endif
|
||
|
|
|
||
|
|
invoker->rbReturnType = rbffi_Type_Lookup(rbReturnType);
|
||
|
|
if (!RTEST(invoker->rbReturnType)) {
|
||
|
|
VALUE typeName = rb_funcall2(rbReturnType, rb_intern("inspect"), 0, NULL);
|
||
|
|
rb_raise(rb_eTypeError, "Invalid return type (%s)", RSTRING_PTR(typeName));
|
||
|
|
}
|
||
|
|
|
||
|
|
Data_Get_Struct(rbReturnType, Type, invoker->returnType);
|
||
|
|
|
||
|
|
invoker->paramCount = -1;
|
||
|
|
|
||
|
|
fixed = rb_ary_new2(RARRAY_LEN(rbParameterTypes) - 1);
|
||
|
|
for (i = 0; i < RARRAY_LEN(rbParameterTypes); ++i) {
|
||
|
|
VALUE entry = rb_ary_entry(rbParameterTypes, i);
|
||
|
|
VALUE rbType = rbffi_Type_Lookup(entry);
|
||
|
|
Type* type;
|
||
|
|
|
||
|
|
if (!RTEST(rbType)) {
|
||
|
|
VALUE typeName = rb_funcall2(entry, rb_intern("inspect"), 0, NULL);
|
||
|
|
rb_raise(rb_eTypeError, "Invalid parameter type (%s)", RSTRING_PTR(typeName));
|
||
|
|
}
|
||
|
|
Data_Get_Struct(rbType, Type, type);
|
||
|
|
if (type->nativeType != NATIVE_VARARGS) {
|
||
|
|
rb_ary_push(fixed, entry);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
/*
|
||
|
|
* @fixed and @type_map are used by the parameter mangling ruby code
|
||
|
|
*/
|
||
|
|
rb_iv_set(self, "@fixed", fixed);
|
||
|
|
rb_iv_set(self, "@type_map", rb_hash_aref(options, ID2SYM(rb_intern("type_map"))));
|
||
|
|
|
||
|
|
return retval;
|
||
|
|
}
|
||
|
|
|
||
|
|
static VALUE
|
||
|
|
variadic_invoke(VALUE self, VALUE parameterTypes, VALUE parameterValues)
|
||
|
|
{
|
||
|
|
VariadicInvoker* invoker;
|
||
|
|
FFIStorage* params;
|
||
|
|
void* retval;
|
||
|
|
ffi_cif cif;
|
||
|
|
void** ffiValues;
|
||
|
|
ffi_type** ffiParamTypes;
|
||
|
|
ffi_type* ffiReturnType;
|
||
|
|
Type** paramTypes;
|
||
|
|
VALUE* argv;
|
||
|
|
int paramCount = 0, fixedCount = 0, i;
|
||
|
|
ffi_status ffiStatus;
|
||
|
|
rbffi_frame_t frame = { 0 };
|
||
|
|
|
||
|
|
Check_Type(parameterTypes, T_ARRAY);
|
||
|
|
Check_Type(parameterValues, T_ARRAY);
|
||
|
|
|
||
|
|
Data_Get_Struct(self, VariadicInvoker, invoker);
|
||
|
|
paramCount = (int) RARRAY_LEN(parameterTypes);
|
||
|
|
paramTypes = ALLOCA_N(Type *, paramCount);
|
||
|
|
ffiParamTypes = ALLOCA_N(ffi_type *, paramCount);
|
||
|
|
params = ALLOCA_N(FFIStorage, paramCount);
|
||
|
|
ffiValues = ALLOCA_N(void*, paramCount);
|
||
|
|
argv = ALLOCA_N(VALUE, paramCount);
|
||
|
|
retval = alloca(MAX(invoker->returnType->ffiType->size, FFI_SIZEOF_ARG));
|
||
|
|
|
||
|
|
for (i = 0; i < paramCount; ++i) {
|
||
|
|
VALUE rbType = rb_ary_entry(parameterTypes, i);
|
||
|
|
|
||
|
|
if (!rb_obj_is_kind_of(rbType, rbffi_TypeClass)) {
|
||
|
|
rb_raise(rb_eTypeError, "wrong type. Expected (FFI::Type)");
|
||
|
|
}
|
||
|
|
Data_Get_Struct(rbType, Type, paramTypes[i]);
|
||
|
|
|
||
|
|
switch (paramTypes[i]->nativeType) {
|
||
|
|
case NATIVE_INT8:
|
||
|
|
case NATIVE_INT16:
|
||
|
|
case NATIVE_INT32:
|
||
|
|
rbType = rb_const_get(rbffi_TypeClass, rb_intern("INT32"));
|
||
|
|
Data_Get_Struct(rbType, Type, paramTypes[i]);
|
||
|
|
break;
|
||
|
|
case NATIVE_UINT8:
|
||
|
|
case NATIVE_UINT16:
|
||
|
|
case NATIVE_UINT32:
|
||
|
|
rbType = rb_const_get(rbffi_TypeClass, rb_intern("UINT32"));
|
||
|
|
Data_Get_Struct(rbType, Type, paramTypes[i]);
|
||
|
|
break;
|
||
|
|
|
||
|
|
case NATIVE_FLOAT32:
|
||
|
|
rbType = rb_const_get(rbffi_TypeClass, rb_intern("DOUBLE"));
|
||
|
|
Data_Get_Struct(rbType, Type, paramTypes[i]);
|
||
|
|
break;
|
||
|
|
|
||
|
|
default:
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
ffiParamTypes[i] = paramTypes[i]->ffiType;
|
||
|
|
if (ffiParamTypes[i] == NULL) {
|
||
|
|
rb_raise(rb_eArgError, "Invalid parameter type #%x", paramTypes[i]->nativeType);
|
||
|
|
}
|
||
|
|
argv[i] = rb_ary_entry(parameterValues, i);
|
||
|
|
}
|
||
|
|
|
||
|
|
ffiReturnType = invoker->returnType->ffiType;
|
||
|
|
if (ffiReturnType == NULL) {
|
||
|
|
rb_raise(rb_eArgError, "Invalid return type");
|
||
|
|
}
|
||
|
|
|
||
|
|
/*Get the number of fixed args from @fixed array*/
|
||
|
|
fixedCount = RARRAY_LEN(rb_iv_get(self, "@fixed"));
|
||
|
|
|
||
|
|
#ifdef HAVE_FFI_PREP_CIF_VAR
|
||
|
|
ffiStatus = ffi_prep_cif_var(&cif, invoker->abi, fixedCount, paramCount, ffiReturnType, ffiParamTypes);
|
||
|
|
#else
|
||
|
|
ffiStatus = ffi_prep_cif(&cif, invoker->abi, paramCount, ffiReturnType, ffiParamTypes);
|
||
|
|
#endif
|
||
|
|
switch (ffiStatus) {
|
||
|
|
case FFI_BAD_ABI:
|
||
|
|
rb_raise(rb_eArgError, "Invalid ABI specified");
|
||
|
|
case FFI_BAD_TYPEDEF:
|
||
|
|
rb_raise(rb_eArgError, "Invalid argument type specified");
|
||
|
|
case FFI_OK:
|
||
|
|
break;
|
||
|
|
default:
|
||
|
|
rb_raise(rb_eArgError, "Unknown FFI error");
|
||
|
|
}
|
||
|
|
|
||
|
|
rbffi_SetupCallParams(paramCount, argv, -1, paramTypes, params,
|
||
|
|
ffiValues, NULL, 0, invoker->rbEnums);
|
||
|
|
|
||
|
|
rbffi_frame_push(&frame);
|
||
|
|
|
||
|
|
if(unlikely(invoker->blocking)) {
|
||
|
|
rbffi_blocking_call_t* bc;
|
||
|
|
bc = ALLOCA_N(rbffi_blocking_call_t, 1);
|
||
|
|
bc->retval = retval;
|
||
|
|
bc->function = invoker->function;
|
||
|
|
bc->ffiValues = ffiValues;
|
||
|
|
bc->params = params;
|
||
|
|
bc->frame = &frame;
|
||
|
|
bc->cif = cif;
|
||
|
|
|
||
|
|
rb_rescue2(rbffi_do_blocking_call, (VALUE) bc, rbffi_save_frame_exception, (VALUE) &frame, rb_eException, (VALUE) 0);
|
||
|
|
} else {
|
||
|
|
ffi_call(&cif, FFI_FN(invoker->function), retval, ffiValues);
|
||
|
|
}
|
||
|
|
|
||
|
|
rbffi_frame_pop(&frame);
|
||
|
|
|
||
|
|
rbffi_save_errno();
|
||
|
|
|
||
|
|
if (RTEST(frame.exc) && frame.exc != Qnil) {
|
||
|
|
rb_exc_raise(frame.exc);
|
||
|
|
}
|
||
|
|
|
||
|
|
return rbffi_NativeValue_ToRuby(invoker->returnType, invoker->rbReturnType, retval);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
void
|
||
|
|
rbffi_Variadic_Init(VALUE moduleFFI)
|
||
|
|
{
|
||
|
|
classVariadicInvoker = rb_define_class_under(moduleFFI, "VariadicInvoker", rb_cObject);
|
||
|
|
rb_global_variable(&classVariadicInvoker);
|
||
|
|
|
||
|
|
rb_define_alloc_func(classVariadicInvoker, variadic_allocate);
|
||
|
|
|
||
|
|
rb_define_method(classVariadicInvoker, "initialize", variadic_initialize, 4);
|
||
|
|
rb_define_method(classVariadicInvoker, "invoke", variadic_invoke, 2);
|
||
|
|
}
|
||
|
|
|