PageRenderTime 30ms CodeModel.GetById 17ms app.highlight 5ms RepoModel.GetById 2ms app.codeStats 0ms

/trunk/Lib/swigrun.swg

#
Unknown | 583 lines | 521 code | 62 blank | 0 comment | 0 complexity | 4eb99603eb7e279a8466dc20c757e105 MD5 | raw file
  1/* -----------------------------------------------------------------------------
  2 * swigrun.swg
  3 *
  4 * This file contains generic C API SWIG runtime support for pointer
  5 * type checking.
  6 * ----------------------------------------------------------------------------- */
  7
  8/* This should only be incremented when either the layout of swig_type_info changes,
  9   or for whatever reason, the runtime changes incompatibly */
 10#define SWIG_RUNTIME_VERSION "4"
 11
 12/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
 13#ifdef SWIG_TYPE_TABLE
 14# define SWIG_QUOTE_STRING(x) #x
 15# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
 16# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
 17#else
 18# define SWIG_TYPE_TABLE_NAME
 19#endif
 20
 21/*
 22  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
 23  creating a static or dynamic library from the SWIG runtime code.
 24  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
 25  
 26  But only do this if strictly necessary, ie, if you have problems
 27  with your compiler or suchlike.
 28*/
 29
 30#ifndef SWIGRUNTIME
 31# define SWIGRUNTIME SWIGINTERN
 32#endif
 33
 34#ifndef SWIGRUNTIMEINLINE
 35# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
 36#endif
 37
 38/*  Generic buffer size */
 39#ifndef SWIG_BUFFER_SIZE
 40# define SWIG_BUFFER_SIZE 1024
 41#endif
 42
 43/* Flags for pointer conversions */
 44#define SWIG_POINTER_DISOWN        0x1
 45#define SWIG_CAST_NEW_MEMORY       0x2
 46
 47/* Flags for new pointer objects */
 48#define SWIG_POINTER_OWN           0x1
 49
 50
 51/* 
 52   Flags/methods for returning states.
 53   
 54   The SWIG conversion methods, as ConvertPtr, return an integer 
 55   that tells if the conversion was successful or not. And if not,
 56   an error code can be returned (see swigerrors.swg for the codes).
 57   
 58   Use the following macros/flags to set or process the returning
 59   states.
 60   
 61   In old versions of SWIG, code such as the following was usually written:
 62
 63     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
 64       // success code
 65     } else {
 66       //fail code
 67     }
 68
 69   Now you can be more explicit:
 70
 71    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
 72    if (SWIG_IsOK(res)) {
 73      // success code
 74    } else {
 75      // fail code
 76    }
 77
 78   which is the same really, but now you can also do
 79
 80    Type *ptr;
 81    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
 82    if (SWIG_IsOK(res)) {
 83      // success code
 84      if (SWIG_IsNewObj(res) {
 85        ...
 86	delete *ptr;
 87      } else {
 88        ...
 89      }
 90    } else {
 91      // fail code
 92    }
 93    
 94   I.e., now SWIG_ConvertPtr can return new objects and you can
 95   identify the case and take care of the deallocation. Of course that
 96   also requires SWIG_ConvertPtr to return new result values, such as
 97
 98      int SWIG_ConvertPtr(obj, ptr,...) {         
 99        if (<obj is ok>) {			       
100          if (<need new object>) {		       
101            *ptr = <ptr to new allocated object>; 
102            return SWIG_NEWOBJ;		       
103          } else {				       
104            *ptr = <ptr to old object>;	       
105            return SWIG_OLDOBJ;		       
106          } 				       
107        } else {				       
108          return SWIG_BADOBJ;		       
109        }					       
110      }
111
112   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
113   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
114   SWIG errors code.
115
116   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
117   allows to return the 'cast rank', for example, if you have this
118
119       int food(double)
120       int fooi(int);
121
122   and you call
123 
124      food(1)   // cast rank '1'  (1 -> 1.0)
125      fooi(1)   // cast rank '0'
126
127   just use the SWIG_AddCast()/SWIG_CheckState()
128*/
129
130#define SWIG_OK                    (0) 
131#define SWIG_ERROR                 (-1)
132#define SWIG_IsOK(r)               (r >= 0)
133#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)  
134
135/* The CastRankLimit says how many bits are used for the cast rank */
136#define SWIG_CASTRANKLIMIT         (1 << 8)
137/* The NewMask denotes the object was created (using new/malloc) */
138#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
139/* The TmpMask is for in/out typemaps that use temporal objects */
140#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
141/* Simple returning values */
142#define SWIG_BADOBJ                (SWIG_ERROR)
143#define SWIG_OLDOBJ                (SWIG_OK)
144#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
145#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
146/* Check, add and del mask methods */
147#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
148#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
149#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
150#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
151#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
152#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
153
154/* Cast-Rank Mode */
155#if defined(SWIG_CASTRANK_MODE)
156#  ifndef SWIG_TypeRank
157#    define SWIG_TypeRank             unsigned long
158#  endif
159#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
160#    define SWIG_MAXCASTRANK          (2)
161#  endif
162#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
163#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
164SWIGINTERNINLINE int SWIG_AddCast(int r) { 
165  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
166}
167SWIGINTERNINLINE int SWIG_CheckState(int r) { 
168  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0; 
169}
170#else /* no cast-rank mode */
171#  define SWIG_AddCast
172#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
173#endif
174
175
176#include <string.h>
177
178#ifdef __cplusplus
179extern "C" {
180#endif
181
182typedef void *(*swig_converter_func)(void *, int *);
183typedef struct swig_type_info *(*swig_dycast_func)(void **);
184
185/* Structure to store information on one type */
186typedef struct swig_type_info {
187  const char             *name;			/* mangled name of this type */
188  const char             *str;			/* human readable name of this type */
189  swig_dycast_func        dcast;		/* dynamic cast function down a hierarchy */
190  struct swig_cast_info  *cast;			/* linked list of types that can cast into this type */
191  void                   *clientdata;		/* language specific type data */
192  int                    owndata;		/* flag if the structure owns the clientdata */
193} swig_type_info;
194
195/* Structure to store a type and conversion function used for casting */
196typedef struct swig_cast_info {
197  swig_type_info         *type;			/* pointer to type that is equivalent to this type */
198  swig_converter_func     converter;		/* function to cast the void pointers */
199  struct swig_cast_info  *next;			/* pointer to next cast in linked list */
200  struct swig_cast_info  *prev;			/* pointer to the previous cast */
201} swig_cast_info;
202
203/* Structure used to store module information
204 * Each module generates one structure like this, and the runtime collects
205 * all of these structures and stores them in a circularly linked list.*/
206typedef struct swig_module_info {
207  swig_type_info         **types;		/* Array of pointers to swig_type_info structures that are in this module */
208  size_t                 size;		        /* Number of types in this module */
209  struct swig_module_info *next;		/* Pointer to next element in circularly linked list */
210  swig_type_info         **type_initial;	/* Array of initially generated type structures */
211  swig_cast_info         **cast_initial;	/* Array of initially generated casting structures */
212  void                    *clientdata;		/* Language specific module data */
213} swig_module_info;
214
215/* 
216  Compare two type names skipping the space characters, therefore
217  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
218
219  Return 0 when the two name types are equivalent, as in
220  strncmp, but skipping ' '.
221*/
222SWIGRUNTIME int
223SWIG_TypeNameComp(const char *f1, const char *l1,
224		  const char *f2, const char *l2) {
225  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
226    while ((*f1 == ' ') && (f1 != l1)) ++f1;
227    while ((*f2 == ' ') && (f2 != l2)) ++f2;
228    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
229  }
230  return (int)((l1 - f1) - (l2 - f2));
231}
232
233/*
234  Check type equivalence in a name list like <name1>|<name2>|...
235  Return 0 if not equal, 1 if equal
236*/
237SWIGRUNTIME int
238SWIG_TypeEquiv(const char *nb, const char *tb) {
239  int equiv = 0;
240  const char* te = tb + strlen(tb);
241  const char* ne = nb;
242  while (!equiv && *ne) {
243    for (nb = ne; *ne; ++ne) {
244      if (*ne == '|') break;
245    }
246    equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
247    if (*ne) ++ne;
248  }
249  return equiv;
250}
251
252/*
253  Check type equivalence in a name list like <name1>|<name2>|...
254  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
255*/
256SWIGRUNTIME int
257SWIG_TypeCompare(const char *nb, const char *tb) {
258  int equiv = 0;
259  const char* te = tb + strlen(tb);
260  const char* ne = nb;
261  while (!equiv && *ne) {
262    for (nb = ne; *ne; ++ne) {
263      if (*ne == '|') break;
264    }
265    equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
266    if (*ne) ++ne;
267  }
268  return equiv;
269}
270
271
272/*
273  Check the typename
274*/
275SWIGRUNTIME swig_cast_info *
276SWIG_TypeCheck(const char *c, swig_type_info *ty) {
277  if (ty) {
278    swig_cast_info *iter = ty->cast;
279    while (iter) {
280      if (strcmp(iter->type->name, c) == 0) {
281        if (iter == ty->cast)
282          return iter;
283        /* Move iter to the top of the linked list */
284        iter->prev->next = iter->next;
285        if (iter->next)
286          iter->next->prev = iter->prev;
287        iter->next = ty->cast;
288        iter->prev = 0;
289        if (ty->cast) ty->cast->prev = iter;
290        ty->cast = iter;
291        return iter;
292      }
293      iter = iter->next;
294    }
295  }
296  return 0;
297}
298
299/* 
300  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
301*/
302SWIGRUNTIME swig_cast_info *
303SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
304  if (ty) {
305    swig_cast_info *iter = ty->cast;
306    while (iter) {
307      if (iter->type == from) {
308        if (iter == ty->cast)
309          return iter;
310        /* Move iter to the top of the linked list */
311        iter->prev->next = iter->next;
312        if (iter->next)
313          iter->next->prev = iter->prev;
314        iter->next = ty->cast;
315        iter->prev = 0;
316        if (ty->cast) ty->cast->prev = iter;
317        ty->cast = iter;
318        return iter;
319      }
320      iter = iter->next;
321    }
322  }
323  return 0;
324}
325
326/*
327  Cast a pointer up an inheritance hierarchy
328*/
329SWIGRUNTIMEINLINE void *
330SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
331  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
332}
333
334/* 
335   Dynamic pointer casting. Down an inheritance hierarchy
336*/
337SWIGRUNTIME swig_type_info *
338SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
339  swig_type_info *lastty = ty;
340  if (!ty || !ty->dcast) return ty;
341  while (ty && (ty->dcast)) {
342    ty = (*ty->dcast)(ptr);
343    if (ty) lastty = ty;
344  }
345  return lastty;
346}
347
348/*
349  Return the name associated with this type
350*/
351SWIGRUNTIMEINLINE const char *
352SWIG_TypeName(const swig_type_info *ty) {
353  return ty->name;
354}
355
356/*
357  Return the pretty name associated with this type,
358  that is an unmangled type name in a form presentable to the user.
359*/
360SWIGRUNTIME const char *
361SWIG_TypePrettyName(const swig_type_info *type) {
362  /* The "str" field contains the equivalent pretty names of the
363     type, separated by vertical-bar characters.  We choose
364     to print the last name, as it is often (?) the most
365     specific. */
366  if (!type) return NULL;
367  if (type->str != NULL) {
368    const char *last_name = type->str;
369    const char *s;
370    for (s = type->str; *s; s++)
371      if (*s == '|') last_name = s+1;
372    return last_name;
373  }
374  else
375    return type->name;
376}
377
378/* 
379   Set the clientdata field for a type
380*/
381SWIGRUNTIME void
382SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
383  swig_cast_info *cast = ti->cast;
384  /* if (ti->clientdata == clientdata) return; */
385  ti->clientdata = clientdata;
386  
387  while (cast) {
388    if (!cast->converter) {
389      swig_type_info *tc = cast->type;
390      if (!tc->clientdata) {
391	SWIG_TypeClientData(tc, clientdata);
392      }
393    }    
394    cast = cast->next;
395  }
396}
397SWIGRUNTIME void
398SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
399  SWIG_TypeClientData(ti, clientdata);
400  ti->owndata = 1;
401}
402  
403/*
404  Search for a swig_type_info structure only by mangled name
405  Search is a O(log #types)
406  
407  We start searching at module start, and finish searching when start == end.  
408  Note: if start == end at the beginning of the function, we go all the way around
409  the circular list.
410*/
411SWIGRUNTIME swig_type_info *
412SWIG_MangledTypeQueryModule(swig_module_info *start, 
413                            swig_module_info *end, 
414		            const char *name) {
415  swig_module_info *iter = start;
416  do {
417    if (iter->size) {
418      register size_t l = 0;
419      register size_t r = iter->size - 1;
420      do {
421	/* since l+r >= 0, we can (>> 1) instead (/ 2) */
422	register size_t i = (l + r) >> 1; 
423	const char *iname = iter->types[i]->name;
424	if (iname) {
425	  register int compare = strcmp(name, iname);
426	  if (compare == 0) {	    
427	    return iter->types[i];
428	  } else if (compare < 0) {
429	    if (i) {
430	      r = i - 1;
431	    } else {
432	      break;
433	    }
434	  } else if (compare > 0) {
435	    l = i + 1;
436	  }
437	} else {
438	  break; /* should never happen */
439	}
440      } while (l <= r);
441    }
442    iter = iter->next;
443  } while (iter != end);
444  return 0;
445}
446
447/*
448  Search for a swig_type_info structure for either a mangled name or a human readable name.
449  It first searches the mangled names of the types, which is a O(log #types)
450  If a type is not found it then searches the human readable names, which is O(#types).
451  
452  We start searching at module start, and finish searching when start == end.  
453  Note: if start == end at the beginning of the function, we go all the way around
454  the circular list.
455*/
456SWIGRUNTIME swig_type_info *
457SWIG_TypeQueryModule(swig_module_info *start, 
458                     swig_module_info *end, 
459		     const char *name) {
460  /* STEP 1: Search the name field using binary search */
461  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
462  if (ret) {
463    return ret;
464  } else {
465    /* STEP 2: If the type hasn't been found, do a complete search
466       of the str field (the human readable name) */
467    swig_module_info *iter = start;
468    do {
469      register size_t i = 0;
470      for (; i < iter->size; ++i) {
471	if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
472	  return iter->types[i];
473      }
474      iter = iter->next;
475    } while (iter != end);
476  }
477  
478  /* neither found a match */
479  return 0;
480}
481
482/* 
483   Pack binary data into a string
484*/
485SWIGRUNTIME char *
486SWIG_PackData(char *c, void *ptr, size_t sz) {
487  static const char hex[17] = "0123456789abcdef";
488  register const unsigned char *u = (unsigned char *) ptr;
489  register const unsigned char *eu =  u + sz;
490  for (; u != eu; ++u) {
491    register unsigned char uu = *u;
492    *(c++) = hex[(uu & 0xf0) >> 4];
493    *(c++) = hex[uu & 0xf];
494  }
495  return c;
496}
497
498/* 
499   Unpack binary data from a string
500*/
501SWIGRUNTIME const char *
502SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
503  register unsigned char *u = (unsigned char *) ptr;
504  register const unsigned char *eu = u + sz;
505  for (; u != eu; ++u) {
506    register char d = *(c++);
507    register unsigned char uu;
508    if ((d >= '0') && (d <= '9'))
509      uu = ((d - '0') << 4);
510    else if ((d >= 'a') && (d <= 'f'))
511      uu = ((d - ('a'-10)) << 4);
512    else 
513      return (char *) 0;
514    d = *(c++);
515    if ((d >= '0') && (d <= '9'))
516      uu |= (d - '0');
517    else if ((d >= 'a') && (d <= 'f'))
518      uu |= (d - ('a'-10));
519    else 
520      return (char *) 0;
521    *u = uu;
522  }
523  return c;
524}
525
526/* 
527   Pack 'void *' into a string buffer.
528*/
529SWIGRUNTIME char *
530SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
531  char *r = buff;
532  if ((2*sizeof(void *) + 2) > bsz) return 0;
533  *(r++) = '_';
534  r = SWIG_PackData(r,&ptr,sizeof(void *));
535  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
536  strcpy(r,name);
537  return buff;
538}
539
540SWIGRUNTIME const char *
541SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
542  if (*c != '_') {
543    if (strcmp(c,"NULL") == 0) {
544      *ptr = (void *) 0;
545      return name;
546    } else {
547      return 0;
548    }
549  }
550  return SWIG_UnpackData(++c,ptr,sizeof(void *));
551}
552
553SWIGRUNTIME char *
554SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
555  char *r = buff;
556  size_t lname = (name ? strlen(name) : 0);
557  if ((2*sz + 2 + lname) > bsz) return 0;
558  *(r++) = '_';
559  r = SWIG_PackData(r,ptr,sz);
560  if (lname) {
561    strncpy(r,name,lname+1);
562  } else {
563    *r = 0;
564  }
565  return buff;
566}
567
568SWIGRUNTIME const char *
569SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
570  if (*c != '_') {
571    if (strcmp(c,"NULL") == 0) {
572      memset(ptr,0,sz);
573      return name;
574    } else {
575      return 0;
576    }
577  }
578  return SWIG_UnpackData(++c,ptr,sz);
579}
580
581#ifdef __cplusplus
582}
583#endif