]>
Commit | Line | Data |
---|---|---|
1 | /******************************************************************************* | |
2 | * Simplified Wrapper and Interface Generator (SWIG) | |
3 | * | |
4 | * Author : David Beazley | |
5 | * | |
6 | * Department of Computer Science | |
7 | * University of Chicago | |
8 | * 1100 E 58th Street | |
9 | * Chicago, IL 60637 | |
10 | * beazley@cs.uchicago.edu | |
11 | * | |
12 | * Please read the file LICENSE for the copyright and terms by which SWIG | |
13 | * can be used and distributed. | |
14 | *******************************************************************************/ | |
15 | ||
16 | /********************************************************************** | |
17 | * $Header$ | |
18 | * | |
19 | * pycpp.cxx | |
20 | * | |
21 | * This module contains code to generate Python shadow classes of C/C++ | |
22 | * objects. | |
23 | **************************************************************************/ | |
24 | ||
25 | ||
26 | #include "swig.h" | |
27 | #include "python.h" | |
28 | ||
29 | static String *setattr; | |
30 | static String *getattr; | |
31 | static String *pyclass; | |
32 | static String *construct; | |
33 | static String *cinit; | |
34 | static String *additional; | |
35 | static int have_constructor; | |
36 | static int have_destructor; | |
37 | static int have_getattr; | |
38 | static int have_setattr; | |
39 | static int have_repr; | |
40 | static char *class_name; | |
41 | static char *class_type; | |
42 | static char *real_classname; | |
43 | static String *base_class; | |
44 | static String base_getattr; | |
45 | static String base_setattr; | |
46 | static int class_renamed = 0; | |
47 | ||
48 | // -------------------------------------------------------------------------- | |
49 | // PYTHON::cpp_open_class(char *classname, char *rname, char *ctype, int strip) | |
50 | // | |
51 | // Opens a new C++ class or structure. | |
52 | // -------------------------------------------------------------------------- | |
53 | ||
54 | void PYTHON::cpp_open_class(char *classname, char *rname, char *ctype, int strip) { | |
55 | ||
56 | char temp[256]; | |
57 | ||
58 | this->Language::cpp_open_class(classname, rname, ctype, strip); | |
59 | ||
60 | if (shadow) { | |
61 | /* Create new strings for building up a wrapper function */ | |
62 | ||
63 | setattr = new String(); | |
64 | getattr = new String(); | |
65 | pyclass = new String(); | |
66 | construct = new String(); | |
67 | cinit = new String(); | |
68 | additional= new String(); | |
69 | base_class = 0; | |
70 | base_getattr = ""; | |
71 | base_setattr = ""; | |
72 | ||
73 | ||
74 | // *pyclass << "class " << rname << ":\n"; | |
75 | *setattr << tab4 << "def __setattr__(self,name,value):\n"; | |
76 | *getattr << tab4 << "def __getattr__(self,name):\n"; | |
77 | have_constructor = 0; | |
78 | have_destructor = 0; | |
79 | have_getattr = 0; | |
80 | have_setattr = 0; | |
81 | have_repr = 0; | |
82 | if (rname) { | |
83 | class_name = copy_string(rname); | |
84 | class_renamed = 1; | |
85 | } else { | |
86 | class_name = copy_string(classname); | |
87 | class_renamed = 0; | |
88 | } | |
89 | } | |
90 | ||
91 | real_classname = copy_string(classname); | |
92 | class_type = copy_string(ctype); | |
93 | ||
94 | // Build up the hash table | |
95 | hash.add(real_classname,copy_string(class_name)); | |
96 | ||
97 | sprintf(temp,"%s %s", class_type, real_classname); | |
98 | hash.add(temp,copy_string(class_name)); | |
99 | ||
100 | } | |
101 | ||
102 | // -------------------------------------------------------------------------- | |
103 | // PYTHON::cpp_member_func(char *name, char *iname, DataType *t, ParmList *l) | |
104 | // | |
105 | // Creates a C++ member function | |
106 | // -------------------------------------------------------------------------- | |
107 | ||
108 | void PYTHON::cpp_member_func(char *name, char *iname, DataType *t, ParmList *l) { | |
109 | ||
110 | Parm *p; | |
111 | int i; | |
112 | char *realname; | |
113 | int oldshadow; | |
114 | int pcount; | |
115 | int numopt; | |
116 | int have_optional; | |
117 | ||
118 | String cname = "python:"; | |
119 | String translate = ""; | |
120 | ||
121 | // Create the default member function | |
122 | ||
123 | oldshadow = shadow; // Disable shadowing when wrapping member functions | |
124 | if (shadow) shadow = shadow | PYSHADOW_MEMBER; | |
125 | this->Language::cpp_member_func(name,iname,t,l); | |
126 | shadow = oldshadow; | |
127 | if (shadow) { | |
128 | if (!iname) | |
129 | realname = name; | |
130 | else | |
131 | realname = iname; | |
132 | ||
133 | // Check to see if we've already seen this | |
134 | cname << class_name << "::" << realname; | |
135 | if (add_symbol(cname.get(), 0,0)) { | |
136 | return; // Forget it, already saw it | |
137 | } | |
138 | ||
139 | if (strcmp(realname,"__repr__") == 0) | |
140 | have_repr = 1; | |
141 | ||
142 | // Now add it to the class | |
143 | ||
144 | *pyclass << tab4 << "def " << realname << "(self, *_args, **_kwargs):\n"; | |
145 | // Create a doc string | |
146 | if (docstring && doc_entry) { | |
147 | *pyclass << tab8 << "\"\"\"" << add_docstring(doc_entry) << "\"\"\"\n"; | |
148 | } | |
149 | *pyclass << tab8 << "val = apply(" << module << "." << name_member(realname,class_name) << ",(self,) + _args, _kwargs)\n"; | |
150 | ||
151 | // Check to see if the return type is an object | |
152 | if ((hash.lookup(t->name)) && (t->is_pointer <= 1)) { | |
153 | if (!typemap_check("out",typemap_lang,t,name_member(realname,class_name))) { | |
154 | if (!have_output) { | |
155 | *pyclass << tab8 << "if val: val = " << (char *) hash.lookup(t->name) << "Ptr(val) "; | |
156 | if (((hash.lookup(t->name)) && (t->is_pointer < 1)) || | |
157 | ((hash.lookup(t->name)) && (t->is_pointer == 1) && NewObject)) | |
158 | *pyclass << "; val.thisown = 1\n"; | |
159 | else | |
160 | *pyclass << "\n"; | |
161 | } else { | |
162 | // Do nothing! | |
163 | } | |
164 | } | |
165 | } | |
166 | emitAddPragmas(*pyclass, realname, tab8); | |
167 | *pyclass << tab8 << "return val\n"; | |
168 | ||
169 | // Change the usage string to reflect our shadow class | |
170 | if (doc_entry) { | |
171 | doc_entry->usage = ""; | |
172 | doc_entry->usage << usage_func(realname,t,l); | |
173 | } | |
174 | } | |
175 | } | |
176 | ||
177 | // ----------------------------------------------------------------------------- | |
178 | // void PYTHON::cpp_constructor(char *name, char *iname, ParmList *l) | |
179 | // | |
180 | // Make a constructor for our class | |
181 | // ----------------------------------------------------------------------------- | |
182 | ||
183 | void PYTHON::cpp_constructor(char *name, char *iname, ParmList *l) { | |
184 | char *realname; | |
185 | Parm *p; | |
186 | int i; | |
187 | int oldshadow = shadow; | |
188 | String cname = "python:constructor:"; | |
189 | String translate = ""; | |
190 | int pcount, numopt; | |
191 | int have_optional; | |
192 | ||
193 | if (shadow) shadow = shadow | PYSHADOW_MEMBER; | |
194 | this->Language::cpp_constructor(name,iname,l); | |
195 | shadow = oldshadow; | |
196 | ||
197 | if (shadow) { | |
198 | if (iname) | |
199 | realname = iname; | |
200 | else { | |
201 | if (class_renamed) realname = class_name; | |
202 | else realname = class_name; | |
203 | } | |
204 | ||
205 | // Check to see if we've already seen this | |
206 | cname << class_name << "::" << realname; | |
207 | if (add_symbol(cname.get(), 0,0)) { | |
208 | return; // Forget it, already seen it | |
209 | } | |
210 | ||
211 | if (!have_constructor) { | |
212 | ||
213 | // Create a new constructor | |
214 | ||
215 | *construct << tab4 << "def __init__(self,*_args,**_kwargs):\n"; | |
216 | if (docstring && doc_entry) | |
217 | *construct << tab8 << "\"\"\"" << add_docstring(doc_entry) << "\"\"\"\n"; | |
218 | ||
219 | *construct << tab8 << "self.this = apply(" << module << "." << name_construct(realname) << ",_args,_kwargs)\n"; | |
220 | *construct << tab8 << "self.thisown = 1\n"; | |
221 | emitAddPragmas(*construct,"__init__",tab8); | |
222 | have_constructor = 1; | |
223 | } else { | |
224 | ||
225 | // Hmmm. We seem to be creating a different constructor. We're just going to create a | |
226 | // function for it. | |
227 | ||
228 | *additional << "def " << realname << "(*_args,**_kwargs):\n"; | |
229 | *additional << tab4 << "val = " << class_name << "Ptr(apply(" | |
230 | << module << "." << name_construct(realname) << ",_args,_kwargs))\n" | |
231 | << tab4 << "val.thisown = 1\n"; | |
232 | emitAddPragmas(*additional, realname, tab4); | |
233 | *additional << tab4 << "return val\n\n"; | |
234 | } | |
235 | // Patch up the documentation entry | |
236 | if (doc_entry) { | |
237 | doc_entry->usage = ""; | |
238 | doc_entry->usage << usage_func(class_name,0,l); | |
239 | } | |
240 | } | |
241 | } | |
242 | ||
243 | // ------------------------------------------------------------------------------ | |
244 | // void PYTHON::cpp_destructor(char *name, char *newname) | |
245 | // | |
246 | // Creates a destructor for this object | |
247 | // ------------------------------------------------------------------------------ | |
248 | ||
249 | void PYTHON::cpp_destructor(char *name, char *newname) { | |
250 | char *realname; | |
251 | int oldshadow = shadow; | |
252 | ||
253 | if (shadow) shadow = shadow | PYSHADOW_MEMBER; | |
254 | this->Language::cpp_destructor(name,newname); | |
255 | shadow = oldshadow; | |
256 | if (shadow) { | |
257 | if (newname) realname = newname; | |
258 | else { | |
259 | if (class_renamed) realname = class_name; | |
260 | else realname = name; | |
261 | } | |
262 | ||
263 | *pyclass << tab4 << "def __del__(self," << module << "=" << module << "):\n"; | |
264 | emitAddPragmas(*pyclass,"__del__",tab8); | |
265 | *pyclass << tab8 << "if self.thisown == 1 :\n" | |
266 | << tab8 << tab4 << module << "." << name_destroy(realname) << "(self)\n"; | |
267 | ||
268 | have_destructor = 1; | |
269 | if (doc_entry) { | |
270 | doc_entry->usage = ""; | |
271 | doc_entry->usage << "del this"; | |
272 | } | |
273 | } | |
274 | } | |
275 | ||
276 | // ------------------------------------------------------------------------------- | |
277 | // PYTHON::cpp_close_class() | |
278 | // | |
279 | // Closes a Python class and writes out a wrapper | |
280 | // ------------------------------------------------------------------------------- | |
281 | ||
282 | void PYTHON::cpp_close_class() { | |
283 | String ptrclass; | |
284 | String repr; | |
285 | ||
286 | if (shadow) { | |
287 | ||
288 | if (!have_constructor) { | |
289 | // Build a constructor that takes a pointer to this kind of object | |
290 | *construct << tab4 << "def __init__(self,this):\n"; | |
291 | *construct << tab8 << "self.this = this\n"; | |
292 | } | |
293 | ||
294 | // First, build the pointer base class | |
295 | if (base_class) { | |
296 | ptrclass << "class " << class_name << "Ptr(" << *base_class << "):\n"; | |
297 | } else { | |
298 | ptrclass << "class " << class_name << "Ptr :\n"; | |
299 | } | |
300 | ||
301 | // *getattr << tab8 << "return self.__dict__[name]\n"; | |
302 | *getattr << tab8 << "raise AttributeError,name\n"; | |
303 | *setattr << tab8 << "self.__dict__[name] = value\n"; | |
304 | ||
305 | ptrclass << *cinit | |
306 | << tab4 << "def __init__(self,this):\n" | |
307 | << tab8 << "self.this = this\n" | |
308 | << tab8 << "self.thisown = 0\n"; | |
309 | ||
310 | classes << ptrclass | |
311 | << *pyclass; | |
312 | if (have_setattr) | |
313 | classes << *setattr; | |
314 | if (have_getattr) | |
315 | classes << *getattr; | |
316 | ||
317 | if (!have_repr) { | |
318 | // Supply a repr method for this class | |
319 | repr << tab4 << "def __repr__(self):\n" | |
320 | << tab8 << "return \"<C " << class_name <<" instance at %s>\" % (self.this,)\n"; | |
321 | ||
322 | classes << repr; | |
323 | emitAddPragmas(classes,"__class__",tab4); | |
324 | } | |
325 | ||
326 | // Now build the real class with a normal constructor | |
327 | ||
328 | classes << "class " << class_name << "(" << class_name << "Ptr):\n"; | |
329 | ||
330 | if (docstring && doc_entry) { | |
331 | classes << tab4 << "\"\"\"" << add_docstring(doc_entry) << "\"\"\"\n"; | |
332 | } | |
333 | ||
334 | classes << *construct << "\n\n" | |
335 | << "\n" << *additional << "\n"; | |
336 | ||
337 | delete pyclass; | |
338 | delete setattr; | |
339 | delete getattr; | |
340 | delete additional; | |
341 | } | |
342 | } | |
343 | ||
344 | void PYTHON::cpp_cleanup() { }; | |
345 | ||
346 | void PYTHON::cpp_inherit(char **baseclass,int) { | |
347 | ||
348 | char *bc; | |
349 | int i = 0, first_base = 0; | |
350 | ||
351 | if (!shadow) { | |
352 | this->Language::cpp_inherit(baseclass); | |
353 | return; | |
354 | } | |
355 | ||
356 | // We'll inherit variables and constants, but not methods | |
357 | ||
358 | this->Language::cpp_inherit(baseclass, INHERIT_VAR); | |
359 | ||
360 | if (!baseclass) return; | |
361 | base_class = new String; | |
362 | ||
363 | // Now tell the Python module that we're inheriting from a base class | |
364 | ||
365 | while (baseclass[i]) { | |
366 | bc = (char *) hash.lookup(baseclass[i]); | |
367 | if (bc) { | |
368 | if (first_base) *base_class << ","; | |
369 | *base_class << bc << "Ptr"; | |
370 | first_base = 1; | |
371 | } | |
372 | i++; | |
373 | } | |
374 | if (!first_base) { | |
375 | delete base_class; | |
376 | base_class = 0; | |
377 | } | |
378 | } | |
379 | ||
380 | // -------------------------------------------------------------------------------- | |
381 | // PYTHON::cpp_variable(char *name, char *iname, DataType *t) | |
382 | // | |
383 | // Adds an instance member. | |
384 | // -------------------------------------------------------------------------------- | |
385 | ||
386 | void PYTHON::cpp_variable(char *name, char *iname, DataType *t) { | |
387 | char *realname; | |
388 | int inhash = 0; | |
389 | int oldshadow = shadow; | |
390 | String cname = "python:"; | |
391 | ||
392 | if (shadow) shadow = shadow | PYSHADOW_MEMBER; | |
393 | this->Language::cpp_variable(name,iname,t); | |
394 | shadow = oldshadow; | |
395 | ||
396 | if (shadow) { | |
397 | have_getattr = 1; | |
398 | have_setattr = 1; | |
399 | if (!iname) | |
400 | realname = name; | |
401 | else | |
402 | realname = iname; | |
403 | ||
404 | // Check to see if we've already seen this | |
405 | ||
406 | cname << class_name << "::" << realname; | |
407 | if (add_symbol(cname.get(), 0,0)) { | |
408 | return; // Forget it, already seen it | |
409 | } | |
410 | ||
411 | // Figure out if we've seen this datatype before | |
412 | ||
413 | if ((hash.lookup(t->name)) && (t->is_pointer <= 1)) inhash = 1; | |
414 | ||
415 | // Now write some code to set the variable | |
416 | *setattr << tab8 << "if name == \"" << realname << "\" :\n"; | |
417 | if (inhash) { | |
418 | *setattr << tab8 << tab4 << module << "." << name_set(name_member(realname,class_name)) << "(self,value.this)\n"; | |
419 | } else { | |
420 | *setattr << tab8 << tab4 << module << "." << name_set(name_member(realname,class_name)) << "(self,value)\n"; | |
421 | } | |
422 | *setattr << tab8 << tab4 << "return\n"; | |
423 | ||
424 | // Write some code to get the variable | |
425 | *getattr << tab8 << "if name == \"" << realname << "\" : \n"; | |
426 | if (inhash) { | |
427 | *getattr << tab8 << tab4 << "return " << (char *) hash.lookup(t->name) << "Ptr(" << module << "." | |
428 | << name_get(name_member(realname,class_name)) << "(self))\n"; | |
429 | } else { | |
430 | *getattr << tab8 << tab4 << "return " << module << "." << name_get(name_member(realname,class_name)) << "(self)\n"; | |
431 | } | |
432 | ||
433 | // Patch up ye old documentation entry | |
434 | ||
435 | if (doc_entry) { | |
436 | doc_entry->usage = ""; | |
437 | doc_entry->usage << "self." << realname; | |
438 | } | |
439 | } | |
440 | } | |
441 | ||
442 | // -------------------------------------------------------------------------------- | |
443 | // PYTHON::cpp_declare_const(char *name, char *iname, DataType *type, char *value) | |
444 | // | |
445 | // Add access to a C++ constant | |
446 | // -------------------------------------------------------------------------------- | |
447 | ||
448 | void PYTHON::cpp_declare_const(char *name, char *iname, DataType *type, char *value) { | |
449 | char *realname; | |
450 | int oldshadow = shadow; | |
451 | String cname = "python:"; | |
452 | ||
453 | if (shadow) shadow = shadow | PYSHADOW_MEMBER; | |
454 | this->Language::cpp_declare_const(name,iname,type,value); | |
455 | shadow = oldshadow; | |
456 | ||
457 | if (shadow) { | |
458 | if (!iname) | |
459 | realname = name; | |
460 | else | |
461 | realname = iname; | |
462 | ||
463 | // Check to see if we've already seen this | |
464 | ||
465 | cname << class_name << "::" << realname; | |
466 | if (add_symbol(cname.get(), 0,0)) { | |
467 | return; // Forget it, already seen it | |
468 | } | |
469 | ||
470 | *cinit << tab4 << realname << " = " << module << "." << name_member(realname,class_name) << "\n"; | |
471 | ||
472 | if (doc_entry) { | |
473 | doc_entry->usage = ""; | |
474 | doc_entry->usage << "self." << realname; | |
475 | if (value) { | |
476 | doc_entry->usage << " = " << value; | |
477 | } | |
478 | } | |
479 | } | |
480 | } | |
481 | ||
482 | // -------------------------------------------------------------------------------- | |
483 | // PYTHON::add_typedef(DataType *t, char *name) | |
484 | // | |
485 | // This is called whenever a typedef is encountered. When shadow classes are | |
486 | // used, this function lets us discovered hidden uses of a class. For example : | |
487 | // | |
488 | // struct FooBar { | |
489 | // ... | |
490 | // } | |
491 | // | |
492 | // typedef FooBar *FooBarPtr; | |
493 | // | |
494 | // -------------------------------------------------------------------------------- | |
495 | ||
496 | void PYTHON::add_typedef(DataType *t, char *name) { | |
497 | ||
498 | if (!shadow) return; | |
499 | ||
500 | // First check to see if there aren't too many pointers | |
501 | ||
502 | if (t->is_pointer > 1) return; | |
503 | ||
504 | if (hash.lookup(name)) return; // Already added | |
505 | ||
506 | ||
507 | // Now look up the datatype in our shadow class hash table | |
508 | ||
509 | if (hash.lookup(t->name)) { | |
510 | ||
511 | // Yep. This datatype is in the hash | |
512 | ||
513 | // Put this types 'new' name into the hash | |
514 | ||
515 | hash.add(name,copy_string((char *) hash.lookup(t->name))); | |
516 | } | |
517 | } |