mirror of
https://github.com/nillerusr/source-engine.git
synced 2026-09-01 15:09:19 +00:00
1
This commit is contained in:
FluorescentCIAAfricanAmerican
@@ -0,0 +1,236 @@
|
||||
/* -----------------------------------------------------------------------------
|
||||
* 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
|
||||
Reference in New Issue
Block a user