|
1899
|
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 /* check to see if the circular list has been setup, if not, set it up */
|
|
|
61 if (swig_module.next==0) {
|
|
|
62 /* Initialize the swig_module */
|
|
|
63 swig_module.type_initial = swig_type_initial;
|
|
|
64 swig_module.cast_initial = swig_cast_initial;
|
|
|
65 swig_module.next = &swig_module;
|
|
|
66 init = 1;
|
|
|
67 } else {
|
|
|
68 init = 0;
|
|
|
69 }
|
|
|
70
|
|
|
71 /* Try and load any already created modules */
|
|
|
72 module_head = SWIG_GetModule(clientdata);
|
|
|
73 if (!module_head) {
|
|
|
74 /* This is the first module loaded for this interpreter */
|
|
|
75 /* so set the swig module into the interpreter */
|
|
|
76 SWIG_SetModule(clientdata, &swig_module);
|
|
|
77 module_head = &swig_module;
|
|
|
78 } else {
|
|
|
79 /* the interpreter has loaded a SWIG module, but has it loaded this one? */
|
|
|
80 found=0;
|
|
|
81 iter=module_head;
|
|
|
82 do {
|
|
|
83 if (iter==&swig_module) {
|
|
|
84 found=1;
|
|
|
85 break;
|
|
|
86 }
|
|
|
87 iter=iter->next;
|
|
|
88 } while (iter!= module_head);
|
|
|
89
|
|
|
90 /* if the is found in the list, then all is done and we may leave */
|
|
|
91 if (found) return;
|
|
|
92 /* otherwise we must add out module into the list */
|
|
|
93 swig_module.next = module_head->next;
|
|
|
94 module_head->next = &swig_module;
|
|
|
95 }
|
|
|
96
|
|
|
97 /* When multiple interpreters are used, a module could have already been initialized in
|
|
|
98 a different interpreter, but not yet have a pointer in this interpreter.
|
|
|
99 In this case, we do not want to continue adding types... everything should be
|
|
|
100 set up already */
|
|
|
101 if (init == 0) return;
|
|
|
102
|
|
|
103 /* Now work on filling in swig_module.types */
|
|
|
104 #ifdef SWIGRUNTIME_DEBUG
|
|
|
105 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
|
|
|
106 #endif
|
|
|
107 for (i = 0; i < swig_module.size; ++i) {
|
|
|
108 swig_type_info *type = 0;
|
|
|
109 swig_type_info *ret;
|
|
|
110 swig_cast_info *cast;
|
|
|
111
|
|
|
112 #ifdef SWIGRUNTIME_DEBUG
|
|
|
113 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
|
|
|
114 #endif
|
|
|
115
|
|
|
116 /* if there is another module already loaded */
|
|
|
117 if (swig_module.next != &swig_module) {
|
|
|
118 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
|
|
|
119 }
|
|
|
120 if (type) {
|
|
|
121 /* Overwrite clientdata field */
|
|
|
122 #ifdef SWIGRUNTIME_DEBUG
|
|
|
123 printf("SWIG_InitializeModule: found type %s\n", type->name);
|
|
|
124 #endif
|
|
|
125 if (swig_module.type_initial[i]->clientdata) {
|
|
|
126 type->clientdata = swig_module.type_initial[i]->clientdata;
|
|
|
127 #ifdef SWIGRUNTIME_DEBUG
|
|
|
128 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
|
|
|
129 #endif
|
|
|
130 }
|
|
|
131 } else {
|
|
|
132 type = swig_module.type_initial[i];
|
|
|
133 }
|
|
|
134
|
|
|
135 /* Insert casting types */
|
|
|
136 cast = swig_module.cast_initial[i];
|
|
|
137 while (cast->type) {
|
|
|
138
|
|
|
139 /* Don't need to add information already in the list */
|
|
|
140 ret = 0;
|
|
|
141 #ifdef SWIGRUNTIME_DEBUG
|
|
|
142 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
|
|
|
143 #endif
|
|
|
144 if (swig_module.next != &swig_module) {
|
|
|
145 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
|
|
|
146 #ifdef SWIGRUNTIME_DEBUG
|
|
|
147 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
|
|
|
148 #endif
|
|
|
149 }
|
|
|
150 if (ret) {
|
|
|
151 if (type == swig_module.type_initial[i]) {
|
|
|
152 #ifdef SWIGRUNTIME_DEBUG
|
|
|
153 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
|
|
|
154 #endif
|
|
|
155 cast->type = ret;
|
|
|
156 ret = 0;
|
|
|
157 } else {
|
|
|
158 /* Check for casting already in the list */
|
|
|
159 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
|
|
|
160 #ifdef SWIGRUNTIME_DEBUG
|
|
|
161 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
|
|
|
162 #endif
|
|
|
163 if (!ocast) ret = 0;
|
|
|
164 }
|
|
|
165 }
|
|
|
166
|
|
|
167 if (!ret) {
|
|
|
168 #ifdef SWIGRUNTIME_DEBUG
|
|
|
169 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
|
|
|
170 #endif
|
|
|
171 if (type->cast) {
|
|
|
172 type->cast->prev = cast;
|
|
|
173 cast->next = type->cast;
|
|
|
174 }
|
|
|
175 type->cast = cast;
|
|
|
176 }
|
|
|
177 cast++;
|
|
|
178 }
|
|
|
179 /* Set entry in modules->types array equal to the type */
|
|
|
180 swig_module.types[i] = type;
|
|
|
181 }
|
|
|
182 swig_module.types[i] = 0;
|
|
|
183
|
|
|
184 #ifdef SWIGRUNTIME_DEBUG
|
|
|
185 printf("**** SWIG_InitializeModule: Cast List ******\n");
|
|
|
186 for (i = 0; i < swig_module.size; ++i) {
|
|
|
187 int j = 0;
|
|
|
188 swig_cast_info *cast = swig_module.cast_initial[i];
|
|
|
189 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
|
|
|
190 while (cast->type) {
|
|
|
191 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
|
|
|
192 cast++;
|
|
|
193 ++j;
|
|
|
194 }
|
|
|
195 printf("---- Total casts: %d\n",j);
|
|
|
196 }
|
|
|
197 printf("**** SWIG_InitializeModule: Cast List ******\n");
|
|
|
198 #endif
|
|
|
199 }
|
|
|
200
|
|
|
201 /* This function will propagate the clientdata field of type to
|
|
|
202 * any new swig_type_info structures that have been added into the list
|
|
|
203 * of equivalent types. It is like calling
|
|
|
204 * SWIG_TypeClientData(type, clientdata) a second time.
|
|
|
205 */
|
|
|
206 SWIGRUNTIME void
|
|
|
207 SWIG_PropagateClientData(void) {
|
|
|
208 size_t i;
|
|
|
209 swig_cast_info *equiv;
|
|
|
210 static int init_run = 0;
|
|
|
211
|
|
|
212 if (init_run) return;
|
|
|
213 init_run = 1;
|
|
|
214
|
|
|
215 for (i = 0; i < swig_module.size; i++) {
|
|
|
216 if (swig_module.types[i]->clientdata) {
|
|
|
217 equiv = swig_module.types[i]->cast;
|
|
|
218 while (equiv) {
|
|
|
219 if (!equiv->converter) {
|
|
|
220 if (equiv->type && !equiv->type->clientdata)
|
|
|
221 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
|
|
|
222 }
|
|
|
223 equiv = equiv->next;
|
|
|
224 }
|
|
|
225 }
|
|
|
226 }
|
|
|
227 }
|
|
|
228
|
|
|
229 #ifdef __cplusplus
|
|
|
230 #if 0
|
|
|
231 { /* c-mode */
|
|
|
232 #endif
|
|
|
233 }
|
|
|
234 #endif
|
