rbdc 0.8.0

data/bindings/ruby/rbdc/extconf.rb

@@ -0,0 +1,57 @@
+#//////////////////////////////////////////////////////////////////////
+#
+# extconf.rb
+# Copyright (c) 2007-2014 Daniel Adler <dadler@uni-goettingen.de>, 
+#                         Tassilo Philipp <tphilipp@potion-studios.com>
+#
+# Permission to use, copy, modify, and distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+#
+# Configuration file for dyncall/ruby extension. This script creates
+# a makefile that can be used to compile the C-extension. It is
+# configured such that every .c file in this directory will be used
+# for compilation.
+#
+#///////////////////////////////////////////////////////////////////////
+
+require 'mkmf'
+
+dir_config 'rbdc'
+base_dir = '../../../dyncall/'
+
+# Build dyncall libs.
+puts 'Building dyncall libraries:'
+Dir.chdir(base_dir) do
+	cmd = case
+		when RUBY_PLATFORM =~ /mswin/  then 'configure.bat && nmake /f Nmakefile'
+		else './configure && env CFLAGS="-fPIC" make'
+	end
+	puts cmd
+	raise "'#{cmd}' failed" unless system(cmd)
+end
+
+# Search for dyncall libs.
+puts 'Using the following dyncall libraries to build native ruby extension:'
+Dir[base_dir+'**/*'].each { |d|
+	if d =~ /(lib)?dyn(call(back)?|load)_s\./
+		$LOCAL_LIBS << '"'+d+'" '
+		puts d
+	end
+}
+
+if($LOCAL_LIBS.size > 0) then
+	# Write out a makefile for our dyncall extension.
+	create_makefile 'rbdc'
+else
+	puts "Couldn't find dyncall and dynload libraries - dyncall build seems to have failed!"
+end
+

data/bindings/ruby/rbdc/rbdc.c

@@ -0,0 +1,304 @@
+/*
+
+ rbdc.c
+ Copyright (c) 2007-2014 Daniel Adler <dadler@uni-goettingen.de>, 
+                         Tassilo Philipp <tphilipp@potion-studios.com>
+
+ Permission to use, copy, modify, and distribute this software for any
+ purpose with or without fee is hereby granted, provided that the above
+ copyright notice and this permission notice appear in all copies.
+
+ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+ Ruby/dyncall extension implementation.
+
+*/
+
+
+#include <ruby.h>
+#include "../../../dyncall/dyncall/dyncall.h"
+#include "../../../dyncall/dyncallback/dyncall_callback.h"
+#include "../../../dyncall/dynload/dynload.h"
+#include "../../../dyncall/dyncall/dyncall_signature.h"
+
+/* Our ruby module and its classes. */
+static VALUE rb_dcModule;
+static VALUE rb_dcExtLib;
+
+
+typedef struct {
+	void*     lib;
+	void*     syms;
+	DCCallVM* cvm;
+} rb_dcLibHandle;
+
+
+/* Allocator for handle and mark-and-sweep GC handlers. */
+static void GCMark_ExtLib(rb_dcLibHandle* h)
+{
+}
+
+static void GCSweep_ExtLib(rb_dcLibHandle* h)
+{
+	if(h->lib  != NULL) dlFreeLibrary(h->lib);
+	if(h->syms != NULL) dlSymsCleanup(h->syms);
+
+	dcFree(h->cvm);
+	free(h);
+}
+
+static VALUE AllocExtLib(VALUE cl)
+{
+	rb_dcLibHandle* h = malloc(sizeof(rb_dcLibHandle));
+	h->lib  = NULL;
+	h->syms = NULL;
+	h->cvm  = dcNewCallVM(4096/*@@@*/);
+	return Data_Wrap_Struct(cl, GCMark_ExtLib, GCSweep_ExtLib, h);
+}
+
+
+/* Helpers */
+static void ExtLib_SecCheckLib(rb_dcLibHandle* h)
+{
+	if(h->lib == NULL)
+		rb_raise(rb_eRuntimeError, "no library loaded - use ExtLib#load");
+}
+
+static void ExtLib_SecCheckSyms(rb_dcLibHandle* h)
+{
+	if(h->syms == NULL)
+		rb_raise(rb_eRuntimeError, "no symbol table initialized - use ExtLib#symsInit");
+}
+
+
+
+/* Methods for lib access */
+static VALUE ExtLib_Load(VALUE self, VALUE path)
+{
+	void* newLib;
+	rb_dcLibHandle* h;
+
+	if(TYPE(path) != T_STRING)
+		rb_raise(rb_eRuntimeError, "argument must be of type 'String'");/*@@@ respond to to_s*/
+
+	Data_Get_Struct(self, rb_dcLibHandle, h);
+	newLib = dlLoadLibrary(RSTRING_PTR(path));
+	if(newLib) {
+		dlFreeLibrary(h->lib);
+		h->lib = newLib;
+
+		return self;
+	}
+
+	return Qnil;
+}
+
+static VALUE ExtLib_ExistsQ(VALUE self, VALUE sym)
+{
+	rb_dcLibHandle* h;
+
+	Data_Get_Struct(self, rb_dcLibHandle, h);
+	ExtLib_SecCheckLib(h);
+
+	return dlFindSymbol(h->lib, rb_id2name(SYM2ID(sym))) ? Qtrue : Qfalse;
+}
+
+
+/* Methods for syms parsing */
+static VALUE ExtLib_SymsInit(VALUE self, VALUE path)
+{
+	void* newSyms;
+	rb_dcLibHandle* h;
+
+	if(TYPE(path) != T_STRING)
+		rb_raise(rb_eRuntimeError, "argument must be of type 'String'");/*@@@ respond to to_s*/
+
+	Data_Get_Struct(self, rb_dcLibHandle, h);
+	newSyms = dlSymsInit(RSTRING_PTR(path));
+
+	if(newSyms) {
+		dlSymsCleanup(h->syms);
+		h->syms = newSyms;
+
+		return self;
+	}
+
+	return Qnil;
+}
+
+
+static VALUE ExtLib_SymsCount(VALUE self)
+{
+	rb_dcLibHandle* h;
+
+	Data_Get_Struct(self, rb_dcLibHandle, h);
+	ExtLib_SecCheckSyms(h);
+
+	return LONG2NUM(dlSymsCount(h->syms));
+}
+
+
+static VALUE ExtLib_SymsEach(int argc, VALUE* argv, VALUE self)
+{
+	rb_dcLibHandle* h;
+	size_t i, c;
+
+	if(!rb_block_given_p())
+		rb_raise(rb_eRuntimeError, "no block given");
+
+	Data_Get_Struct(self, rb_dcLibHandle, h);
+	ExtLib_SecCheckSyms(h);
+
+	c = dlSymsCount(h->syms);
+	for(i=0; i<c; ++i)
+		rb_yield(ID2SYM(rb_intern(dlSymsName(h->syms, i))));
+
+	return self;
+}
+
+/* expose dlSymsName @@@ */
+
+
+/* Methods interfacing with dyncall */
+static VALUE ExtLib_Call(int argc, VALUE* argv, VALUE self)
+{
+	/* argv[0] - symbol to call  *
+	 * argv[1] - signature       *
+	 * argv[2] - first parameter *
+	 * argv[x] - parameter x-2   */
+
+	rb_dcLibHandle* h;
+	DCpointer       fptr;
+	int             i, t, b;
+	VALUE           r;
+	DCCallVM*       cvm;
+	const char*     sig;
+
+
+	/* Security checks. */
+	if(argc < 2)
+		rb_raise(rb_eRuntimeError, "wrong number of arguments for function call");
+
+	if(TYPE(argv[0]) != T_SYMBOL)
+		rb_raise(rb_eRuntimeError, "syntax error - argument 0 must be of type 'Symbol'");
+
+	if(TYPE(argv[1]) != T_STRING)
+		rb_raise(rb_eRuntimeError, "syntax error - argument 1 must be of type 'String'");
+
+	Data_Get_Struct(self, rb_dcLibHandle, h);
+	cvm = h->cvm;
+
+	if(argc != RSTRING_LEN(argv[1]))	/* Don't count the return value in the signature @@@ write something more secure */
+		rb_raise(rb_eRuntimeError, "number of provided arguments doesn't match signature");
+
+	ExtLib_SecCheckLib(h);
+
+
+	/* Flush old arguments. */
+	dcReset(cvm);
+
+
+	/* Get a pointer to the function and start pushing. */
+	fptr = (DCpointer)dlFindSymbol(h->lib, rb_id2name(SYM2ID(argv[0])));
+	sig = RSTRING_PTR(argv[1]);
+
+	for(i=2; i<argc; ++i) {
+		t = TYPE(argv[i]);
+
+		switch(sig[i-2]) {
+			case DC_SIGCHAR_BOOL:
+				b = 1;
+				switch(t) {
+					case T_TRUE:   dcArgBool(cvm, DC_TRUE);                break;  /* TrueClass.  */
+					case T_FALSE:                                                  /* FalseClass. */
+					case T_NIL:    dcArgBool(cvm, DC_FALSE);               break;  /* NilClass.   */
+					case T_FIXNUM: dcArgBool(cvm, FIX2LONG(argv[i]) != 0); break;  /* Fixnum.     */
+					default:       b = 0;                                  break;
+				}
+				break;
+
+			case DC_SIGCHAR_CHAR:
+			case DC_SIGCHAR_UCHAR:     if(b = (t == T_FIXNUM)) dcArgChar    (cvm, (DCchar)    FIX2LONG(argv[i]));      break;
+			case DC_SIGCHAR_SHORT:
+			case DC_SIGCHAR_USHORT:    if(b = (t == T_FIXNUM)) dcArgShort   (cvm, (DCshort)   FIX2LONG(argv[i]));      break;
+			case DC_SIGCHAR_INT:
+			case DC_SIGCHAR_UINT:      if(b = (t == T_FIXNUM)) dcArgInt     (cvm, (DCint)     FIX2LONG(argv[i]));      break;
+			case DC_SIGCHAR_LONG:
+			case DC_SIGCHAR_ULONG:     if(b = (t == T_FIXNUM)) dcArgLong    (cvm, (DClong)    FIX2LONG(argv[i]));      break;
+			case DC_SIGCHAR_LONGLONG:
+			case DC_SIGCHAR_ULONGLONG: if(b = (t == T_FIXNUM)) dcArgLongLong(cvm, (DClonglong)FIX2LONG(argv[i]));      break;
+			case DC_SIGCHAR_FLOAT:     if(b = (t == T_FLOAT))  dcArgFloat   (cvm, (DCfloat)   RFLOAT_VALUE(argv[i]));  break;
+			case DC_SIGCHAR_DOUBLE:    if(b = (t == T_FLOAT))  dcArgDouble  (cvm, (DCdouble)  RFLOAT_VALUE(argv[i]));  break;
+
+			case DC_SIGCHAR_POINTER:
+			case DC_SIGCHAR_STRING:
+				b = 1;	
+				switch(t) {
+					case T_STRING: dcArgPointer(cvm, RSTRING_PTR(argv[i])); break;  /* String. */
+					default:       b = 0;                                   break;
+				}
+				break;
+
+			default:
+				b = 0;
+				break;
+		}
+
+
+		if(!b)
+			rb_raise(rb_eRuntimeError, "syntax error in signature or type mismatch at argument %d", i-2);
+	}
+
+
+	/* Get the return type and call the function. */
+	switch(sig[i-1]) {
+		case DC_SIGCHAR_VOID:      r = Qnil;        dcCallVoid    (cvm, fptr);                  break;
+		case DC_SIGCHAR_BOOL:      r =              dcCallBool    (cvm, fptr) ? Qtrue : Qfalse; break;
+		case DC_SIGCHAR_CHAR:
+		case DC_SIGCHAR_UCHAR:     r = CHR2FIX(     dcCallChar    (cvm, fptr));                 break;
+		case DC_SIGCHAR_SHORT:
+		case DC_SIGCHAR_USHORT:    r = INT2FIX(     dcCallShort   (cvm, fptr));                 break;
+		case DC_SIGCHAR_INT:
+		case DC_SIGCHAR_UINT:      r = INT2FIX(     dcCallInt     (cvm, fptr));                 break;
+		case DC_SIGCHAR_LONG:
+		case DC_SIGCHAR_ULONG:     r = INT2FIX(     dcCallLong    (cvm, fptr));                 break;
+		case DC_SIGCHAR_LONGLONG:
+		case DC_SIGCHAR_ULONGLONG: r = INT2FIX(     dcCallLongLong(cvm, fptr));                 break;
+		case DC_SIGCHAR_FLOAT:     r = rb_float_new(dcCallFloat   (cvm, fptr));                 break;
+		case DC_SIGCHAR_DOUBLE:    r = rb_float_new(dcCallDouble  (cvm, fptr));                 break;
+		case DC_SIGCHAR_STRING:    r = rb_str_new2( dcCallPointer (cvm, fptr));                 break;
+		case DC_SIGCHAR_POINTER:
+		default:
+			rb_raise(rb_eRuntimeError, "unsupported return type or syntax error in signature");
+	}
+
+	return r;
+}
+
+
+/* Main initialization. */
+void Init_rbdc()
+{
+	rb_dcModule = rb_define_module("Dyncall");
+
+	/* Handle to the external dynamic library. */
+	rb_dcExtLib = rb_define_class_under(rb_dcModule, "ExtLib", rb_cObject);
+
+	/* Class allocators. */
+	rb_define_alloc_func(rb_dcExtLib, AllocExtLib);
+
+	/* Methods. */
+	rb_define_method(rb_dcExtLib, "load",       &ExtLib_Load,      1);
+	rb_define_method(rb_dcExtLib, "exists?",    &ExtLib_ExistsQ,   1);
+	rb_define_method(rb_dcExtLib, "syms_init",  &ExtLib_SymsInit,  1);
+	rb_define_method(rb_dcExtLib, "syms_count", &ExtLib_SymsCount, 0);
+	rb_define_method(rb_dcExtLib, "syms_each",  &ExtLib_SymsEach, -1);
+	rb_define_method(rb_dcExtLib, "call",       &ExtLib_Call,     -1);
+}
+

data/dyncall/AUTHORS

@@ -0,0 +1,4 @@
+Daniel Adler <dadler@uni-goettingen.de>
+Tassilo Philipp <tphilipp@potion-studios.com>
+Olivier Chafik <olivier.chafik@gmail.com>
+

data/dyncall/BUGS

@@ -0,0 +1,3 @@
+- add support for SELinux; object files need to be tagged with section '.section .note.GNU-stack,"",%progbits'
+- dyncall sparc v7/v8: -xO3 on SunPro segfaults in tests.
+- dyncall sparc64 port: works fine on Debian 6, but has issues on OpenBSD and Solaris regarding passing of float and double values.

data/dyncall/CMakeLists.txt

@@ -0,0 +1,79 @@
+# Package: dyncall
+# File: CMakeLists.txt
+# Description: DynCall Project cmake files
+# License:
+#
+# Copyright (c) 2010 Daniel Adler <dadler@uni-goettingen.de>
+# 
+# Permission to use, copy, modify, and distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+#
+
+cmake_minimum_required (VERSION 2.6)
+project(DynCall)
+
+set(CPACK_PACKAGE_DESCRIPTION_SUMMARY "dyncall enables dynamic invocation of machine-level function calls")
+set(CPACK_PACKAGE_VENDOR "dyncall project")
+set(CPACK_PACKAGE_DESCRIPTION_FILE "${CMAKE_CURRENT_SOURCE_DIR}/doc/Description.txt")
+set(CPACK_RESOURCE_FILE_LICENSE "${CMAKE_CURRENT_SOURCE_DIR}/doc/License.txt")
+if(APPLE)
+set(CPACK_RESOURCE_FILE_README "${CMAKE_CURRENT_SOURCE_DIR}/doc/Description.txt")
+endif(APPLE)
+set(CPACK_PACKAGE_NAME "dyncall")
+include(CPack)
+
+# add cmake modules shipped with the package to cmake's module path.
+# currently we have no use for this, but maybe later..
+#set(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/buildsys/cmake/Modules" "${CMAKE_MODULE_PATH}")
+
+
+if(MSVC)
+  enable_language(ASM_MASM)
+  #if(CMAKE_SIZEOF_VOID_P MATCHES 8)
+  #  set(CMAKE_ASM_COMPILER "ml64")
+  #else()
+  #  set(CMAKE_ASM_COMPILER "ml")
+  #endif()
+  #set(CMAKE_ASM_COMPILER_ARG1 "/c")
+  #set(CMAKE_ASM_MASM_SOURCE_FILE_EXTENSIONS asm)
+  #set(CMAKE_ASM_MASM_COMPILE_OBJECT "<CMAKE_ASM_MASM_COMPILER> <FLAGS> /c /Fo <OBJECT> <SOURCE>")
+elseif(CMAKE_COMPILER_IS_GNUCC)
+  # when used in shared libraries, -fPIC is required by several architectures
+  # and platforms (observed on AMD64, Solaris/Sparc).
+  # we enable it per default here.
+  add_definitions("-fPIC")
+  # enable gcc as front-end to assembler for .S files
+  set(CMAKE_ASM_COMPILER "${CMAKE_C_COMPILER}")
+  set(CMAKE_ASM_COMPILER_ARG1 "${CPPFLAGS} -c")
+  enable_language(ASM)
+elseif("${CMAKE_C_COMPILER_ID}" STREQUAL "SunPro")
+  set(CMAKE_ASM_COMPILER "${CMAKE_C_COMPILER}")
+  set(CMAKE_ASM_COMPILER_ARG1 "${CPPFLAGS} -c")
+  enable_language(ASM)
+endif()
+
+
+add_subdirectory(dynload)
+add_subdirectory(dyncall)
+add_subdirectory(dyncallback)
+add_subdirectory(doc/manual EXCLUDE_FROM_ALL)
+add_subdirectory(test EXCLUDE_FROM_ALL)
+
+# install cmake Find scripts (disabled per default)
+
+option(INSTALL_CMAKE_MODULES "install cmake modules to locate dyncall" "NO")
+
+if(INSTALL_CMAKE_MODULES)
+file(GLOB INSTALL_CMAKE_MODULES_FILES buildsys/cmake/Modules/Find*.cmake)
+install(FILES ${INSTALL_CMAKE_MODULES_FILES} DESTINATION ${CMAKE_ROOT}/Modules)
+endif(INSTALL_CMAKE_MODULES)
+