/tags/rel-1-3-26/SWIG/Lib/swig.swg

  1/* -----------------------------------------------------------------------------
  2 * swig.swg
  3 *
  4 * $Header$
  5 *
  6 * Common macro definitions for various SWIG directives.  This file is always 
  7 * included at the top of each input file.
  8 * ----------------------------------------------------------------------------- */
  9
 10/* Deprecated SWIG directives */
 11
 12#define %disabledoc     %warn "104:%disabledoc is deprecated"
 13#define %enabledoc      %warn "105:%enabledoc is deprecated"
 14#define %doconly        %warn "106:%doconly is deprecated"
 15#define %style          %warn "107:%style is deprecated" /##/
 16#define %localstyle     %warn "108:%localstyle is deprecated" /##/
 17#define %title          %warn "109:%title is deprecated" /##/
 18#define %section        %warn "110:%section is deprecated" /##/
 19#define %subsection     %warn "111:%subsection is deprecated" /##/
 20#define %subsubsection  %warn "112:%subsubsection is deprecated" /##/
 21#define %new            %warn "117:%new is deprecated. Use %newobject"
 22#define %text           %insert("null")
 23
 24/* Code insertion directives such as %wrapper %{ ... %} */
 25
 26#define %init        %insert("init")
 27#define %wrapper     %insert("wrapper")
 28#define %header      %insert("header")
 29#define %runtime     %insert("runtime")
 30
 31/* Class extension */
 32
 33#define %addmethods  %warn "113:%addmethods is now %extend" %extend
 34
 35/* %ignore directive */
 36
 37#define %ignore         %rename($ignore)
 38#define %ignorewarn(x)  %rename("$ignore:" x)
 39
 40/* Access control directives */
 41
 42#define %readonly    %warn "114:%readonly is deprecated. Use %immutable; " %feature("immutable");
 43#define %readwrite   %warn "115:%readwrite is deprecated. Use %mutable; " %feature("immutable","");
 44
 45#define %immutable       %feature("immutable")
 46#define %noimmutable     %feature("immutable","0")
 47#define %clearimmutable  %feature("immutable","")
 48#define %mutable         %noimmutable
 49
 50/* Generation of default constructors/destructors */
 51
 52#define %nodefault       %feature("nodefault","1")
 53#define %default         %feature("nodefault","0")
 54#define %clearnodefault  %feature("nodefault","")
 55#define %makedefault     %default
 56
 57/* the %exception directive */
 58
 59#ifdef SWIGCSHARP
 60#define %exception      %feature("except", canthrow=1)
 61#else
 62#define %exception      %feature("except")
 63#endif
 64#define %noexception    %feature("except","0")
 65#define %clearexception %feature("except","")
 66
 67/* the %exceptionclass directive */
 68
 69#define %exceptionclass      %feature("exceptionclass")
 70#define %noexceptionclass    %feature("exceptionclass","0")
 71#define %clearexceptionclass %feature("exceptionclass","")
 72
 73/* the %newobject directive */
 74
 75#define %newobject        %feature("new")
 76#define %nonewobject      %feature("new","0")
 77#define %clearnewobject   %feature("new","")
 78
 79/* the %refobject/%unrefobject directives */
 80
 81#define %refobject         %feature("ref")
 82#define %norefobject       %feature("ref","0")
 83#define %clearrefobject    %feature("ref","")
 84
 85#define %unrefobject       %feature("unref")
 86#define %nounrefobject     %feature("unref","0")
 87#define %clearunrefobject  %feature("unref","")
 88
 89/* Directives for callback functions (experimental) */
 90
 91#define %callback(x)    %feature("callback",`x`)
 92#define %nocallback     %feature("callback","0")
 93#define %clearcallback  %feature("callback","")
 94
 95
 96/* Common features */
 97
 98/* Warnings */
 99#define %warnfilter(...) %feature("warnfilter",`__VA_ARGS__`)
100
101/* Warnings used in typemaps. Macro names are the same as those in swigwarn.h but prefixed by SWIG_. */
102%define SWIG_WARN_TYPEMAP_THREAD_UNSAFE "470:Thread/reentrant unsafe wrapping, consider returning by value instead." %enddef
103
104/* Contract support - Experimental and undocumented */
105
106#define %contract    %feature("contract")
107
108/* Default handling of certain overloaded operators */
109
110#ifdef __cplusplus
111%ignorewarn("350:operator new ignored")     operator new;
112%ignorewarn("351:operator delete ignored")  operator delete;
113%ignorewarn("394:operator new[] ignored")   operator new[];
114%ignorewarn("395:operator delete[] ignored") operator delete[];
115
116/* Smart pointer handling */
117
118%rename(__deref__) *::operator->;
119%rename(__ref__) *::operator*();
120%rename(__ref__) *::operator*() const;
121
122/* Define std namespace */
123namespace std {
124}
125#endif
126
127/* Set up the typemap for handling new return strings */
128
129#ifdef __cplusplus
130%typemap(newfree) char * "delete [] $1;";
131#else
132%typemap(newfree) char * "free($1);";
133#endif
134
135/* Default typemap for handling char * members */
136
137#ifdef __cplusplus
138%typemap(memberin) char * {
139  if ($1) delete [] $1;
140  if ($input) {
141     $1 = ($1_type) (new char[strlen($input)+1]);
142     strcpy((char *) $1,$input);
143  } else {
144     $1 = 0;
145  }
146}
147%typemap(memberin,warning="451:Setting const char * member may leak memory.") const char * {
148  if ($input) {
149     $1 = ($1_type) (new char[strlen($input)+1]);
150     strcpy((char *) $1,$input);
151  } else {
152     $1 = 0;
153  }
154}
155%typemap(globalin) char * {
156  if ($1) delete [] $1;
157  if ($input) {
158     $1 = ($1_type) (new char[strlen($input)+1]);
159     strcpy((char *) $1,$input);
160  } else {
161     $1 = 0;
162  }
163}
164%typemap(globalin,warning="451:Setting const char * variable may leak memory.") const char * {
165  if ($input) {
166     $1 = ($1_type) (new char[strlen($input)+1]);
167     strcpy((char *) $1,$input);
168  } else {
169     $1 = 0;
170  }
171}
172#else
173%typemap(memberin) char * {
174  if ($1) free((char*)$1);
175  if ($input) {
176     $1 = ($1_type) malloc(strlen($input)+1);
177     strcpy((char*)$1,$input);
178  } else {
179     $1 = 0;
180  }
181}
182%typemap(memberin,warning="451:Setting const char * member may leak memory.") const char * {
183  if ($input) {
184     $1 = ($1_type) malloc(strlen($input)+1);
185     strcpy((char*)$1,$input);
186  } else {
187     $1 = 0;
188  }
189}
190%typemap(globalin) char * {
191  if ($1) free((char*)$1);
192  if ($input) {
193     $1 = ($1_type) malloc(strlen($input)+1);
194     strcpy((char*)$1,$input);
195  } else {
196     $1 = 0;
197  }
198}
199%typemap(globalin,warning="451:Setting const char * variable may leak memory.") const char * {
200  if ($input) {
201     $1 = ($1_type) malloc(strlen($input)+1);
202     strcpy((char*)$1,$input);
203  } else {
204     $1 = 0;
205  }
206}
207
208#endif
209
210/* Character array handling */
211
212%typemap(memberin) char [ANY] {
213  if ($input) strncpy($1,$input,$1_dim0);
214  else $1[0] = 0;
215}
216
217%typemap(globalin) char [ANY] {
218  if ($input) strncpy($1,$input,$1_dim0);
219  else $1[0] = 0;
220}
221
222%typemap(memberin) char [] {
223  if ($input) strcpy($1,$input);
224  else $1[0] = 0;
225}
226
227%typemap(globalin) char [] {
228  if ($input) strcpy($1,$input);
229  else $1[0] = 0;
230}
231
232/* memberin/globalin typemap for arrays. */
233
234%typemap(memberin) SWIGTYPE [ANY] {
235  size_t ii;
236  $1_basetype *b = ($1_basetype *) $1;
237  for (ii = 0; ii < (size_t)$1_size; ii++) b[ii] = *(($1_basetype *) $input + ii);
238}
239
240%typemap(globalin) SWIGTYPE [ANY] {
241  size_t ii;
242  $1_basetype *b = ($1_basetype *) $1;
243  for (ii = 0; ii < (size_t)$1_size; ii++) b[ii] = *(($1_basetype *) $input + ii);
244}
245
246/* memberin/globalin typemap for double arrays. */
247
248%typemap(memberin) SWIGTYPE [ANY][ANY] {
249  $basetype (*inp)[$dim1] = ($basetype (*)[$dim1])($input);
250  $basetype (*dest)[$dim1] = ($basetype (*)[$dim1])($1);
251  size_t ii = 0;
252  for (; ii < $dim0; ++ii) {
253    $basetype *ip = inp[ii];
254    $basetype *dp = dest[ii];
255    size_t jj = 0;
256    for (; jj < $dim1; ++jj) dp[jj] = ip[jj];
257  }
258}
259
260%typemap(globalin) SWIGTYPE [ANY][ANY] {
261  $basetype (*inp)[$dim1] = ($basetype (*)[$dim1])($input);
262  $basetype (*dest)[$dim1] = ($basetype (*)[$dim1])($1);
263  size_t ii = 0;
264  for (; ii < $dim0; ++ii) {
265    $basetype *ip = inp[ii];
266    $basetype *dp = dest[ii];
267    size_t jj = 0;
268    for (; jj < $dim1; ++jj) dp[jj] = ip[jj];
269  }
270}
271
272/* Typemap for variable length arguments sentinel value.  Used
273   by the %varargs directive. */
274
275%typemap(in,numinputs=0) SWIGTYPE *VARARGS_SENTINEL, SWIGTYPE VARARGS_SENTINEL "";
276
277
278/*
279 * Function/method overloading support.   This is done through typemaps,
280 * but also involve a precedence level. 
281 */
282
283/* Macro for overload resolution */
284
285#define %typecheck(_x) %typemap(typecheck, precedence=_x)
286
287/* Macros for precedence levels */
288
289%define SWIG_TYPECHECK_POINTER       0     %enddef
290%define SWIG_TYPECHECK_VOIDPTR       10    %enddef
291%define SWIG_TYPECHECK_BOOL          15    %enddef
292%define SWIG_TYPECHECK_UINT8         20    %enddef
293%define SWIG_TYPECHECK_INT8          25    %enddef
294%define SWIG_TYPECHECK_UINT16        30    %enddef
295%define SWIG_TYPECHECK_INT16         35    %enddef
296%define SWIG_TYPECHECK_UINT32        40    %enddef
297%define SWIG_TYPECHECK_INT32         45    %enddef
298%define SWIG_TYPECHECK_UINT64        50    %enddef
299%define SWIG_TYPECHECK_INT64         55    %enddef
300%define SWIG_TYPECHECK_UINT128       60    %enddef
301%define SWIG_TYPECHECK_INT128        65    %enddef
302%define SWIG_TYPECHECK_INTEGER       70    %enddef
303%define SWIG_TYPECHECK_FLOAT         80    %enddef
304%define SWIG_TYPECHECK_DOUBLE        90    %enddef
305%define SWIG_TYPECHECK_CPLXFLT       95    %enddef
306%define SWIG_TYPECHECK_CPLXDBL      100    %enddef
307%define SWIG_TYPECHECK_COMPLEX      105    %enddef
308%define SWIG_TYPECHECK_UNICHAR      110    %enddef
309%define SWIG_TYPECHECK_UNISTRING    120    %enddef
310%define SWIG_TYPECHECK_CHAR         130    %enddef
311%define SWIG_TYPECHECK_STRING       140    %enddef
312%define SWIG_TYPECHECK_PAIR         150    %enddef
313%define SWIG_TYPECHECK_VECTOR       160    %enddef
314%define SWIG_TYPECHECK_DEQUE        170    %enddef
315%define SWIG_TYPECHECK_LIST         180    %enddef
316%define SWIG_TYPECHECK_SET          190    %enddef
317%define SWIG_TYPECHECK_MULTISET     200    %enddef
318%define SWIG_TYPECHECK_MAP          210    %enddef
319%define SWIG_TYPECHECK_MULTIMAP     220    %enddef
320
321%define SWIG_TYPECHECK_BOOL_ARRAY        1015    %enddef
322%define SWIG_TYPECHECK_INT8_ARRAY        1025    %enddef
323%define SWIG_TYPECHECK_INT16_ARRAY       1035    %enddef
324%define SWIG_TYPECHECK_INT32_ARRAY       1045    %enddef
325%define SWIG_TYPECHECK_INT64_ARRAY       1055    %enddef
326%define SWIG_TYPECHECK_INT128_ARRAY      1065    %enddef
327%define SWIG_TYPECHECK_FLOAT_ARRAY       1080    %enddef
328%define SWIG_TYPECHECK_DOUBLE_ARRAY      1090    %enddef
329%define SWIG_TYPECHECK_CHAR_ARRAY        1130    %enddef
330%define SWIG_TYPECHECK_STRING_ARRAY      1140    %enddef
331%define SWIG_TYPECHECK_OBJECT_ARRAY      1150    %enddef
332
333%define SWIG_TYPECHECK_BOOL_PTR          2015    %enddef
334%define SWIG_TYPECHECK_UINT8_PTR         2020    %enddef
335%define SWIG_TYPECHECK_INT8_PTR          2025    %enddef
336%define SWIG_TYPECHECK_UINT16_PTR        2030    %enddef
337%define SWIG_TYPECHECK_INT16_PTR         2035    %enddef
338%define SWIG_TYPECHECK_UINT32_PTR        2040    %enddef
339%define SWIG_TYPECHECK_INT32_PTR         2045    %enddef
340%define SWIG_TYPECHECK_UINT64_PTR        2050    %enddef
341%define SWIG_TYPECHECK_INT64_PTR         2055    %enddef
342%define SWIG_TYPECHECK_FLOAT_PTR         2080    %enddef
343%define SWIG_TYPECHECK_DOUBLE_PTR        2090    %enddef
344%define SWIG_TYPECHECK_CHAR_PTR          2130    %enddef
345
346/*  
347 * This template wrapper is used to handle C++ objects that are passed or 
348 * returned by value.   This is necessary to handle objects that define
349 * no default-constructor (making it difficult for SWIG to properly declare
350 * local variables).
351 *
352 * The wrapper is used as follows.  First consider a function like this:
353 *
354 *      Vector cross_product(Vector a, Vector b)
355 *
356 * Now, if Vector is defined as a C++ class with no default constructor, 
357 * code is generated as follows:
358 *
359 *     Vector *wrap_cross_product(Vector *inarg1, Vector *inarg2) {
360 *          SwigValueWrapper<Vector>  arg1;
361 *          SwigValueWrapper<Vector>  arg2;
362 *          SwigValueWrapper<Vector> result;
363 *
364 *          arg1 = *inarg1;
365 *          arg2 = *inarg2;
366 *          ...            
367 *          result = cross_product(arg1,arg2);
368 *          ...
369 *          return new Vector(result);
370 *    }
371 *         
372 * In the wrappers, the template SwigValueWrapper simply provides a thin
373 * layer around a Vector *.  However, it does this in a way that allows
374 * the object to be bound after the variable declaration (which is not possible
375 * with the bare object when it lacks a default constructor).  
376 *
377 * An observant reader will notice that the code after the variable declarations
378 * is *identical* to the code used for classes that do define default constructors.
379 * Thus, this neat trick allows us to fix this special case without having to
380 * make massive changes to typemaps and other parts of the SWIG code generator.
381 *
382 * Note: this code is not included when SWIG runs in C-mode, when classes
383 * define default constructors, or when pointers and references are used.
384 * SWIG tries to avoid doing this except in very special circumstances.
385 *
386 * Note: This solution suffers from making a large number of copies
387 * of the underlying object.  However, this is needed in the interest of
388 * safety and in order to cover all of the possible ways in which a value
389 * might be assigned.  For example:
390 *
391 *       arg1 = *inarg1;       // Assignment from a pointer
392 *       arg1 = Vector(1,2,3); // Assignment from a value  
393 *
394 * This wrapping technique was suggested by William Fulton and is henceforth
395 * known as the "Fulton Transform" :-).
396 */
397
398#ifdef __cplusplus
399%insert("runtime") %{
400#ifdef __cplusplus
401template<class T> class SwigValueWrapper {
402    T *tt;
403public:
404    SwigValueWrapper() : tt(0) { }
405    SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
406    SwigValueWrapper(const T& t) : tt(new T(t)) { }
407    ~SwigValueWrapper() { delete tt; } 
408    SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
409    operator T&() const { return *tt; }
410    T *operator&() { return tt; }
411private:
412    SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
413};
414#endif
415%}
416#endif
417
418/* Macro for setting a dynamic cast function */
419%define DYNAMIC_CAST(mangle,func)
420%init %{
421   mangle->dcast = (swig_dycast_func) func;
422%}
423%enddef
424
425/*
426
427   This macro performs constant aggregation.  Basically the idea of
428   constant aggregation is that you can group a collection of constants 
429   together.  For example, suppose you have some code like this:
430
431       #define UP  1
432       #define DOWN 2
433       #define LEFT 3
434       #define RIGHT 4
435
436   Now, suppose you had a function like this:
437
438       int move(int direction)
439
440   In this case, you might want to restrict the direction argument to one of the supplied
441   constant names. To do this, you could write some typemap code by hand.  Alternatively,
442   you can use the %aggregate_check macro defined here to create a simple check function
443   for you.  Here is an example:
444
445      %aggregate_check(int, check_direction, UP, DOWN, LEFT, RIGHT);
446
447   Now, using a typemap
448
449       %typemap(check) int direction {
450            if (!check_direction($1)) SWIG_exception(SWIG_ValueError,"Bad direction.");
451       }
452
453   or a contract (better)
454
455       %contract move(int x) {
456       require:
457           check_direction(x);
458       }
459*/
460   
461%define %aggregate_check(TYPE, NAME, FIRST, ...)
462%wrapper %{
463static int NAME(TYPE x) {
464    static  TYPE values[] = { FIRST, ##__VA_ARGS__ };
465    static  int size = sizeof(values);
466    int     i,j;
467    for (i = 0, j = 0; i < size; i+=sizeof(TYPE),j++) {
468        if (x == values[j]) return 1; 
469    }
470    return 0;
471}
472%}
473%enddef
474
475%insert("runtime") "swiglabels.swg"
476
477