OLD | NEW |
(Empty) | |
| 1 /* ----------------------------------------------------------------------------- |
| 2 * Type initialization: |
| 3 * This problem is tough by the requirement that no dynamic |
| 4 * memory is used. Also, since swig_type_info structures store pointers to |
| 5 * swig_cast_info structures and swig_cast_info structures store pointers back |
| 6 * to swig_type_info structures, we need some lookup code at initialization. |
| 7 * The idea is that swig generates all the structures that are needed. |
| 8 * The runtime then collects these partially filled structures. |
| 9 * The SWIG_InitializeModule function takes these initial arrays out of |
| 10 * swig_module, and does all the lookup, filling in the swig_module.types |
| 11 * array with the correct data and linking the correct swig_cast_info |
| 12 * structures together. |
| 13 * |
| 14 * The generated swig_type_info structures are assigned staticly to an initial |
| 15 * array. We just loop through that array, and handle each type individually. |
| 16 * First we lookup if this type has been already loaded, and if so, use the |
| 17 * loaded structure instead of the generated one. Then we have to fill in the |
| 18 * cast linked list. The cast data is initially stored in something like a |
| 19 * two-dimensional array. Each row corresponds to a type (there are the same |
| 20 * number of rows as there are in the swig_type_initial array). Each entry in |
| 21 * a column is one of the swig_cast_info structures for that type. |
| 22 * The cast_initial array is actually an array of arrays, because each row has |
| 23 * a variable number of columns. So to actually build the cast linked list, |
| 24 * we find the array of casts associated with the type, and loop through it |
| 25 * adding the casts to the list. The one last trick we need to do is making |
| 26 * sure the type pointer in the swig_cast_info struct is correct. |
| 27 * |
| 28 * First off, we lookup the cast->type name to see if it is already loaded. |
| 29 * There are three cases to handle: |
| 30 * 1) If the cast->type has already been loaded AND the type we are adding |
| 31 * casting info to has not been loaded (it is in this module), THEN we |
| 32 * replace the cast->type pointer with the type pointer that has already |
| 33 * been loaded. |
| 34 * 2) If BOTH types (the one we are adding casting info to, and the |
| 35 * cast->type) are loaded, THEN the cast info has already been loaded by |
| 36 * the previous module so we just ignore it. |
| 37 * 3) Finally, if cast->type has not already been loaded, then we add that |
| 38 * swig_cast_info to the linked list (because the cast->type) pointer will |
| 39 * be correct. |
| 40 * -----------------------------------------------------------------------------
*/ |
| 41 |
| 42 #ifdef __cplusplus |
| 43 extern "C" { |
| 44 #if 0 |
| 45 } /* c-mode */ |
| 46 #endif |
| 47 #endif |
| 48 |
| 49 #if 0 |
| 50 #define SWIGRUNTIME_DEBUG |
| 51 #endif |
| 52 |
| 53 |
| 54 SWIGRUNTIME void |
| 55 SWIG_InitializeModule(void *clientdata) { |
| 56 size_t i; |
| 57 swig_module_info *module_head, *iter; |
| 58 int found, init; |
| 59 |
| 60 clientdata = clientdata; |
| 61 |
| 62 /* check to see if the circular list has been setup, if not, set it up */ |
| 63 if (swig_module.next==0) { |
| 64 /* Initialize the swig_module */ |
| 65 swig_module.type_initial = swig_type_initial; |
| 66 swig_module.cast_initial = swig_cast_initial; |
| 67 swig_module.next = &swig_module; |
| 68 init = 1; |
| 69 } else { |
| 70 init = 0; |
| 71 } |
| 72 |
| 73 /* Try and load any already created modules */ |
| 74 module_head = SWIG_GetModule(clientdata); |
| 75 if (!module_head) { |
| 76 /* This is the first module loaded for this interpreter */ |
| 77 /* so set the swig module into the interpreter */ |
| 78 SWIG_SetModule(clientdata, &swig_module); |
| 79 module_head = &swig_module; |
| 80 } else { |
| 81 /* the interpreter has loaded a SWIG module, but has it loaded this one? */ |
| 82 found=0; |
| 83 iter=module_head; |
| 84 do { |
| 85 if (iter==&swig_module) { |
| 86 found=1; |
| 87 break; |
| 88 } |
| 89 iter=iter->next; |
| 90 } while (iter!= module_head); |
| 91 |
| 92 /* if the is found in the list, then all is done and we may leave */ |
| 93 if (found) return; |
| 94 /* otherwise we must add out module into the list */ |
| 95 swig_module.next = module_head->next; |
| 96 module_head->next = &swig_module; |
| 97 } |
| 98 |
| 99 /* When multiple interpeters are used, a module could have already been initia
lized in |
| 100 a different interpreter, but not yet have a pointer in this interpreter. |
| 101 In this case, we do not want to continue adding types... everything should
be |
| 102 set up already */ |
| 103 if (init == 0) return; |
| 104 |
| 105 /* Now work on filling in swig_module.types */ |
| 106 #ifdef SWIGRUNTIME_DEBUG |
| 107 printf("SWIG_InitializeModule: size %d\n", swig_module.size); |
| 108 #endif |
| 109 for (i = 0; i < swig_module.size; ++i) { |
| 110 swig_type_info *type = 0; |
| 111 swig_type_info *ret; |
| 112 swig_cast_info *cast; |
| 113 |
| 114 #ifdef SWIGRUNTIME_DEBUG |
| 115 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]
->name); |
| 116 #endif |
| 117 |
| 118 /* if there is another module already loaded */ |
| 119 if (swig_module.next != &swig_module) { |
| 120 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_mo
dule.type_initial[i]->name); |
| 121 } |
| 122 if (type) { |
| 123 /* Overwrite clientdata field */ |
| 124 #ifdef SWIGRUNTIME_DEBUG |
| 125 printf("SWIG_InitializeModule: found type %s\n", type->name); |
| 126 #endif |
| 127 if (swig_module.type_initial[i]->clientdata) { |
| 128 type->clientdata = swig_module.type_initial[i]->clientdata; |
| 129 #ifdef SWIGRUNTIME_DEBUG |
| 130 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name
); |
| 131 #endif |
| 132 } |
| 133 } else { |
| 134 type = swig_module.type_initial[i]; |
| 135 } |
| 136 |
| 137 /* Insert casting types */ |
| 138 cast = swig_module.cast_initial[i]; |
| 139 while (cast->type) { |
| 140 |
| 141 /* Don't need to add information already in the list */ |
| 142 ret = 0; |
| 143 #ifdef SWIGRUNTIME_DEBUG |
| 144 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name); |
| 145 #endif |
| 146 if (swig_module.next != &swig_module) { |
| 147 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->
type->name); |
| 148 #ifdef SWIGRUNTIME_DEBUG |
| 149 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name); |
| 150 #endif |
| 151 } |
| 152 if (ret) { |
| 153 if (type == swig_module.type_initial[i]) { |
| 154 #ifdef SWIGRUNTIME_DEBUG |
| 155 printf("SWIG_InitializeModule: skip old type %s\n", ret->name); |
| 156 #endif |
| 157 cast->type = ret; |
| 158 ret = 0; |
| 159 } else { |
| 160 /* Check for casting already in the list */ |
| 161 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type); |
| 162 #ifdef SWIGRUNTIME_DEBUG |
| 163 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->na
me); |
| 164 #endif |
| 165 if (!ocast) ret = 0; |
| 166 } |
| 167 } |
| 168 |
| 169 if (!ret) { |
| 170 #ifdef SWIGRUNTIME_DEBUG |
| 171 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name); |
| 172 #endif |
| 173 if (type->cast) { |
| 174 type->cast->prev = cast; |
| 175 cast->next = type->cast; |
| 176 } |
| 177 type->cast = cast; |
| 178 } |
| 179 cast++; |
| 180 } |
| 181 /* Set entry in modules->types array equal to the type */ |
| 182 swig_module.types[i] = type; |
| 183 } |
| 184 swig_module.types[i] = 0; |
| 185 |
| 186 #ifdef SWIGRUNTIME_DEBUG |
| 187 printf("**** SWIG_InitializeModule: Cast List ******\n"); |
| 188 for (i = 0; i < swig_module.size; ++i) { |
| 189 int j = 0; |
| 190 swig_cast_info *cast = swig_module.cast_initial[i]; |
| 191 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]
->name); |
| 192 while (cast->type) { |
| 193 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name); |
| 194 cast++; |
| 195 ++j; |
| 196 } |
| 197 printf("---- Total casts: %d\n",j); |
| 198 } |
| 199 printf("**** SWIG_InitializeModule: Cast List ******\n"); |
| 200 #endif |
| 201 } |
| 202 |
| 203 /* This function will propagate the clientdata field of type to |
| 204 * any new swig_type_info structures that have been added into the list |
| 205 * of equivalent types. It is like calling |
| 206 * SWIG_TypeClientData(type, clientdata) a second time. |
| 207 */ |
| 208 SWIGRUNTIME void |
| 209 SWIG_PropagateClientData(void) { |
| 210 size_t i; |
| 211 swig_cast_info *equiv; |
| 212 static int init_run = 0; |
| 213 |
| 214 if (init_run) return; |
| 215 init_run = 1; |
| 216 |
| 217 for (i = 0; i < swig_module.size; i++) { |
| 218 if (swig_module.types[i]->clientdata) { |
| 219 equiv = swig_module.types[i]->cast; |
| 220 while (equiv) { |
| 221 if (!equiv->converter) { |
| 222 if (equiv->type && !equiv->type->clientdata) |
| 223 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata); |
| 224 } |
| 225 equiv = equiv->next; |
| 226 } |
| 227 } |
| 228 } |
| 229 } |
| 230 |
| 231 #ifdef __cplusplus |
| 232 #if 0 |
| 233 { /* c-mode */ |
| 234 #endif |
| 235 } |
| 236 #endif |
OLD | NEW |