mirror of
https://github.com/nillerusr/source-engine.git
synced 2024-12-23 14:46:53 +00:00
445 lines
13 KiB
Plaintext
445 lines
13 KiB
Plaintext
/* -----------------------------------------------------------------------------
|
|
* See the LICENSE file for information on copyright, usage and redistribution
|
|
* of SWIG, and the README file for authors - http://www.swig.org/release.html.
|
|
*
|
|
* rubyrun.swg
|
|
*
|
|
* This file contains the runtime support for Ruby modules
|
|
* and includes code for managing global variables and pointer
|
|
* type checking.
|
|
* ----------------------------------------------------------------------------- */
|
|
|
|
/* For backward compatibility only */
|
|
#define SWIG_POINTER_EXCEPTION 0
|
|
|
|
/* for raw pointers */
|
|
#define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
|
|
#define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Ruby_ConvertPtrAndOwn(obj, pptr, type, flags, own)
|
|
#define SWIG_NewPointerObj(ptr, type, flags) SWIG_Ruby_NewPointerObj(ptr, type, flags)
|
|
#define SWIG_AcquirePtr(ptr, own) SWIG_Ruby_AcquirePtr(ptr, own)
|
|
#define swig_owntype ruby_owntype
|
|
|
|
/* for raw packed data */
|
|
#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_ConvertPtr(obj, pptr, type, flags)
|
|
#define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
|
|
|
|
/* for C or C++ function pointers */
|
|
#define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0)
|
|
#define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0)
|
|
|
|
/* for C++ member pointers, ie, member methods */
|
|
#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)
|
|
|
|
|
|
/* Runtime API */
|
|
|
|
#define SWIG_GetModule(clientdata) SWIG_Ruby_GetModule()
|
|
#define SWIG_SetModule(clientdata, pointer) SWIG_Ruby_SetModule(pointer)
|
|
|
|
|
|
/* Error manipulation */
|
|
|
|
#define SWIG_ErrorType(code) SWIG_Ruby_ErrorType(code)
|
|
#define SWIG_Error(code, msg) rb_raise(SWIG_Ruby_ErrorType(code), msg)
|
|
#define SWIG_fail goto fail
|
|
|
|
|
|
/* Ruby-specific SWIG API */
|
|
|
|
#define SWIG_InitRuntime() SWIG_Ruby_InitRuntime()
|
|
#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)
|
|
|
|
#include "assert.h"
|
|
|
|
/* -----------------------------------------------------------------------------
|
|
* pointers/data manipulation
|
|
* ----------------------------------------------------------------------------- */
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
typedef struct {
|
|
VALUE klass;
|
|
VALUE mImpl;
|
|
void (*mark)(void *);
|
|
void (*destroy)(void *);
|
|
int trackObjects;
|
|
} swig_class;
|
|
|
|
|
|
/* Global pointer used to keep some internal SWIG stuff */
|
|
static VALUE _cSWIG_Pointer = Qnil;
|
|
static VALUE swig_runtime_data_type_pointer = Qnil;
|
|
|
|
/* Global IDs used to keep some internal SWIG stuff */
|
|
static ID swig_arity_id = 0;
|
|
static ID swig_call_id = 0;
|
|
|
|
/*
|
|
If your swig extension is to be run within an embedded ruby and has
|
|
director callbacks, you should set -DRUBY_EMBEDDED during compilation.
|
|
This will reset ruby's stack frame on each entry point from the main
|
|
program the first time a virtual director function is invoked (in a
|
|
non-recursive way).
|
|
If this is not done, you run the risk of Ruby trashing the stack.
|
|
*/
|
|
|
|
#ifdef RUBY_EMBEDDED
|
|
|
|
# define SWIG_INIT_STACK \
|
|
if ( !swig_virtual_calls ) { RUBY_INIT_STACK } \
|
|
++swig_virtual_calls;
|
|
# define SWIG_RELEASE_STACK --swig_virtual_calls;
|
|
# define Ruby_DirectorTypeMismatchException(x) \
|
|
rb_raise( rb_eTypeError, x ); return c_result;
|
|
|
|
static unsigned int swig_virtual_calls = 0;
|
|
|
|
#else /* normal non-embedded extension */
|
|
|
|
# define SWIG_INIT_STACK
|
|
# define SWIG_RELEASE_STACK
|
|
# define Ruby_DirectorTypeMismatchException(x) \
|
|
throw Swig::DirectorTypeMismatchException( x );
|
|
|
|
#endif /* RUBY_EMBEDDED */
|
|
|
|
|
|
SWIGRUNTIME VALUE
|
|
getExceptionClass(void) {
|
|
static int init = 0;
|
|
static VALUE rubyExceptionClass ;
|
|
if (!init) {
|
|
init = 1;
|
|
rubyExceptionClass = rb_const_get(_mSWIG, rb_intern("Exception"));
|
|
}
|
|
return rubyExceptionClass;
|
|
}
|
|
|
|
/* This code checks to see if the Ruby object being raised as part
|
|
of an exception inherits from the Ruby class Exception. If so,
|
|
the object is simply returned. If not, then a new Ruby exception
|
|
object is created and that will be returned to Ruby.*/
|
|
SWIGRUNTIME VALUE
|
|
SWIG_Ruby_ExceptionType(swig_type_info *desc, VALUE obj) {
|
|
VALUE exceptionClass = getExceptionClass();
|
|
if (rb_obj_is_kind_of(obj, exceptionClass)) {
|
|
return obj;
|
|
} else {
|
|
return rb_exc_new3(rb_eRuntimeError, rb_obj_as_string(obj));
|
|
}
|
|
}
|
|
|
|
/* Initialize Ruby runtime support */
|
|
SWIGRUNTIME void
|
|
SWIG_Ruby_InitRuntime(void)
|
|
{
|
|
if (_mSWIG == Qnil) {
|
|
_mSWIG = rb_define_module("SWIG");
|
|
swig_call_id = rb_intern("call");
|
|
swig_arity_id = rb_intern("arity");
|
|
}
|
|
}
|
|
|
|
/* Define Ruby class for C type */
|
|
SWIGRUNTIME void
|
|
SWIG_Ruby_define_class(swig_type_info *type)
|
|
{
|
|
VALUE klass;
|
|
char *klass_name = (char *) malloc(4 + strlen(type->name) + 1);
|
|
sprintf(klass_name, "TYPE%s", type->name);
|
|
if (NIL_P(_cSWIG_Pointer)) {
|
|
_cSWIG_Pointer = rb_define_class_under(_mSWIG, "Pointer", rb_cObject);
|
|
rb_undef_method(CLASS_OF(_cSWIG_Pointer), "new");
|
|
}
|
|
klass = rb_define_class_under(_mSWIG, klass_name, _cSWIG_Pointer);
|
|
free((void *) klass_name);
|
|
}
|
|
|
|
/* Create a new pointer object */
|
|
SWIGRUNTIME VALUE
|
|
SWIG_Ruby_NewPointerObj(void *ptr, swig_type_info *type, int flags)
|
|
{
|
|
int own = flags & SWIG_POINTER_OWN;
|
|
int track;
|
|
char *klass_name;
|
|
swig_class *sklass;
|
|
VALUE klass;
|
|
VALUE obj;
|
|
|
|
if (!ptr)
|
|
return Qnil;
|
|
|
|
if (type->clientdata) {
|
|
sklass = (swig_class *) type->clientdata;
|
|
|
|
/* Are we tracking this class and have we already returned this Ruby object? */
|
|
track = sklass->trackObjects;
|
|
if (track) {
|
|
obj = SWIG_RubyInstanceFor(ptr);
|
|
|
|
/* Check the object's type and make sure it has the correct type.
|
|
It might not in cases where methods do things like
|
|
downcast methods. */
|
|
if (obj != Qnil) {
|
|
VALUE value = rb_iv_get(obj, "@__swigtype__");
|
|
char* type_name = RSTRING_PTR(value);
|
|
|
|
if (strcmp(type->name, type_name) == 0) {
|
|
return obj;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Create a new Ruby object */
|
|
obj = Data_Wrap_Struct(sklass->klass, VOIDFUNC(sklass->mark),
|
|
( own ? VOIDFUNC(sklass->destroy) :
|
|
(track ? VOIDFUNC(SWIG_RubyRemoveTracking) : 0 )
|
|
), ptr);
|
|
|
|
/* If tracking is on for this class then track this object. */
|
|
if (track) {
|
|
SWIG_RubyAddTracking(ptr, obj);
|
|
}
|
|
} else {
|
|
klass_name = (char *) malloc(4 + strlen(type->name) + 1);
|
|
sprintf(klass_name, "TYPE%s", type->name);
|
|
klass = rb_const_get(_mSWIG, rb_intern(klass_name));
|
|
free((void *) klass_name);
|
|
obj = Data_Wrap_Struct(klass, 0, 0, ptr);
|
|
}
|
|
rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
|
|
|
|
return obj;
|
|
}
|
|
|
|
/* Create a new class instance (always owned) */
|
|
SWIGRUNTIME VALUE
|
|
SWIG_Ruby_NewClassInstance(VALUE klass, swig_type_info *type)
|
|
{
|
|
VALUE obj;
|
|
swig_class *sklass = (swig_class *) type->clientdata;
|
|
obj = Data_Wrap_Struct(klass, VOIDFUNC(sklass->mark), VOIDFUNC(sklass->destroy), 0);
|
|
rb_iv_set(obj, "@__swigtype__", rb_str_new2(type->name));
|
|
return obj;
|
|
}
|
|
|
|
/* Get type mangle from class name */
|
|
SWIGRUNTIMEINLINE char *
|
|
SWIG_Ruby_MangleStr(VALUE obj)
|
|
{
|
|
VALUE stype = rb_iv_get(obj, "@__swigtype__");
|
|
return StringValuePtr(stype);
|
|
}
|
|
|
|
/* Acquire a pointer value */
|
|
typedef void (*ruby_owntype)(void*);
|
|
|
|
SWIGRUNTIME ruby_owntype
|
|
SWIG_Ruby_AcquirePtr(VALUE obj, ruby_owntype own) {
|
|
if (obj) {
|
|
ruby_owntype oldown = RDATA(obj)->dfree;
|
|
RDATA(obj)->dfree = own;
|
|
return oldown;
|
|
} else {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
/* Convert a pointer value */
|
|
SWIGRUNTIME int
|
|
SWIG_Ruby_ConvertPtrAndOwn(VALUE obj, void **ptr, swig_type_info *ty, int flags, ruby_owntype *own)
|
|
{
|
|
char *c;
|
|
swig_cast_info *tc;
|
|
void *vptr = 0;
|
|
|
|
/* Grab the pointer */
|
|
if (NIL_P(obj)) {
|
|
*ptr = 0;
|
|
return SWIG_OK;
|
|
} else {
|
|
if (TYPE(obj) != T_DATA) {
|
|
return SWIG_ERROR;
|
|
}
|
|
Data_Get_Struct(obj, void, vptr);
|
|
}
|
|
|
|
if (own) *own = RDATA(obj)->dfree;
|
|
|
|
/* Check to see if the input object is giving up ownership
|
|
of the underlying C struct or C++ object. If so then we
|
|
need to reset the destructor since the Ruby object no
|
|
longer owns the underlying C++ object.*/
|
|
if (flags & SWIG_POINTER_DISOWN) {
|
|
/* Is tracking on for this class? */
|
|
int track = 0;
|
|
if (ty && ty->clientdata) {
|
|
swig_class *sklass = (swig_class *) ty->clientdata;
|
|
track = sklass->trackObjects;
|
|
}
|
|
|
|
if (track) {
|
|
/* We are tracking objects for this class. Thus we change the destructor
|
|
* to SWIG_RubyRemoveTracking. This allows us to
|
|
* remove the mapping from the C++ to Ruby object
|
|
* when the Ruby object is garbage collected. If we don't
|
|
* do this, then it is possible we will return a reference
|
|
* to a Ruby object that no longer exists thereby crashing Ruby. */
|
|
RDATA(obj)->dfree = SWIG_RubyRemoveTracking;
|
|
} else {
|
|
RDATA(obj)->dfree = 0;
|
|
}
|
|
}
|
|
|
|
/* Do type-checking if type info was provided */
|
|
if (ty) {
|
|
if (ty->clientdata) {
|
|
if (rb_obj_is_kind_of(obj, ((swig_class *) (ty->clientdata))->klass)) {
|
|
if (vptr == 0) {
|
|
/* The object has already been deleted */
|
|
return SWIG_ObjectPreviouslyDeletedError;
|
|
}
|
|
*ptr = vptr;
|
|
return SWIG_OK;
|
|
}
|
|
}
|
|
if ((c = SWIG_MangleStr(obj)) == NULL) {
|
|
return SWIG_ERROR;
|
|
}
|
|
tc = SWIG_TypeCheck(c, ty);
|
|
if (!tc) {
|
|
return SWIG_ERROR;
|
|
} else {
|
|
int newmemory = 0;
|
|
*ptr = SWIG_TypeCast(tc, vptr, &newmemory);
|
|
assert(!newmemory); /* newmemory handling not yet implemented */
|
|
}
|
|
} else {
|
|
*ptr = vptr;
|
|
}
|
|
|
|
return SWIG_OK;
|
|
}
|
|
|
|
/* Check convert */
|
|
SWIGRUNTIMEINLINE int
|
|
SWIG_Ruby_CheckConvert(VALUE obj, swig_type_info *ty)
|
|
{
|
|
char *c = SWIG_MangleStr(obj);
|
|
if (!c) return 0;
|
|
return SWIG_TypeCheck(c,ty) != 0;
|
|
}
|
|
|
|
SWIGRUNTIME VALUE
|
|
SWIG_Ruby_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
|
|
char result[1024];
|
|
char *r = result;
|
|
if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
|
|
*(r++) = '_';
|
|
r = SWIG_PackData(r, ptr, sz);
|
|
strcpy(r, type->name);
|
|
return rb_str_new2(result);
|
|
}
|
|
|
|
/* Convert a packed value value */
|
|
SWIGRUNTIME int
|
|
SWIG_Ruby_ConvertPacked(VALUE obj, void *ptr, int sz, swig_type_info *ty) {
|
|
swig_cast_info *tc;
|
|
const char *c;
|
|
|
|
if (TYPE(obj) != T_STRING) goto type_error;
|
|
c = StringValuePtr(obj);
|
|
/* Pointer values must start with leading underscore */
|
|
if (*c != '_') goto type_error;
|
|
c++;
|
|
c = SWIG_UnpackData(c, ptr, sz);
|
|
if (ty) {
|
|
tc = SWIG_TypeCheck(c, ty);
|
|
if (!tc) goto type_error;
|
|
}
|
|
return SWIG_OK;
|
|
|
|
type_error:
|
|
return SWIG_ERROR;
|
|
}
|
|
|
|
SWIGRUNTIME swig_module_info *
|
|
SWIG_Ruby_GetModule(void)
|
|
{
|
|
VALUE pointer;
|
|
swig_module_info *ret = 0;
|
|
VALUE verbose = rb_gv_get("VERBOSE");
|
|
|
|
/* temporarily disable warnings, since the pointer check causes warnings with 'ruby -w' */
|
|
rb_gv_set("VERBOSE", Qfalse);
|
|
|
|
/* first check if pointer already created */
|
|
pointer = rb_gv_get("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME);
|
|
if (pointer != Qnil) {
|
|
Data_Get_Struct(pointer, swig_module_info, ret);
|
|
}
|
|
|
|
/* reinstate warnings */
|
|
rb_gv_set("VERBOSE", verbose);
|
|
return ret;
|
|
}
|
|
|
|
SWIGRUNTIME void
|
|
SWIG_Ruby_SetModule(swig_module_info *pointer)
|
|
{
|
|
/* register a new class */
|
|
VALUE cl = rb_define_class("swig_runtime_data", rb_cObject);
|
|
/* create and store the structure pointer to a global variable */
|
|
swig_runtime_data_type_pointer = Data_Wrap_Struct(cl, 0, 0, pointer);
|
|
rb_define_readonly_variable("$swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, &swig_runtime_data_type_pointer);
|
|
}
|
|
|
|
/* This function can be used to check whether a proc or method or similarly
|
|
callable function has been passed. Usually used in a %typecheck, like:
|
|
|
|
%typecheck(c_callback_t, precedence=SWIG_TYPECHECK_POINTER) {
|
|
$result = SWIG_Ruby_isCallable( $input );
|
|
}
|
|
*/
|
|
SWIGINTERN
|
|
int SWIG_Ruby_isCallable( VALUE proc )
|
|
{
|
|
if ( rb_respond_to( proc, swig_call_id ) == Qtrue )
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
/* This function can be used to check the arity (number of arguments)
|
|
a proc or method can take. Usually used in a %typecheck.
|
|
Valid arities will be that equal to minimal or those < 0
|
|
which indicate a variable number of parameters at the end.
|
|
*/
|
|
SWIGINTERN
|
|
int SWIG_Ruby_arity( VALUE proc, int minimal )
|
|
{
|
|
if ( rb_respond_to( proc, swig_arity_id ) == Qtrue )
|
|
{
|
|
VALUE num = rb_funcall( proc, swig_arity_id, 0 );
|
|
int arity = NUM2INT(num);
|
|
if ( arity < 0 && (arity+1) < -minimal ) return 1;
|
|
if ( arity == minimal ) return 1;
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|