jyapayne/swig
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Perl added to the Unified typemap library, cleaner way to use the library, and 'normalized' macro names

Browse source 
git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk/SWIG@7707 626c5289-ae23-0410-ae9c-e8d60b6d4f22
This commit is contained in:
Marcelo Matus 2005-10-24 14:59:05 +00:00
commit 3c65cea431
112 changed files with 3262 additions and 3375 deletions
Download patch file Download diff file Expand all files Collapse all files

9
Lib/ruby/cstring.i
View file

@ -1,10 +1 @@
%include <typemaps/cstring.swg>
%include <rubystrings.swg>
%typemap_cstrings(%cstring,
char,
SWIG_AsCharPtr,
SWIG_AsCharPtrAndSize,
SWIG_FromCharPtr,
SWIG_FromCharPtrAndSize);

2
Lib/ruby/rubyapi.swg
View file

@ -7,7 +7,7 @@ extern "C" {
#endif
SWIGINTERN VALUE
SWIG_Ruby_AppendResult(VALUE target, VALUE o) {
SWIG_Ruby_AppendOutput(VALUE target, VALUE o) {
if (NIL_P(target)) {
target = o;
} else {

197
Lib/ruby/rubyprimtypes.swg
View file

@ -1,33 +1,30 @@
%include <typemaps/primtypes.swg>
/* Macro for 'signed long' derived types */
%define %type_slong(Type, Frag, Min, Max)
%derived_type_from(long, Type)
%signed_derived_type_asval(long, Type, Frag, Min, Max)
%enddef
/* Macro for 'unsigned long' derived types */
%define %type_ulong(Type, Frag, Max)
%derived_type_from(unsigned long, Type)
%unsigned_derived_type_asval(unsigned long, Type, Frag, Max)
%enddef
/* ------------------------------------------------------------
* Primitive Types
* ------------------------------------------------------------ */
/* auxiliar ruby fail method */
%fragment("SWIG_ruby_failed","header")
{
SWIGINTERN VALUE
SWIG_ruby_failed()
{
return Qnil;
}
}
%define %ruby_aux_method(Type, Method, Action)
SWIGINTERN VALUE SWIG_AUX_##Method##(VALUE *args)
{
VALUE obj = args[0];
VALUE type = TYPE(obj);
Type *res = (Type *)(args[1]);
*res = Action;
return obj;
}
%enddef
/* boolean */
@ -61,48 +58,24 @@ SWIG_AsVal_dec(bool)(VALUE obj, bool *val)
}
}
/* signed/unsigned char */
%type_slong(signed char, "<limits.h>", SCHAR_MIN, SCHAR_MAX)
%type_ulong(unsigned char, "<limits.h>", UCHAR_MAX)
/* short/unsigned short */
%type_slong(short, "<limits.h>", SHRT_MIN, SHRT_MAX)
%type_ulong(unsigned short, "<limits.h>", USHRT_MAX)
/* int/unsigned int */
%type_slong(int, "<limits.h>", INT_MIN, INT_MAX)
%type_ulong(unsigned int, "<limits.h>", UINT_MAX)
/* signed/unsigned wchar_t */
#ifdef __cplusplus
%type_slong(signed wchar_t, "<wchar.h>", WCHAR_MIN, WCHAR_MAX)
%type_ulong(unsigned wchar_t, "<wchar.h>", UWCHAR_MAX)
#endif
/* long */
%fragment(SWIG_From_frag(long),"header",
fragment="<limits.h>") {
SWIG_define(SWIG_From_dec(long), LONG2NUM)
%define_as(SWIG_From_dec(long), LONG2NUM)
}
%fragment(SWIG_AsVal_frag(long),"header",fragment="SWIG_ruby_failed") {
SWIGINTERN VALUE SWIG_num2long(VALUE *args)
{
*((long *)(args[1])) = NUM2LONG(args[0]);
return args[0];
}
%ruby_aux_method(long, NUM2LONG, type == T_FIXNUM ? NUM2LONG(obj) : rb_big2long(obj))
SWIGINTERN int
SWIG_AsVal_dec(long)(VALUE obj, long* val)
{
if (obj != Qnil && ((TYPE(obj) == T_FIXNUM) || (TYPE(obj) == T_BIGNUM))) {
VALUE type = TYPE(obj);
if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
long v;
VALUE a[2] = { obj, (VALUE)(&v) };
if (rb_rescue(RUBY_METHOD_FUNC(SWIG_num2long), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2LONG), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
if (val) *val = v;
return SWIG_OK;
}
@ -123,18 +96,16 @@ SWIG_From_dec(unsigned long)(unsigned long value)
}
%fragment(SWIG_AsVal_frag(unsigned long),"header",fragment="SWIG_ruby_failed") {
SWIGINTERN VALUE SWIG_num2ulong(VALUE *args)
{
*((unsigned long *)(args[1])) = NUM2ULONG(args[0]);
return args[0];
}
%ruby_aux_method(unsigned long, NUM2ULONG, type == T_FIXNUM ? NUM2ULONG(obj) : rb_big2ulong(obj))
SWIGINTERN int
SWIG_AsVal_dec(unsigned long)(VALUE obj, unsigned long *val)
{
if (obj != Qnil && ((TYPE(obj) == T_FIXNUM) || (TYPE(obj) == T_BIGNUM))) {
VALUE type = TYPE(obj);
if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
unsigned long v;
VALUE a[2] = { obj, (VALUE)(&v) };
if (rb_rescue(RUBY_METHOD_FUNC(SWIG_num2ulong), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2ULONG), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
if (val) *val = v;
return SWIG_OK;
}
@ -156,18 +127,16 @@ SWIG_From_dec(long long)(long long value)
}
%fragment(SWIG_AsVal_frag(long long),"header",fragment="SWIG_ruby_failed") {
SWIGINTERN VALUE SWIG_num2longlong(VALUE *args)
{
*((long long *)(args[1])) = NUM2LL(args[0]);
return args[0];
}
%ruby_aux_method(long long, NUM2LL, type == T_FIXNUM ? NUM2LL(obj) : rb_big2ll(obj))
SWIGINTERN int
SWIG_AsVal_dec(long long)(VALUE obj, long long *val)
{
if (obj != Qnil && ((TYPE(obj) == T_FIXNUM) || (TYPE(obj) == T_BIGNUM))) {
VALUE type = TYPE(obj);
if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
long long v;
VALUE a[2] = { obj, (VALUE)(&v) };
if (rb_rescue(RUBY_METHOD_FUNC(SWIG_num2longlong), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2LL), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
if (val) *val = v;
return SWIG_OK;
}
@ -189,18 +158,16 @@ SWIG_From_dec(unsigned long long)(unsigned long long value)
}
%fragment(SWIG_AsVal_frag(unsigned long long),"header",fragment="SWIG_ruby_failed") {
SWIGINTERN VALUE SWIG_num2ulonglong(VALUE *args)
{
*((unsigned long long *)(args[1])) = NUM2ULL(args[0]);
return args[0];
}
%ruby_aux_method(long long, NUM2ULL, type == T_FIXNUM ? NUM2ULL(obj) : rb_big2ull(obj))
SWIGINTERN int
SWIG_AsVal_dec(unsigned long long)(VALUE obj, unsigned long long *val)
{
if (obj != Qnil && ((TYPE(obj) == T_FIXNUM) || (TYPE(obj) == T_BIGNUM))) {
{
VALUE type = TYPE(obj);
if ((type == T_FIXNUM) || (type == T_BIGNUM)) {
unsigned long long v;
VALUE a[2] = { obj, (VALUE)(&v) };
if (rb_rescue(RUBY_METHOD_FUNC(SWIG_num2ulonglong), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2ULL), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
if (val) *val = v;
return SWIG_OK;
}
@ -209,30 +176,23 @@ SWIG_AsVal_dec(unsigned long long)(VALUE obj, unsigned long long *val)
}
}
/* float */
%derived_type_from(double, float)
%signed_derived_type_asval(double, float, "<float.h>", -FLT_MAX, FLT_MAX)
/* double */
%fragment(SWIG_From_frag(double),"header") {
SWIG_define(SWIG_From_dec(double), rb_float_new)
%define_as(SWIG_From_dec(double), rb_float_new)
}
%fragment(SWIG_AsVal_frag(double),"header",fragment="SWIG_ruby_failed") {
SWIGINTERN VALUE SWIG_num2dbl(VALUE *args)
{
*((double *)(args[1])) = NUM2DBL(args[0]);
return args[0];
}
%ruby_aux_method(double, NUM2DBL, (type == T_FLOAT ? NUM2DBL(obj) : (type == T_FIXNUM ? (double) FIX2INT(obj) : rb_big2dbl(obj))))
SWIGINTERN int
SWIG_AsVal_dec(double)(VALUE obj, double *val)
{
if (obj != Qnil &&((TYPE(obj) == T_FLOAT) || (TYPE(obj) == T_FIXNUM) || (TYPE(obj) == T_BIGNUM))) {
VALUE type = TYPE(obj);
if ((type == T_FLOAT) || (type == T_FIXNUM) || (type == T_BIGNUM)) {
double v;
VALUE a[2] = { obj, (VALUE)(&v) };
if (rb_rescue(RUBY_METHOD_FUNC(SWIG_num2dbl), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
if (rb_rescue(RUBY_METHOD_FUNC(SWIG_AUX_NUM2DBL), (VALUE)a, RUBY_METHOD_FUNC(SWIG_ruby_failed), 0) != Qnil) {
if (val) *val = v;
return SWIG_OK;
}
@ -241,77 +201,4 @@ SWIG_AsVal_dec(double)(VALUE obj, double *val)
}
}
/* char */
%fragment(SWIG_From_frag(char),"header") {
SWIGINTERNINLINE VALUE
SWIG_From_dec(char)(char c)
{
return rb_str_new(&c,1);
}
}
%fragment(SWIG_AsVal_frag(char),"header",
fragment="SWIG_AsCharArray",
fragment=SWIG_AsVal_frag(signed char)) {
SWIGINTERN int
SWIG_AsVal_dec(char)(VALUE obj, char *val)
{
signed char v;
if (SWIG_AsVal(signed char)(obj, &v) == SWIG_OK) {
if (val) *val = (char)(v);
return SWIG_OK;
} else {
if (SWIG_AsCharArray(obj, val, 1) == SWIG_OK) {
return SWIG_OK;
}
}
return SWIG_TypeError;
}
}
/* wchar_t */
%fragment(SWIG_From_frag(wchar_t),"header",
fragment=SWIG_From_frag(char),
fragment=SWIG_From_frag(long)) {
SWIGINTERNINLINE VALUE
SWIG_From_dec(wchar_t)(wchar_t c)
{
if (CHAR_MIN <= v && v <= CHAR_MAX) {
return SWIG_From(char)((char)c);
} else {
return SWIG_From(long)((long)c);
}
}
}
%fragment(SWIG_AsVal_frag(wchar_t),"header",
fragment="SWIG_AsWCharArray",
fragment=SWIG_AsVal_frag(long)) {
SWIGINTERN int
SWIG_AsVal_dec(wchar_t)(VALUE obj, wchar_t *val)
{
char v;
if (SWIG_AsVal(char)(obj, &v) == SWIG_OK) {
if (val) *val = (wchar_t)(v);
return SWIG_OK;
} else {
long v;
if (SWIG_AsVal(long)(obj, &v) == SWIG_OK) {
if (WCHAR_MIN <= v && v <= WCHAR_MAX) {
if (val) *val = (wchar_t)(v);
return SWIG_OK;
}
}
}
return SWIG_TypeError;
}
}
/* ------------------------------------------------------------
* Apply the primitive typemap for all the types with checkcode
* ------------------------------------------------------------ */
%apply_checkctypes(%typemap_primitive)

12
Lib/ruby/rubyrun.swg
View file

@ -12,19 +12,19 @@
#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Ruby_NewPointerObj(ptr, type, flags)
/* for raw packed data */
#define SWIG_ConvertPacked(obj, ptr, sz, ty, flags) SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)
#define SWIG_NewPackedObj(ptr, sz, type, flags) SWIG_Ruby_NewPackedObj(ptr, sz, type)
#define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)
#define SWIG_NewPackedObj(ptr, sz, type) SWIG_Ruby_NewPackedObj(ptr, sz, type)
/* for class or struct pointers */
#define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_Ruby_ConvertPtr(obj, pptr, type, flags)
#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_Ruby_NewPointerObj(ptr, type, flags)
/* for C or C++ function pointers */
#define SWIG_ConvertFunctionPtr(obj, pptr, type, flags) SWIG_Ruby_ConvertPtr(obj, pptr, type, flags)
#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Ruby_ConvertPtr(obj, pptr, type, 0)
#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Ruby_NewPointerObj(ptr, type, 0)
/* for C++ member pointers, ie, member methods */
#define SWIG_ConvertMember(obj, ptr, sz, ty, flags) SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty, flags)
#define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Ruby_ConvertPacked(obj, ptr, sz, ty)
#define SWIG_NewMemberObj(ptr, sz, type) SWIG_Ruby_NewPackedObj(ptr, sz, type)
@ -44,7 +44,7 @@
/* Ruby-specific SWIG API */
#define SWIG_InitRuntime() SWIG_Ruby_InitRuntime()
#define SWIG_define_class(ty) SWIG_Ruby_define_class(ty)
#define SWIG_define_class(ty) SWIG_Ruby_define_class(ty)
#define SWIG_NewClassInstance(value, ty) SWIG_Ruby_NewClassInstance(value, ty)
#define SWIG_MangleStr(value) SWIG_Ruby_MangleStr(value)
#define SWIG_CheckConvert(value, ty) SWIG_Ruby_CheckConvert(value, ty)
@ -243,7 +243,7 @@ SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
/* Convert a packed value value */
SWIGRUNTIME int
SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty, int flags) {
SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty) {
swig_cast_info *tc;
const char *c;

12
Lib/ruby/rubystrings.swg
View file

@ -21,7 +21,7 @@ SWIG_AsCharPtrAndSize(VALUE obj, char** cptr, size_t* psize, int *alloc)
if (cptr) {
if (alloc) {
if (*alloc == SWIG_NEWOBJ) {
*cptr = SWIG_new_copy_array(cstr, size, char);
*cptr = %new_copy_array(cstr, size, char);
} else {
*cptr = cstr;
*alloc = SWIG_OLDOBJ;
@ -42,9 +42,9 @@ SWIG_FromCharPtrAndSize(const char* carray, size_t size)
{
if (carray) {
if (size > LONG_MAX) {
return SWIG_NewPointerObj(SWIG_const_cast(carray,char *), SWIG_TypeQuery("char *"), 0);
return SWIG_NewPointerObj(%const_cast(carray,char *), SWIG_TypeQuery("char *"), 0);
} else {
return rb_str_new(carray, SWIG_numeric_cast(size,long));
return rb_str_new(carray, %numeric_cast(size,long));
}
} else {
return Qnil;
@ -52,9 +52,3 @@ SWIG_FromCharPtrAndSize(const char* carray, size_t size)
}
}
/* ------------------------------------------------------------
* The plain char * handling
* ------------------------------------------------------------ */
%include <typemaps/strings.swg>
%typemap_string(char, Char, SWIG_AsCharPtrAndSize, SWIG_FromCharPtrAndSize, strlen)

28
Lib/ruby/rubytypemaps.swg
View file

@ -10,37 +10,31 @@
/* -----------------------------------------------------------------------------
* Basic definitions
* ----------------------------------------------------------------------------- */
#define %convertptr_flags $track
#define %newpointer_flags $track
#define %newinstance_flags $track
%define_swig_object(VALUE)
#define SWIG_Object VALUE
#define VOID_Object Qnil
#define SWIG_VoidObject() Qnil
#define SWIG_SetResultObj(obj) $result = obj
#define SWIG_AppendResultObj(obj) $result = SWIG_Ruby_AppendResult($result, obj)
#define SWIG_SetConstantObj(name, obj) rb_define_const($module, name, obj)
#define SWIG_Raise(obj, type, desc) rb_exc_raise(rb_exc_new3(rb_eRuntimeError, rb_obj_as_string(obj)))
#define SWIG_DirOutFail(code, msg) Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(code), msg)
#define SWIG_AppendOutput(result,obj) SWIG_Ruby_AppendOutput(result, obj)
#define SWIG_SetConstant(name, obj) rb_define_const($module, name, obj)
#define SWIG_Raise(obj, type, desc) rb_exc_raise(rb_exc_new3(rb_eRuntimeError, rb_obj_as_string(obj)))
#define SWIG_DirOutFail(code, msg) Swig::DirectorTypeMismatchException::raise(SWIG_ErrorType(code), msg)
/* -----------------------------------------------------------------------------
* All the typemaps
* ----------------------------------------------------------------------------- */
%include <typemaps/exception.swg>
%include <typemaps/swigtype.swg>
%include <typemaps/void.swg>
%include <typemaps/valtypes.swg>
%include <typemaps/ptrtypes.swg>
%include <typemaps/swigobject.swg>
%include <typemaps/inoutlist.swg>
%include <rubyprimtypes.swg>
%include <rubystrings.swg>
%include <typemaps/misctypes.swg>
%include <typemaps/enumint.swg>
%include <typemaps/swigtypemaps.swg>
/* -----------------------------------------------------------------------------
* Backward compatibility output helper
* ----------------------------------------------------------------------------- */
%fragment("output_helper","header") %{
#define output_helper SWIG_Ruby_AppendResult
#define output_helper SWIG_Ruby_AppendOutput
%}

74
Lib/ruby/rubywstrings.swg
View file

@ -1,74 +0,0 @@
/* ------------------------------------------------------------
* utility methods for wchar_t strings
* ------------------------------------------------------------ */
/*
Ruby doesn't support the wchar_t, so, we need to use an 'opaque' type.
*/
%types(ruby_wchar_array *);
%fragment("ruby_wchar_array","header",fragment="<wchar.h>") {
struct ruby_wchar_array {
wchar_t *cptr;
size_t size;
};
SWIGINTERN get_ruby_wchar_array_info() {
static swig_type_info* ruby_wchar_array_info = 0;
if (!ruby_wchar_array_info) ruby_wchar_array_info = SWIG_TypeQuery("ruby_wchar_array *");
return ruby_wchar_array_info;
}
}
%fragment("SWIG_AsWCharPtrAndSize","header",fragment="ruby_wchar_array") {
SWIGINTERN int
SWIG_AsWCharPtrAndSize(PyObject *obj, wchar_t **cptr, size_t *psize, int *alloc)
{
static swig_type_info* ptr_wchar_info = 0;
wchar_t * vptr = 0;
if (!ptr_wchar_info) ptr_wchar_info = SWIG_TypeQuery("wchar_t *");
if (SWIG_ConvertPtr(obj, (void**)&vptr, ptr_wchar_info, 0) != SWIG_OK) {
if (cptr) *cptr = vptr;
if (psize) *psize = vptr ? (wcslen(vptr) + 1) : 0;
return SWIG_OK;
} else {
ruby_wchar_array *vptr = 0;
if (SWIG_ConvertPtr(obj, (void**)&vptr, get_ruby_wchar_array_info(), 0) != SWIG_OK) {
if (cptr) *cptr = vptr->cptr;
if (psize) *psize = vprtr->size;
return SWIG_OK;
}
}
return SWIG_TypeError;
}
}
%fragment("SWIG_FromWCharPtrAndSize","header",fragment="ruby_wchar_array") {
SWIGINTERNINLINE PyObject *
SWIG_FromWCharPtrAndSize(const wchar_t * carray, size_t size)
{
ruby_wchar_array *vptr = SWIG_new(ruby_wchar_array);
vptr->cptr = carray;
vptr->size = size;
return SWIG_NewPointerObj(SWIG_const_cast(carray,wchar_t *), get_ruby_wchar_array_info(), 1);
}
}
%fragment("SWIG_FromWCharPtr","header",fragment="<wchar.h>") {
SWIGINTERNINLINE PyObject *
SWIG_FromWCharPtr(const wchar_t * carray)
{
static swig_type_info* wchar_ptr_info = 0;
if (!wchar_array_info) wchar_ptr_info = SWIG_TypeQuery("wchar_t *");
return SWIG_NewPointerObj(SWIG_const_cast(carray,wchar_t *), wchar_ptr_info, 0);
}
}
/* ------------------------------------------------------------
* The plain wchar_t * handling
* ------------------------------------------------------------ */
%include <typemaps/strbase.swg>
%typemap_string(wchar_t, WChar, SWIG_AsWCharPtrAndSize, SWIG_FromWCharPtrAndSize, wcslen);

29
Lib/ruby/std_string.i
View file

@ -1,30 +1 @@
//
// std::string
//
#ifndef SWIG_STD_BASIC_STRING
#define SWIG_STD_STRING
%{
#include <string>
%}
namespace std
{
class string;
}
%include <typemaps/std_string.swg>
%include <rubystrings.swg>
%std_string_asptr(std::string, char, SWIG_AsCharPtrAndSize)
%std_string_from(std::string, SWIG_FromCharPtrAndSize)
%std_string_asval(std::string)
%typemap_asptrfromn(SWIG_CCode(STRING), std::string);
#else
%include <std/std_string.i>
#endif