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

Changed _swig_type_info to swig_type_info

Browse source 
git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk@799 626c5289-ae23-0410-ae9c-e8d60b6d4f22
This commit is contained in:
Dave Beazley 2000-09-02 16:25:50 +00:00
commit 3ef3086b5a
20 changed files with 201 additions and 209 deletions
Download patch file Download diff file Expand all files Collapse all files

55
SWIG/Lib/common.swg
View file

@ -34,38 +34,38 @@
#endif
#ifdef SWIG_GLOBAL
#define SWIGSTATICRUNTIME(a) SWIGEXPORT(a)
#define SWIGRUNTIME(a) SWIGEXPORT(a)
#else
#define SWIGSTATICRUNTIME(a) static a
#define SWIGRUNTIME(a) static a
#endif
#ifdef __cplusplus
extern "C" {
#endif
typedef struct _swig_type_info {
typedef struct swig_type_info {
char *name;
void *(*converter)(void *);
char *str;
struct _swig_type_info *next;
struct _swig_type_info *prev;
} _swig_type_info;
struct swig_type_info *next;
struct swig_type_info *prev;
} swig_type_info;
#ifdef SWIG_NOINCLUDE
SWIGEXPORT(_swig_type_info *) SWIG_TypeRegister(_swig_type_info *);
SWIGEXPORT(_swig_type_info *) SWIG_TypeCheck(char *c, _swig_type_info *);
SWIGEXPORT(void *) SWIG_TypeCast(_swig_type_info *, void *);
SWIGEXPORT(swig_type_info *) SWIG_TypeRegister(swig_type_info *);
SWIGEXPORT(swig_type_info *) SWIG_TypeCheck(char *c, swig_type_info *);
SWIGEXPORT(void *) SWIG_TypeCast(swig_type_info *, void *);
#else
static _swig_type_info *swig_types = 0;
static swig_type_info *swig_type_list = 0;
/* Register a type mapping with the type-checking */
SWIGSTATICRUNTIME(_swig_type_info *)
SWIG_TypeRegister(_swig_type_info *ti)
SWIGRUNTIME(swig_type_info *)
SWIG_TypeRegister(swig_type_info *ti)
{
_swig_type_info *tc, *head, *ret, *next;
swig_type_info *tc, *head, *ret, *next;
/* Check to see if this type has already been registered */
tc = swig_types;
tc = swig_type_list;
while (tc) {
if (strcmp(tc->name, ti->name) == 0) {
/* Already exists in the table. Just add additional types to the list */
@ -79,8 +79,8 @@ SWIG_TypeRegister(_swig_type_info *ti)
next = 0;
/* Place in list */
ti->prev = swig_types;
swig_types = ti;
ti->prev = swig_type_list;
swig_type_list = ti;
/* Build linked lists */
l1:
@ -98,10 +98,10 @@ SWIG_TypeRegister(_swig_type_info *ti)
}
/* Check the typename */
SWIGSTATICRUNTIME(_swig_type_info *)
SWIG_TypeCheck(char *c, _swig_type_info *ty)
SWIGRUNTIME(swig_type_info *)
SWIG_TypeCheck(char *c, swig_type_info *ty)
{
_swig_type_info *s;
swig_type_info *s;
if (!ty) return 0; /* Void pointer */
s = ty->next; /* First element always just a name */
while (s) {
@ -124,12 +124,25 @@ SWIG_TypeCheck(char *c, _swig_type_info *ty)
}
/* Cast a pointer (needed for C++ inheritance */
SWIGSTATICRUNTIME(void *)
SWIG_TypeCast(_swig_type_info *ty, void *ptr)
SWIGRUNTIME(void *)
SWIG_TypeCast(swig_type_info *ty, void *ptr)
{
if ((!ty) || (!ty->converter)) return ptr;
return (*ty->converter)(ptr);
}
/* Search for a swig_type_info structure */
SWIGRUNTIME(void *)
SWIG_TypeQuery(const char *name) {
swig_type_info *ty = swig_type_list;
while (ty) {
if (ty->str && (strcmp(name,ty->str) == 0)) return ty;
if (ty->name && (strcmp(name,ty->name) == 0)) return ty;
ty = ty->prev;
}
return 0;
}
#endif
#ifdef __cplusplus

8
SWIG/Lib/guile/guile.swg
View file

@ -180,7 +180,7 @@ SWIG_Cast (void *source, size_t source_type,
static unsigned long swig_tag = 0;
SWIGSTATIC SCM
SWIG_Guile_MakePtr (void *ptr, _swig_type_info *type)
SWIG_Guile_MakePtr (void *ptr, swig_type_info *type)
{
if (ptr==NULL) return SCM_EOL;
SCM_RETURN_NEWSMOB((((unsigned long)type->tag << 16) | swig_tag),
@ -189,7 +189,7 @@ SWIG_Guile_MakePtr (void *ptr, _swig_type_info *type)
/* Return 0 if successful. */
SWIGSTATIC int
SWIG_Guile_GetPtr(SCM s, void **result, _swig_type_info *type)
SWIG_Guile_GetPtr(SCM s, void **result, swig_type_info *type)
{
if (SCM_NULLP(s)) {
*result = NULL;
@ -246,10 +246,10 @@ SWIG_Guile_Init (void)
/* Convert datatype table */
SWIGSTATIC
void SWIG_Guile_RegisterTypes(_swig_type_info **table)
void SWIG_Guile_RegisterTypes(swig_type_info **table)
{
for (; *table; table++) {
_swig_type_info *type = *table;
swig_type_info *type = *table;
char *origname = type->name;
/* Register datatype itself and store pointer back */
type->tag = SWIG_RegisterType(origname, type->str);

12
SWIG/Lib/guile/guiledec.swg
View file

@ -54,17 +54,17 @@ GSWIG_scm2char (SCM s)
typedef struct SwigPtrType SwigPtrType;
typedef struct _swig_type_info {
typedef struct swig_type_info {
char *name;
void *(*converter)(void *);
char *str;
size_t tag;
} _swig_type_info;
} swig_type_info;
#define _swig_types_initial _swig_types
#define swig_types_initial swig_types
SWIGSTATIC void
SWIG_Guile_RegisterTypes (_swig_type_info **table);
SWIG_Guile_RegisterTypes (swig_type_info **table);
/* Register a new type-mapping with the type-checker. origtype is the
original datatype and newtype is an equivalent type. cast is optional
@ -87,11 +87,11 @@ SWIG_Guile_Init();
/* Get a pointer value from a smob. If there is a type-mismatch,
return nonzero; on success, return 0. */
SWIGSTATIC int
SWIG_Guile_GetPtr (SCM s, void **result, _swig_type_info *type);
SWIG_Guile_GetPtr (SCM s, void **result, swig_type_info *type);
/* Make a smob from a pointer and typeinfo. */
SWIGSTATIC SCM
SWIG_Guile_MakePtr (void *ptr, _swig_type_info *type);
SWIG_Guile_MakePtr (void *ptr, swig_type_info *type);
/* Get arguments from an argument list */
SWIGSTATIC void

2
SWIG/Lib/perl5/headers.swg
View file

@ -1,2 +0,0 @@
/* $Header$ */
/* Implementation : PERL 5 */

26
SWIG/Lib/perl5/perl5.swg
View file

@ -64,11 +64,11 @@ extern "C" {
#ifdef SWIG_NOINCLUDE
#ifndef PERL_OBJECT
extern int SWIG_ConvertPtr(SV *, void **, _swig_type_info *);
extern void SWIG_MakePtr(SV *, void *, _swig_type_info *);
extern int SWIG_ConvertPtr(SV *, void **, swig_type_info *);
extern void SWIG_MakePtr(SV *, void *, swig_type_info *);
#else
extern int _SWIG_ConvertPtr(CPerlObj *, SV *, void **, _swig_type_info *);
extern void _SWIG_MakePtr(CPerlObj *, SV *, void *, _swig_type_info *);
extern int _SWIG_ConvertPtr(CPerlObj *, SV *, void **, swig_type_info *);
extern void _SWIG_MakePtr(CPerlObj *, SV *, void *, swig_type_info *);
#define SWIG_ConvertPtr(a,b,c) _SWIG_ConvertPtr(pPerl,a,b,c)
#define SWIG_MakePtr(a,b,c) _SWIG_MakePtr(pPerl,a,b,c)
#endif
@ -78,16 +78,16 @@ extern void _SWIG_MakePtr(CPerlObj *, SV *, void *, _swig_type_info *);
/* Function for getting a pointer value */
#ifndef PERL_OBJECT
SWIGSTATICRUNTIME(int)
SWIG_ConvertPtr(SV *sv, void **ptr, _swig_type_info *_t)
SWIGRUNTIME(int)
SWIG_ConvertPtr(SV *sv, void **ptr, swig_type_info *_t)
#else
#define SWIG_ConvertPtr(a,b,c) _SWIG_GetConvert(pPerl,a,b,c)
SWIGSTATICRUNTIME(int)
_SWIG_ConvertPtr(CPerlObj *pPerl, SV *sv, void **ptr, _swig_type_info *_t)
SWIGRUNTIME(int)
_SWIG_ConvertPtr(CPerlObj *pPerl, SV *sv, void **ptr, swig_type_info *_t)
#endif
{
char *_c;
_swig_type_info *tc;
swig_type_info *tc;
IV tmp;
/* If magical, apply more magic */
@ -145,12 +145,12 @@ _SWIG_ConvertPtr(CPerlObj *pPerl, SV *sv, void **ptr, _swig_type_info *_t)
return 0;
}
#ifndef PERL_OBJECT
SWIGSTATICRUNTIME(void)
SWIG_MakePtr(SV *sv, void *ptr, _swig_type_info *t)
SWIGRUNTIME(void)
SWIG_MakePtr(SV *sv, void *ptr, swig_type_info *t)
#else
#define SWIG_MakePtr(a,b,c) _SWIG_MakePtr(pPerl,a,b,c)
SWIGSTATICRUNTIME(int *)
_SWIG_MakePtr(CPerlObj *pPerl, SV *sv, void *ptr, _swig_type_info *t)
SWIGRUNTIME(int *)
_SWIG_MakePtr(CPerlObj *pPerl, SV *sv, void *ptr, swig_type_info *t)
#endif
{
sv_setref_pv(sv, t->name, ptr);

19
SWIG/Lib/perl5/perl5mg.swg
View file

@ -1,19 +0,0 @@
/* Magic variable code */
#ifndef PERL_OBJECT
#define swig_create_magic(s,a,b,c) _swig_create_magic(s,a,b,c)
static void _swig_create_magic(SV *sv, char *name, int (*set)(SV *, MAGIC *), int (*get)(SV *,MAGIC *)) {
#else
#define swig_create_magic(s,a,b,c) _swig_create_magic(pPerl,s,a,b,c)
static void _swig_create_magic(CPerlObj *pPerl, SV *sv, char *name, int (CPerlObj::*set)(SV *, MAGIC *), int (CPerlObj::*get)(SV *, MAGIC *)) {
#endif
MAGIC *mg;
sv_magic(sv,sv,'U',name,strlen(name));
mg = mg_find(sv,'U');
mg->mg_virtual = (MGVTBL *) malloc(sizeof(MGVTBL));
mg->mg_virtual->svt_get = get;
mg->mg_virtual->svt_set = set;
mg->mg_virtual->svt_len = 0;
mg->mg_virtual->svt_clear = 0;
mg->mg_virtual->svt_free = 0;
}

22
SWIG/Lib/python/ptrlang.i
View file

@ -12,15 +12,15 @@
/* Pointer library specific types */
static _swig_type_info _swig_pointer_int_p[] = {{"_int_p",0},{"_int_p",0},{0}};
static _swig_type_info _swig_pointer_short_p[] = {{"_short_p",0},{"_short_p",0},{0}};
static _swig_type_info _swig_pointer_long_p[] = {{"_long_p",0},{"_long_p",0},{0}};
static _swig_type_info _swig_pointer_float_p[] = {{"_float_p",0},{"_float_p",0},{0}};
static _swig_type_info _swig_pointer_double_p[] = {{"_double_p",0},{"_double_p",0},{0}};
static _swig_type_info _swig_pointer_char_p[] = {{"_char_p",0},{"_char_p",0},{0}};
static _swig_type_info _swig_pointer_char_pp[] = {{"_char_pp",0},{"_char_pp",0},{0}};
static swig_type_info _swig_pointer_int_p[] = {{"_int_p",0},{"_int_p",0},{0}};
static swig_type_info _swig_pointer_short_p[] = {{"_short_p",0},{"_short_p",0},{0}};
static swig_type_info _swig_pointer_long_p[] = {{"_long_p",0},{"_long_p",0},{0}};
static swig_type_info _swig_pointer_float_p[] = {{"_float_p",0},{"_float_p",0},{0}};
static swig_type_info _swig_pointer_double_p[] = {{"_double_p",0},{"_double_p",0},{0}};
static swig_type_info _swig_pointer_char_p[] = {{"_char_p",0},{"_char_p",0},{0}};
static swig_type_info _swig_pointer_char_pp[] = {{"_char_pp",0},{"_char_pp",0},{0}};
static _swig_type_info *_swig_pointer_types[] = {
static swig_type_info *_swig_pointer_types[] = {
_swig_pointer_int_p,
_swig_pointer_short_p,
_swig_pointer_long_p,
@ -57,7 +57,7 @@ static PyObject *ptrcast(PyObject *_PTRVALUE, char *type) {
void *ptr;
PyObject *obj;
char *typestr,*c;
_swig_type_info temptype;
swig_type_info temptype;
/* Produce a "mangled" version of the type string. */
@ -180,7 +180,7 @@ static PyObject *ptrcreate(char *type, PyObject *_PYVALUE, int numelements) {
void *ptr;
PyObject *obj;
int sz;
_swig_type_info *cast;
swig_type_info *cast;
char temp[40];
/* Check the type string against a variety of possibilities */
@ -370,7 +370,7 @@ static PyObject *ptradd(PyObject *_PTRVALUE, int offset) {
char *r;
void *ptr,*junk;
PyObject *obj;
_swig_type_info *type;
swig_type_info *type;
/* Check to see what kind of object _PTRVALUE is */

36
SWIG/Lib/python/python.swg
View file

@ -21,23 +21,23 @@ extern "C" {
#define SWIG_PY_POINTER 4
/* Constant information structure */
typedef struct _swig_const_info {
typedef struct swig_const_info {
int type;
char *name;
long lvalue;
double dvalue;
void *pvalue;
_swig_type_info **ptype;
} _swig_const_info;
swig_type_info **ptype;
} swig_const_info;
#ifdef SWIG_NOINCLUDE
SWIGEXPORT(PyObject *) SWIG_newvarlink();
SWIGEXPORT(void) SWIG_addvarlink(PyObject *, char *, PyObject *(*)(void), int (*)(PyObject *));
SWIGEXPORT(int) SWIG_ConvertPtr(PyObject *, void **, _swig_type_info *, int);
SWIGEXPORT(void) SWIG_MakePtr(char *c, void *, _swig_type_info *);
SWIGEXPORT(PyObject *) SWIG_NewPointerObj(void *, _swig_type_info *);
SWIGEXPORT(void) SWIG_InstallConstants(PyObject *d, _swig_const_info constants[]);
SWIGEXPORT(int) SWIG_ConvertPtr(PyObject *, void **, swig_type_info *, int);
SWIGEXPORT(void) SWIG_MakePtr(char *c, void *, swig_type_info *);
SWIGEXPORT(PyObject *) SWIG_NewPointerObj(void *, swig_type_info *);
SWIGEXPORT(void) SWIG_InstallConstants(PyObject *d, swig_const_info constants[]);
#else
@ -120,7 +120,7 @@ statichere PyTypeObject varlinktype = {
};
/* Create a variable linking object for use later */
SWIGSTATICRUNTIME(PyObject *)
SWIGRUNTIME(PyObject *)
SWIG_newvarlink(void) {
swig_varlinkobject *result = 0;
result = PyMem_NEW(swig_varlinkobject,1);
@ -132,7 +132,7 @@ SWIG_newvarlink(void) {
return ((PyObject*) result);
}
SWIGSTATICRUNTIME(void)
SWIGRUNTIME(void)
SWIG_addvarlink(PyObject *p, char *name,
PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
swig_varlinkobject *v;
@ -147,11 +147,11 @@ SWIG_addvarlink(PyObject *p, char *name,
v->vars = gv;
}
/* Convert a pointer value */
SWIGSTATICRUNTIME(int)
SWIG_ConvertPtr(PyObject *obj, void **ptr, _swig_type_info *ty, int flags) {
SWIGRUNTIME(int)
SWIG_ConvertPtr(PyObject *obj, void **ptr, swig_type_info *ty, int flags) {
unsigned long p;
register int d;
_swig_type_info *tc;
swig_type_info *tc;
char *c;
static PyObject *SWIG_this = 0;
int newref = 0;
@ -243,8 +243,8 @@ type_error:
}
/* Take a pointer and convert it to a string */
SWIGSTATICRUNTIME(void)
SWIG_MakePtr(char *c, void *ptr, _swig_type_info *ty) {
SWIGRUNTIME(void)
SWIG_MakePtr(char *c, void *ptr, swig_type_info *ty) {
static char hex[17] = "0123456789abcdef";
unsigned long p, s;
char result[32], *r;
@ -266,8 +266,8 @@ SWIG_MakePtr(char *c, void *ptr, _swig_type_info *ty) {
}
/* Create a new pointer object */
SWIGSTATICRUNTIME(PyObject *)
SWIG_NewPointerObj(void *ptr, _swig_type_info *type) {
SWIGRUNTIME(PyObject *)
SWIG_NewPointerObj(void *ptr, swig_type_info *type) {
char result[512];
PyObject *robj;
if (!ptr) {
@ -284,8 +284,8 @@ SWIG_NewPointerObj(void *ptr, _swig_type_info *type) {
}
/* Install Constants */
SWIGSTATICRUNTIME(void)
SWIG_InstallConstants(PyObject *d, _swig_const_info constants[]) {
SWIGRUNTIME(void)
SWIG_InstallConstants(PyObject *d, swig_const_info constants[]) {
int i;
PyObject *obj;
for (i = 0; constants[i].type; i++) {

22
SWIG/Lib/ruby/ptrlang.i
View file

@ -25,15 +25,15 @@
/* Pointer library specific types */
static _swig_type_info _swig_pointer_int_p[] = {{"_p_int",0},{"_p_int",0},{0}};
static _swig_type_info _swig_pointer_short_p[] = {{"_p_short",0},{"_p_short",0},{0}};
static _swig_type_info _swig_pointer_long_p[] = {{"_p_long",0},{"_p_long",0},{0}};
static _swig_type_info _swig_pointer_float_p[] = {{"_p_float",0},{"_p_float",0},{0}};
static _swig_type_info _swig_pointer_double_p[] = {{"_p_double",0},{"_p_double",0},{0}};
static _swig_type_info _swig_pointer_char_p[] = {{"_p_char",0},{"_p_char",0},{0}};
static _swig_type_info _swig_pointer_char_pp[] = {{"_pp_char",0},{"_pp_char",0},{0}};
static swig_type_info _swig_pointer_int_p[] = {{"_p_int",0},{"_p_int",0},{0}};
static swig_type_info _swig_pointer_short_p[] = {{"_p_short",0},{"_p_short",0},{0}};
static swig_type_info _swig_pointer_long_p[] = {{"_p_long",0},{"_p_long",0},{0}};
static swig_type_info _swig_pointer_float_p[] = {{"_p_float",0},{"_p_float",0},{0}};
static swig_type_info _swig_pointer_double_p[] = {{"_p_double",0},{"_p_double",0},{0}};
static swig_type_info _swig_pointer_char_p[] = {{"_p_char",0},{"_p_char",0},{0}};
static swig_type_info _swig_pointer_char_pp[] = {{"_pp_char",0},{"_pp_char",0},{0}};
static _swig_type_info *_swig_pointer_types[] = {
static swig_type_info *_swig_pointer_types[] = {
_swig_pointer_int_p,
_swig_pointer_short_p,
_swig_pointer_long_p,
@ -70,7 +70,7 @@ static VALUE ptrcast(VALUE _PTRVALUE, char *type) {
void *ptr;
VALUE obj;
char *typestr,*c;
_swig_type_info temptype;
swig_type_info temptype;
/* Produce a "mangled" version of the type string. */
@ -188,7 +188,7 @@ static VALUE ptrcreate(char *type, VALUE _RBVALUE, int numelements) {
void *ptr;
VALUE obj;
int sz;
_swig_type_info *cast;
swig_type_info *cast;
char temp[40];
/* Check the type string against a variety of possibilities */
@ -370,7 +370,7 @@ static VALUE ptradd(VALUE _PTRVALUE, int offset) {
char *r;
void *ptr,*junk;
VALUE obj;
_swig_type_info *type;
swig_type_info *type;
ptr = SWIG_ConvertPtr(_PTRVALUE,0);

8
SWIG/Lib/ruby/rubydec.swg
View file

@ -3,11 +3,11 @@
extern "C" {
#endif
SWIGEXPORT(void) SWIG_define_class(VALUE, _swig_type_info *)
SWIGEXPORT(VALUE) SWIG_NewPointerObj(void *, _swig_type_info *);
SWIGEXPORT(void) SWIG_define_class(VALUE, swig_type_info *)
SWIGEXPORT(VALUE) SWIG_NewPointerObj(void *, swig_type_info *);
SWIGEXPORT(char *) SWIG_MangleStr(VALUE);
SWIGEXPORT(void *) SWIG_ConvertPtr(VALUE, _swig_type_info *);
SWIGEXPORT(int) SWIG_CheckConvert(VALUE, _swig_type_info *);
SWIGEXPORT(void *) SWIG_ConvertPtr(VALUE, swig_type_info *);
SWIGEXPORT(int) SWIG_CheckConvert(VALUE, swig_type_info *);
#ifdef __cplusplus
}

20
SWIG/Lib/ruby/rubydef.swg
View file

@ -8,8 +8,8 @@ static VALUE _mSWIG = Qnil;
static VALUE _cSWIG_Pointer = Qnil;
/* Define ruby class for C type */
SWIGSTATICRUNTIME(void)
SWIG_define_class(_swig_type_info *type)
SWIGRUNTIME(void)
SWIG_define_class(swig_type_info *type)
{
char *klass_name = ALLOCA_N(char, 4 + strlen(type->name) + 1);
sprintf(klass_name, "TYPE%s", type->name);
@ -20,8 +20,8 @@ SWIG_define_class(_swig_type_info *type)
}
/* Create a new pointer object */
SWIGSTATICRUNTIME(VALUE)
SWIG_NewPointerObj(void *ptr, _swig_type_info *type)
SWIGRUNTIME(VALUE)
SWIG_NewPointerObj(void *ptr, swig_type_info *type)
{
char *klass_name;
VALUE klass;
@ -36,7 +36,7 @@ SWIG_NewPointerObj(void *ptr, _swig_type_info *type)
}
/* Get type mangle from class name */
SWIGSTATICRUNTIME(char *)
SWIGRUNTIME(char *)
SWIG_MangleStr(VALUE obj)
{
char *c;
@ -53,12 +53,12 @@ SWIG_MangleStr(VALUE obj)
}
/* Convert a pointer value */
SWIGSTATICRUNTIME(void *)
SWIG_ConvertPtr(VALUE obj, _swig_type_info *ty)
SWIGRUNTIME(void *)
SWIG_ConvertPtr(VALUE obj, swig_type_info *ty)
{
char *c;
void *ptr;
_swig_type_info *tc;
swig_type_info *tc;
if ((c = SWIG_MangleStr(obj)) == NULL)
rb_raise(rb_eTypeError, "Expected %s", ty->name);
@ -72,8 +72,8 @@ SWIG_ConvertPtr(VALUE obj, _swig_type_info *ty)
}
/* Check convert */
SWIGSTATICRUNTIME(int)
SWIG_CheckConvert(VALUE obj, _swig_type_info *ty)
SWIGRUNTIME(int)
SWIG_CheckConvert(VALUE obj, swig_type_info *ty)
{
char *c = SWIG_MangleStr(obj);
if (!c)

50
SWIG/Lib/tcl/object.swg
View file

@ -3,37 +3,37 @@
* Tcl8.x - Object oriented runtime functions
*/
typedef int (*_swig_wrapper)(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST []);
typedef int (*swig_wrapper)(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST []);
typedef struct _swig_method {
typedef struct swig_method {
const char *name;
_swig_wrapper method;
} _swig_method;
swig_wrapper method;
} swig_method;
typedef struct _swig_attribute {
typedef struct swig_attribute {
const char *name;
_swig_wrapper getmethod;
_swig_wrapper setmethod;
} _swig_attribute;
swig_wrapper getmethod;
swig_wrapper setmethod;
} swig_attribute;
typedef struct _swig_class {
typedef struct swig_class {
const char *name;
_swig_type_info **type;
_swig_wrapper constructor;
swig_type_info **type;
swig_wrapper constructor;
void (*destructor)(void *);
_swig_method *methods;
_swig_attribute *attributes;
} _swig_class;
swig_method *methods;
swig_attribute *attributes;
} swig_class;
typedef struct _swig_instance {
typedef struct swig_instance {
Tcl_Obj *thisptr;
void *thisvalue;
_swig_class *classptr;
swig_class *classptr;
int destroy;
} _swig_instance;
} swig_instance;
static void SwigObjectDelete(ClientData clientData) {
_swig_instance *si = (_swig_instance *) clientData;
swig_instance *si = (swig_instance *) clientData;
if (si->destroy) {
if (si->classptr->destructor) {
(si->classptr->destructor)(si->thisvalue);
@ -48,9 +48,9 @@ static int
SwigMethodCmd(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST _objv[])
{
char *method, *attrname;
_swig_instance *inst = (_swig_instance *) clientData;
_swig_method *meth;
_swig_attribute *attr;
swig_instance *inst = (swig_instance *) clientData;
swig_method *meth;
swig_attribute *attr;
Tcl_Obj *oldarg;
Tcl_Obj **objv;
int rcode;
@ -151,9 +151,9 @@ SwigObjectCmd(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONS
{
Tcl_Obj *newObj = 0;
void *thisvalue = 0;
_swig_instance *newinst = 0;
_swig_class *classptr = (_swig_class *) clientData;
_swig_wrapper cons = 0;
swig_instance *newinst = 0;
swig_class *classptr = (swig_class *) clientData;
swig_wrapper cons = 0;
char *name = 0;
int firstarg = 0;
int thisarg = 0;
@ -213,7 +213,7 @@ SwigObjectCmd(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONS
Tcl_DecrRefCount(newObj);
return TCL_ERROR;
}
newinst = (_swig_instance *) malloc(sizeof(_swig_instance));
newinst = (swig_instance *) malloc(sizeof(swig_instance));
newinst->thisptr = newObj;
Tcl_IncrRefCount(newObj);
newinst->thisvalue = thisvalue;

24
SWIG/Lib/tcl/ptrlang.i
View file

@ -13,15 +13,15 @@
/* Pointer library specific types */
static _swig_type_info _swig_pointer_int_p[] = {{"_int_p",0},{"_int_p",0},{0}};
static _swig_type_info _swig_pointer_short_p[] = {{"_short_p",0},{"_short_p",0},{0}};
static _swig_type_info _swig_pointer_long_p[] = {{"_long_p",0},{"_long_p",0},{0}};
static _swig_type_info _swig_pointer_float_p[] = {{"_float_p",0},{"_float_p",0},{0}};
static _swig_type_info _swig_pointer_double_p[] = {{"_double_p",0},{"_double_p",0},{0}};
static _swig_type_info _swig_pointer_char_p[] = {{"_char_p",0},{"_char_p",0},{0}};
static _swig_type_info _swig_pointer_char_pp[] = {{"_char_pp",0},{"_char_pp",0},{0}};
static swig_type_info _swig_pointer_int_p[] = {{"_int_p",0},{"_int_p",0},{0}};
static swig_type_info _swig_pointer_short_p[] = {{"_short_p",0},{"_short_p",0},{0}};
static swig_type_info _swig_pointer_long_p[] = {{"_long_p",0},{"_long_p",0},{0}};
static swig_type_info _swig_pointer_float_p[] = {{"_float_p",0},{"_float_p",0},{0}};
static swig_type_info _swig_pointer_double_p[] = {{"_double_p",0},{"_double_p",0},{0}};
static swig_type_info _swig_pointer_char_p[] = {{"_char_p",0},{"_char_p",0},{0}};
static swig_type_info _swig_pointer_char_pp[] = {{"_char_pp",0},{"_char_pp",0},{0}};
static _swig_type_info *_swig_pointer_types[] = {
static swig_type_info *_swig_pointer_types[] = {
_swig_pointer_int_p,
_swig_pointer_short_p,
_swig_pointer_long_p,
@ -59,7 +59,7 @@ static int ptrcast(Tcl_Interp *interp, char *ptrvalue, char *type) {
char *typestr,*c;
int pv;
int error = 0;
_swig_type_info sinfo;
swig_type_info sinfo;
/* Produce a "mangled" version of the type string. */
@ -188,7 +188,7 @@ static int ptrvalue(Tcl_Interp *interp, char *ptrvalue, int index, char *type) {
static int ptrcreate(Tcl_Interp *interp, char *type, char *ptrvalue, int numelements) {
void *ptr;
int sz;
_swig_type_info *cast = 0;
swig_type_info *cast = 0;
char temp[40];
/* Check the type string against a variety of possibilities */
@ -393,8 +393,8 @@ static int ptradd(Tcl_Interp *interp, char *ptrvalue, int offset) {
char *r,*s;
void *ptr,*junk;
_swig_type_info *type = 0;
_swig_type_info stype;
swig_type_info *type = 0;
swig_type_info stype;
/* Check to see what kind of object ptrvalue is */

38
SWIG/Lib/tcl/swigtcl8.swg
View file

@ -13,21 +13,21 @@ extern "C" {
#endif
#ifdef SWIG_NOINCLUDE
SWIGEXPORT(int) SWIG_ConvertPtrFromString(Tcl_Interp *, char *, void **, _swig_type_info *);
SWIGEXPORT(int) SWIG_ConvertPtr(Tcl_Interp *, Tcl_Obj *, void **, _swig_type_info *);
SWIGEXPORT(void) SWIG_MakePtr(char *, void *, _swig_type_info *);
SWIGEXPORT(Tcl_Obj *) SWIG_NewPointerObj(void *, _swig_type_info *);
SWIGEXPORT(int) SWIG_ConvertPtrFromString(Tcl_Interp *, char *, void **, swig_type_info *);
SWIGEXPORT(int) SWIG_ConvertPtr(Tcl_Interp *, Tcl_Obj *, void **, swig_type_info *);
SWIGEXPORT(void) SWIG_MakePtr(char *, void *, swig_type_info *);
SWIGEXPORT(Tcl_Obj *) SWIG_NewPointerObj(void *, swig_type_info *);
SWIGEXPORT(int) SWIG_GetArgs(Tcl_Interp *, int, Tcl_Obj *CONST [], const char *, ...);
SWIGEXPORT(char *) SWIG_PointerTypeFromString(char *c);
#else
/* Convert a pointer value */
SWIGSTATICRUNTIME(int)
SWIG_ConvertPtrFromString(Tcl_Interp *interp, char *c, void **ptr, _swig_type_info *ty)
SWIGRUNTIME(int)
SWIG_ConvertPtrFromString(Tcl_Interp *interp, char *c, void **ptr, swig_type_info *ty)
{
unsigned long p;
register int d;
_swig_type_info *tc;
swig_type_info *tc;
p = 0;
/* Pointer values must start with leading underscore */
if (*c != '_') {
@ -62,15 +62,15 @@ SWIG_ConvertPtrFromString(Tcl_Interp *interp, char *c, void **ptr, _swig_type_in
/* Convert a pointer value */
SWIGSTATICRUNTIME(int)
SWIG_ConvertPtr(Tcl_Interp *interp, Tcl_Obj *oc, void **ptr, _swig_type_info *ty)
SWIGRUNTIME(int)
SWIG_ConvertPtr(Tcl_Interp *interp, Tcl_Obj *oc, void **ptr, swig_type_info *ty)
{
return SWIG_ConvertPtrFromString(interp, Tcl_GetStringFromObj(oc,NULL), ptr, ty);
}
/* Convert a pointer value */
SWIGSTATICRUNTIME(char *)
SWIGRUNTIME(char *)
SWIG_PointerTypeFromString(char *c) {
char d;
/* Pointer values must start with leading underscore */
@ -87,8 +87,8 @@ SWIG_PointerTypeFromString(char *c) {
}
/* Take a pointer and convert it to a string */
SWIGSTATICRUNTIME(void)
SWIG_MakePtr(char *c, void *ptr, _swig_type_info *ty) {
SWIGRUNTIME(void)
SWIG_MakePtr(char *c, void *ptr, swig_type_info *ty) {
static char hex[17] = "0123456789abcdef";
unsigned long p, s;
char result[24], *r;
@ -110,8 +110,8 @@ SWIG_MakePtr(char *c, void *ptr, _swig_type_info *ty) {
}
/* Create a new pointer object */
SWIGSTATICRUNTIME(Tcl_Obj *)
SWIG_NewPointerObj(void *ptr, _swig_type_info *type) {
SWIGRUNTIME(Tcl_Obj *)
SWIG_NewPointerObj(void *ptr, swig_type_info *type) {
char result[256];
Tcl_Obj *robj;
SWIG_MakePtr(result,ptr,type);
@ -120,7 +120,7 @@ SWIG_NewPointerObj(void *ptr, _swig_type_info *type) {
}
/* Get arguments */
SWIGSTATICRUNTIME(int)
SWIGRUNTIME(int)
SWIG_GetArgs(Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[], const char *fmt, ...)
{
int argno = 0, opt = 0, tempi;
@ -129,7 +129,7 @@ SWIG_GetArgs(Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[], const char *fm
const char *c;
va_list ap;
void *vptr;
_swig_type_info *ty;
swig_type_info *ty;
va_start(ap,fmt);
for (c = fmt; (*c && (*c != ':')); c++,argno++) {
@ -183,7 +183,7 @@ SWIG_GetArgs(Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[], const char *fm
*((char *)vptr) = *(Tcl_GetStringFromObj(objv[argno+1],NULL));
break;
case 'p':
ty = (_swig_type_info *) va_arg(ap, void *);
ty = (swig_type_info *) va_arg(ap, void *);
if (SWIG_ConvertPtr(interp, objv[argno+1], (void **) vptr, ty) == TCL_ERROR) goto argerror;
break;
case 'o':
@ -218,7 +218,7 @@ typedef struct {
const char *name;
int (*wrapper)(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST []);
ClientData clientdata;
} _swig_command_info;
} swig_command_info;
/* Structure for variable linking table */
typedef struct {
@ -226,7 +226,7 @@ typedef struct {
void *addr;
char * (*get)(ClientData, Tcl_Interp *, char *, char *, int);
char * (*set)(ClientData, Tcl_Interp *, char *, char *, int);
} _swig_var_info;
} swig_var_info;
#ifdef __cplusplus

2
SWIG/Source/Modules1.1/guile.cxx
View file

@ -328,7 +328,7 @@ GUILE::close (void)
{
SwigType_emit_type_table (f_runtime, f_wrappers);
Printf (f_init, "SWIG_Guile_RegisterTypes(_swig_types);\n");
Printf (f_init, "SWIG_Guile_RegisterTypes(swig_types);\n");
Printf (f_init, "}\n\n");
char module_name[256];

4
SWIG/Source/Modules1.1/perl5.cxx
View file

@ -285,8 +285,8 @@ PERL5::initialize()
Printf(f_init,"\t char *file = __FILE__;\n");
Printf(f_init,"\t cv = cv; items = items;\n");
Printv(f_init,
"for (i = 0; _swig_types_initial[i]; i++) {\n",
"_swig_types[i] = SWIG_TypeRegister(_swig_types_initial[i]);\n",
"for (i = 0; swig_types_initial[i]; i++) {\n",
"swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);\n",
"}\n", 0);
Printf(f_init,"\t newXS(\"%s::var_%s_init\", _wrap_perl5_%s_var_init, file);\n",package,cmodule, cmodule);

8
SWIG/Source/Modules1.1/python.cxx
View file

@ -239,15 +239,15 @@ PYTHON::initialize(void) {
Printf(f_init,"m = Py_InitModule(\"%s\", %sMethods);\n", module, module);
Printf(f_init,"d = PyModule_GetDict(m);\n");
Printv(f_init,
"for (i = 0; _swig_types_initial[i]; i++) {\n",
"_swig_types[i] = SWIG_TypeRegister(_swig_types_initial[i]);\n",
"for (i = 0; swig_types_initial[i]; i++) {\n",
"swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);\n",
"}\n",
0);
Printf(f_wrappers,"#ifdef __cplusplus\n");
Printf(f_wrappers,"extern \"C\" {\n");
Printf(f_wrappers,"#endif\n");
Printf(const_code,"static _swig_const_info _swig_const_table[] = {\n");
Printf(const_code,"static swig_const_info swig_const_table[] = {\n");
Printf(methods,"static PyMethodDef %sMethods[] = {\n", module);
}
@ -268,7 +268,7 @@ PYTHON::close(void) {
Printf(const_code, "{0}};\n");
Printf(f_wrappers,"%s\n",const_code);
Printv(f_init, "SWIG_InstallConstants(d,_swig_const_table);\n", 0);
Printv(f_init, "SWIG_InstallConstants(d,swig_const_table);\n", 0);
Printf(f_init,"}\n");
if (shadow) {

6
SWIG/Source/Modules1.1/ruby.cxx
View file

@ -335,9 +335,9 @@ void RUBY::close(void) {
/* Finish off our init function */
Printv(f_init,
"\n",
"for (i = 0; _swig_types_initial[i]; i++) {\n",
"_swig_types[i] = SWIG_TypeRegister(_swig_types_initial[i]);\n",
"SWIG_define_class(_swig_types[i]);\n",
"for (i = 0; swig_types_initial[i]; i++) {\n",
"swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);\n",
"SWIG_define_class(swig_types[i]);\n",
"}\n",
0);
Printf(f_init,"}\n");

40
SWIG/Source/Modules1.1/tcl8.cxx
View file

@ -204,11 +204,11 @@ TCL8::initialize() {
Printf(f_init,"Tcl_Eval(interp,\"namespace eval %s { }\");\n", ns_name);
}
Printf(cmd_info, "\nstatic _swig_command_info _swig_commands[] = {\n");
Printf(var_info, "\nstatic _swig_var_info _swig_variables[] = {\n");
Printf(cmd_info, "\nstatic swig_command_info swig_commands[] = {\n");
Printf(var_info, "\nstatic swig_var_info swig_variables[] = {\n");
Printv(f_init,
"for (i = 0; _swig_types_initial[i]; i++) {\n",
"_swig_types[i] = SWIG_TypeRegister(_swig_types_initial[i]);\n",
"for (i = 0; swig_types_initial[i]; i++) {\n",
"swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);\n",
"}\n", 0);
}
@ -225,14 +225,14 @@ TCL8::close(void) {
Printf(f_wrappers,"%s", cmd_info);
Printf(f_wrappers,"%s", var_info);
Printf(f_init,"for (i = 0; _swig_commands[i].name; i++) {\n");
Printf(f_init,"Tcl_CreateObjCommand(interp, (char *) _swig_commands[i].name, _swig_commands[i].wrapper, _swig_commands[i].clientdata, NULL);\n");
Printf(f_init,"for (i = 0; swig_commands[i].name; i++) {\n");
Printf(f_init,"Tcl_CreateObjCommand(interp, (char *) swig_commands[i].name, swig_commands[i].wrapper, swig_commands[i].clientdata, NULL);\n");
Printf(f_init,"}\n");
Printf(f_init,"for (i = 0; _swig_variables[i].name; i++) {\n");
Printf(f_init,"Tcl_SetVar(interp, (char *) _swig_variables[i].name, \"\", TCL_GLOBAL_ONLY);\n");
Printf(f_init,"Tcl_TraceVar(interp, (char *) _swig_variables[i].name, TCL_TRACE_READS | TCL_GLOBAL_ONLY, _swig_variables[i].get, (ClientData) _swig_variables[i].addr);\n");
Printf(f_init,"Tcl_TraceVar(interp, (char *) _swig_variables[i].name, TCL_TRACE_WRITES | TCL_GLOBAL_ONLY, _swig_variables[i].set, (ClientData) _swig_variables[i].addr);\n");
Printf(f_init,"for (i = 0; swig_variables[i].name; i++) {\n");
Printf(f_init,"Tcl_SetVar(interp, (char *) swig_variables[i].name, \"\", TCL_GLOBAL_ONLY);\n");
Printf(f_init,"Tcl_TraceVar(interp, (char *) swig_variables[i].name, TCL_TRACE_READS | TCL_GLOBAL_ONLY, swig_variables[i].get, (ClientData) swig_variables[i].addr);\n");
Printf(f_init,"Tcl_TraceVar(interp, (char *) swig_variables[i].name, TCL_TRACE_WRITES | TCL_GLOBAL_ONLY, swig_variables[i].set, (ClientData) swig_variables[i].addr);\n");
Printf(f_init,"}\n");
/* Dump the pointer equivalency table */
@ -566,8 +566,8 @@ TCL8::link_variable(char *name, char *iname, SwigType *t) {
if (!getname) {
Wrapper *get, *set;
setname = NewStringf("_swig_%s_set", Swig_string_mangle(t));
getname = NewStringf("_swig_%s_get", Swig_string_mangle(t));
setname = NewStringf("swig_%s_set", Swig_string_mangle(t));
getname = NewStringf("swig_%s_get", Swig_string_mangle(t));
get = NewWrapper();
set = NewWrapper();
Printv(set->def, "static char *", setname, "(ClientData clientData, Tcl_Interp *interp, char *name1, char *name2, int flags) {",0);
@ -742,13 +742,13 @@ TCL8::link_variable(char *name, char *iname, SwigType *t) {
static int readonlywrap = 0;
if (!readonlywrap) {
Wrapper *ro = NewWrapper();
Printf(ro->def, "static char *_swig_readonly(ClientData clientData, Tcl_Interp *interp, char *name1, char *name2, int flags) {");
Printf(ro->def, "static char *swig_readonly(ClientData clientData, Tcl_Interp *interp, char *name1, char *name2, int flags) {");
Printv(ro->code, "return \"Variable is read-only\";\n", "}\n", 0);
Wrapper_print(ro,f_wrappers);
readonlywrap = 1;
DelWrapper(ro);
}
Printf(var_info, "_swig_readonly},\n");
Printf(var_info, "swig_readonly},\n");
} else {
Printv(var_info, setname, "},\n",0);
}
@ -941,11 +941,11 @@ TCL8::cpp_open_class(char *classname, char *rename, char *ctype, int strip) {
}
Clear(attributes);
Printf(attributes, "static _swig_attribute _swig_");
Printf(attributes, "static swig_attribute swig_");
Printv(attributes, classname, "_attributes[] = {\n", 0);
Clear(methods);
Printf(methods,"static _swig_method _swig_");
Printf(methods,"static swig_method swig_");
Printv(methods, classname, "_methods[] = {\n", 0);
have_constructor = 0;
@ -972,7 +972,7 @@ TCL8::cpp_close_class() {
SwigType_add_pointer(t);
if (have_destructor) {
Printv(code, "static void _swig_delete_", class_name, "(void *obj) {\n", 0);
Printv(code, "static void swig_delete_", class_name, "(void *obj) {\n", 0);
if (CPlusPlus) {
Printv(code," delete (", SwigType_str(t,0), ") obj;\n",0);
} else {
@ -987,7 +987,7 @@ TCL8::cpp_close_class() {
Printf(attributes, " {0,0,0}\n};\n");
Printv(code,attributes,0);
Printv(code, "static _swig_class _wrap_class_", class_name, " = { \"", class_name,
Printv(code, "static swig_class _wrap_class_", class_name, " = { \"", class_name,
"\", &SWIGTYPE", SwigType_manglestr(t), ",",0);
if (have_constructor) {
@ -996,11 +996,11 @@ TCL8::cpp_close_class() {
Printf(code,"0");
}
if (have_destructor) {
Printv(code, ", _swig_delete_", class_name,0);
Printv(code, ", swig_delete_", class_name,0);
} else {
Printf(code,",0");
}
Printv(code, ", _swig_", real_classname, "_methods, _swig_", real_classname, "_attributes };\n", 0);
Printv(code, ", swig_", real_classname, "_methods, swig_", real_classname, "_attributes };\n", 0);
Printf(f_wrappers,"%s",code);
Printv(cmd_info, tab4, "{ SWIG_prefix \"", class_name, "\", SwigObjectCmd, &_wrap_class_", class_name, "},\n", 0);

8
SWIG/Source/Swig/stype.c
View file

@ -1555,14 +1555,14 @@ SwigType_emit_type_table(File *f_forward, File *f_table) {
#endif
table = NewString("");
types = NewString("");
Printf(table,"static _swig_type_info *_swig_types_initial[] = {\n");
Printf(table,"static swig_type_info *swig_types_initial[] = {\n");
key = Firstkey(r_mangled);
Printf(f_forward,"\n/* -------- TYPES TABLE (BEGIN) -------- */\n\n");
while (key) {
List *el;
String *en;
Printf(f_forward,"#define SWIGTYPE%s _swig_types[%d] \n", key, i);
Printv(types,"static _swig_type_info _swigt_", key, "[] = {", 0);
Printf(f_forward,"#define SWIGTYPE%s swig_types[%d] \n", key, i);
Printv(types,"static swig_type_info _swigt_", key, "[] = {", 0);
Printv(types,"{\"", key, "\", 0, \"", SwigType_str(Getattr(r_ltype,key),0),"\"},", 0);
el = SwigType_equivalent_mangle(key,0,0);
for (en = Firstitem(el); en; en = Nextitem(el)) {
@ -1583,7 +1583,7 @@ SwigType_emit_type_table(File *f_forward, File *f_table) {
}
Printf(table, "0\n};\n");
Printf(f_forward,"static _swig_type_info *_swig_types[%d];\n", i+1);
Printf(f_forward,"static swig_type_info *swig_types[%d];\n", i+1);
Printf(f_forward,"\n/* -------- TYPES TABLE (END) -------- */\n\n");
Printf(f_table,"%s\n", types);
Printf(f_table,"%s\n", table);