You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
237 lines
7.9 KiB
237 lines
7.9 KiB
![]()
4 years ago
|
/* -----------------------------------------------------------------------------
|
||
|
* Type initialization:
|
||
|
* This problem is tough by the requirement that no dynamic
|
||
|
* memory is used. Also, since swig_type_info structures store pointers to
|
||
|
* swig_cast_info structures and swig_cast_info structures store pointers back
|
||
|
* to swig_type_info structures, we need some lookup code at initialization.
|
||
|
* The idea is that swig generates all the structures that are needed.
|
||
|
* The runtime then collects these partially filled structures.
|
||
|
* The SWIG_InitializeModule function takes these initial arrays out of
|
||
|
* swig_module, and does all the lookup, filling in the swig_module.types
|
||
|
* array with the correct data and linking the correct swig_cast_info
|
||
|
* structures together.
|
||
|
*
|
||
|
* The generated swig_type_info structures are assigned staticly to an initial
|
||
|
* array. We just loop through that array, and handle each type individually.
|
||
|
* First we lookup if this type has been already loaded, and if so, use the
|
||
|
* loaded structure instead of the generated one. Then we have to fill in the
|
||
|
* cast linked list. The cast data is initially stored in something like a
|
||
|
* two-dimensional array. Each row corresponds to a type (there are the same
|
||
|
* number of rows as there are in the swig_type_initial array). Each entry in
|
||
|
* a column is one of the swig_cast_info structures for that type.
|
||
|
* The cast_initial array is actually an array of arrays, because each row has
|
||
|
* a variable number of columns. So to actually build the cast linked list,
|
||
|
* we find the array of casts associated with the type, and loop through it
|
||
|
* adding the casts to the list. The one last trick we need to do is making
|
||
|
* sure the type pointer in the swig_cast_info struct is correct.
|
||
|
*
|
||
|
* First off, we lookup the cast->type name to see if it is already loaded.
|
||
|
* There are three cases to handle:
|
||
|
* 1) If the cast->type has already been loaded AND the type we are adding
|
||
|
* casting info to has not been loaded (it is in this module), THEN we
|
||
|
* replace the cast->type pointer with the type pointer that has already
|
||
|
* been loaded.
|
||
|
* 2) If BOTH types (the one we are adding casting info to, and the
|
||
|
* cast->type) are loaded, THEN the cast info has already been loaded by
|
||
|
* the previous module so we just ignore it.
|
||
|
* 3) Finally, if cast->type has not already been loaded, then we add that
|
||
|
* swig_cast_info to the linked list (because the cast->type) pointer will
|
||
|
* be correct.
|
||
|
* ----------------------------------------------------------------------------- */
|
||
|
|
||
|
#ifdef __cplusplus
|
||
|
extern "C" {
|
||
|
#if 0
|
||
|
} /* c-mode */
|
||
|
#endif
|
||
|
#endif
|
||
|
|
||
|
#if 0
|
||
|
#define SWIGRUNTIME_DEBUG
|
||
|
#endif
|
||
|
|
||
|
|
||
|
SWIGRUNTIME void
|
||
|
SWIG_InitializeModule(void *clientdata) {
|
||
|
size_t i;
|
||
|
swig_module_info *module_head, *iter;
|
||
|
int found, init;
|
||
|
|
||
|
clientdata = clientdata;
|
||
|
|
||
|
/* check to see if the circular list has been setup, if not, set it up */
|
||
|
if (swig_module.next==0) {
|
||
|
/* Initialize the swig_module */
|
||
|
swig_module.type_initial = swig_type_initial;
|
||
|
swig_module.cast_initial = swig_cast_initial;
|
||
|
swig_module.next = &swig_module;
|
||
|
init = 1;
|
||
|
} else {
|
||
|
init = 0;
|
||
|
}
|
||
|
|
||
|
/* Try and load any already created modules */
|
||
|
module_head = SWIG_GetModule(clientdata);
|
||
|
if (!module_head) {
|
||
|
/* This is the first module loaded for this interpreter */
|
||
|
/* so set the swig module into the interpreter */
|
||
|
SWIG_SetModule(clientdata, &swig_module);
|
||
|
module_head = &swig_module;
|
||
|
} else {
|
||
|
/* the interpreter has loaded a SWIG module, but has it loaded this one? */
|
||
|
found=0;
|
||
|
iter=module_head;
|
||
|
do {
|
||
|
if (iter==&swig_module) {
|
||
|
found=1;
|
||
|
break;
|
||
|
}
|
||
|
iter=iter->next;
|
||
|
} while (iter!= module_head);
|
||
|
|
||
|
/* if the is found in the list, then all is done and we may leave */
|
||
|
if (found) return;
|
||
|
/* otherwise we must add out module into the list */
|
||
|
swig_module.next = module_head->next;
|
||
|
module_head->next = &swig_module;
|
||
|
}
|
||
|
|
||
|
/* When multiple interpeters are used, a module could have already been initialized in
|
||
|
a different interpreter, but not yet have a pointer in this interpreter.
|
||
|
In this case, we do not want to continue adding types... everything should be
|
||
|
set up already */
|
||
|
if (init == 0) return;
|
||
|
|
||
|
/* Now work on filling in swig_module.types */
|
||
|
#ifdef SWIGRUNTIME_DEBUG
|
||
|
printf("SWIG_InitializeModule: size %d\n", swig_module.size);
|
||
|
#endif
|
||
|
for (i = 0; i < swig_module.size; ++i) {
|
||
|
swig_type_info *type = 0;
|
||
|
swig_type_info *ret;
|
||
|
swig_cast_info *cast;
|
||
|
|
||
|
#ifdef SWIGRUNTIME_DEBUG
|
||
|
printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
|
||
|
#endif
|
||
|
|
||
|
/* if there is another module already loaded */
|
||
|
if (swig_module.next != &swig_module) {
|
||
|
type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
|
||
|
}
|
||
|
if (type) {
|
||
|
/* Overwrite clientdata field */
|
||
|
#ifdef SWIGRUNTIME_DEBUG
|
||
|
printf("SWIG_InitializeModule: found type %s\n", type->name);
|
||
|
#endif
|
||
|
if (swig_module.type_initial[i]->clientdata) {
|
||
|
type->clientdata = swig_module.type_initial[i]->clientdata;
|
||
|
#ifdef SWIGRUNTIME_DEBUG
|
||
|
printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
|
||
|
#endif
|
||
|
}
|
||
|
} else {
|
||
|
type = swig_module.type_initial[i];
|
||
|
}
|
||
|
|
||
|
/* Insert casting types */
|
||
|
cast = swig_module.cast_initial[i];
|
||
|
while (cast->type) {
|
||
|
|
||
|
/* Don't need to add information already in the list */
|
||
|
ret = 0;
|
||
|
#ifdef SWIGRUNTIME_DEBUG
|
||
|
printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
|
||
|
#endif
|
||
|
if (swig_module.next != &swig_module) {
|
||
|
ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
|
||
|
#ifdef SWIGRUNTIME_DEBUG
|
||
|
if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
|
||
|
#endif
|
||
|
}
|
||
|
if (ret) {
|
||
|
if (type == swig_module.type_initial[i]) {
|
||
|
#ifdef SWIGRUNTIME_DEBUG
|
||
|
printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
|
||
|
#endif
|
||
|
cast->type = ret;
|
||
|
ret = 0;
|
||
|
} else {
|
||
|
/* Check for casting already in the list */
|
||
|
swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
|
||
|
#ifdef SWIGRUNTIME_DEBUG
|
||
|
if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
|
||
|
#endif
|
||
|
if (!ocast) ret = 0;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
if (!ret) {
|
||
|
#ifdef SWIGRUNTIME_DEBUG
|
||
|
printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
|
||
|
#endif
|
||
|
if (type->cast) {
|
||
|
type->cast->prev = cast;
|
||
|
cast->next = type->cast;
|
||
|
}
|
||
|
type->cast = cast;
|
||
|
}
|
||
|
cast++;
|
||
|
}
|
||
|
/* Set entry in modules->types array equal to the type */
|
||
|
swig_module.types[i] = type;
|
||
|
}
|
||
|
swig_module.types[i] = 0;
|
||
|
|
||
|
#ifdef SWIGRUNTIME_DEBUG
|
||
|
printf("**** SWIG_InitializeModule: Cast List ******\n");
|
||
|
for (i = 0; i < swig_module.size; ++i) {
|
||
|
int j = 0;
|
||
|
swig_cast_info *cast = swig_module.cast_initial[i];
|
||
|
printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
|
||
|
while (cast->type) {
|
||
|
printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
|
||
|
cast++;
|
||
|
++j;
|
||
|
}
|
||
|
printf("---- Total casts: %d\n",j);
|
||
|
}
|
||
|
printf("**** SWIG_InitializeModule: Cast List ******\n");
|
||
|
#endif
|
||
|
}
|
||
|
|
||
|
/* This function will propagate the clientdata field of type to
|
||
|
* any new swig_type_info structures that have been added into the list
|
||
|
* of equivalent types. It is like calling
|
||
|
* SWIG_TypeClientData(type, clientdata) a second time.
|
||
|
*/
|
||
|
SWIGRUNTIME void
|
||
|
SWIG_PropagateClientData(void) {
|
||
|
size_t i;
|
||
|
swig_cast_info *equiv;
|
||
|
static int init_run = 0;
|
||
|
|
||
|
if (init_run) return;
|
||
|
init_run = 1;
|
||
|
|
||
|
for (i = 0; i < swig_module.size; i++) {
|
||
|
if (swig_module.types[i]->clientdata) {
|
||
|
equiv = swig_module.types[i]->cast;
|
||
|
while (equiv) {
|
||
|
if (!equiv->converter) {
|
||
|
if (equiv->type && !equiv->type->clientdata)
|
||
|
SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
|
||
|
}
|
||
|
equiv = equiv->next;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
|
||
|
#ifdef __cplusplus
|
||
|
#if 0
|
||
|
{ /* c-mode */
|
||
|
#endif
|
||
|
}
|
||
|
#endif
|