source: trunk/base/src/machista1.0/machista_wrap.c @ 138968

Last change on this file since 138968 was 138968, checked in by raimue@…, 5 years ago

machista: Ignore warnings about missing initializers in the code generated by SWIG

  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 87.0 KB
Line 
1/*
2 * Non-generated MacPorts addition:
3 * Ignore these warnings in the generated SWIG code below.
4 *
5 * Please retain these #pragmas when regenerating the file!
6 */
7#pragma GCC   diagnostic ignored "-Wmissing-field-initializers"
8#pragma clang diagnostic ignored "-Wmissing-field-initializers"
9
10/* ----------------------------------------------------------------------------
11 * This file was automatically generated by SWIG (http://www.swig.org).
12 * Version 3.0.5
13 *
14 * This file is not intended to be easily readable and contains a number of
15 * coding conventions designed to improve portability and efficiency. Do not make
16 * changes to this file unless you know what you are doing--modify the SWIG
17 * interface file instead.
18 * ----------------------------------------------------------------------------- */
19
20#define SWIGTCL
21
22/* -----------------------------------------------------------------------------
23 *  This section contains generic SWIG labels for method/variable
24 *  declarations/attributes, and other compiler dependent labels.
25 * ----------------------------------------------------------------------------- */
26
27/* template workaround for compilers that cannot correctly implement the C++ standard */
28#ifndef SWIGTEMPLATEDISAMBIGUATOR
29# if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
30#  define SWIGTEMPLATEDISAMBIGUATOR template
31# elif defined(__HP_aCC)
32/* Needed even with `aCC -AA' when `aCC -V' reports HP ANSI C++ B3910B A.03.55 */
33/* If we find a maximum version that requires this, the test would be __HP_aCC <= 35500 for A.03.55 */
34#  define SWIGTEMPLATEDISAMBIGUATOR template
35# else
36#  define SWIGTEMPLATEDISAMBIGUATOR
37# endif
38#endif
39
40/* inline attribute */
41#ifndef SWIGINLINE
42# if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
43#   define SWIGINLINE inline
44# else
45#   define SWIGINLINE
46# endif
47#endif
48
49/* attribute recognised by some compilers to avoid 'unused' warnings */
50#ifndef SWIGUNUSED
51# if defined(__GNUC__)
52#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
53#     define SWIGUNUSED __attribute__ ((__unused__))
54#   else
55#     define SWIGUNUSED
56#   endif
57# elif defined(__ICC)
58#   define SWIGUNUSED __attribute__ ((__unused__))
59# else
60#   define SWIGUNUSED
61# endif
62#endif
63
64#ifndef SWIG_MSC_UNSUPPRESS_4505
65# if defined(_MSC_VER)
66#   pragma warning(disable : 4505) /* unreferenced local function has been removed */
67# endif
68#endif
69
70#ifndef SWIGUNUSEDPARM
71# ifdef __cplusplus
72#   define SWIGUNUSEDPARM(p)
73# else
74#   define SWIGUNUSEDPARM(p) p SWIGUNUSED
75# endif
76#endif
77
78/* internal SWIG method */
79#ifndef SWIGINTERN
80# define SWIGINTERN static SWIGUNUSED
81#endif
82
83/* internal inline SWIG method */
84#ifndef SWIGINTERNINLINE
85# define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
86#endif
87
88/* exporting methods */
89#if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
90#  ifndef GCC_HASCLASSVISIBILITY
91#    define GCC_HASCLASSVISIBILITY
92#  endif
93#endif
94
95#ifndef SWIGEXPORT
96# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
97#   if defined(STATIC_LINKED)
98#     define SWIGEXPORT
99#   else
100#     define SWIGEXPORT __declspec(dllexport)
101#   endif
102# else
103#   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
104#     define SWIGEXPORT __attribute__ ((visibility("default")))
105#   else
106#     define SWIGEXPORT
107#   endif
108# endif
109#endif
110
111/* calling conventions for Windows */
112#ifndef SWIGSTDCALL
113# if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
114#   define SWIGSTDCALL __stdcall
115# else
116#   define SWIGSTDCALL
117# endif
118#endif
119
120/* Deal with Microsoft's attempt at deprecating C standard runtime functions */
121#if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
122# define _CRT_SECURE_NO_DEPRECATE
123#endif
124
125/* Deal with Microsoft's attempt at deprecating methods in the standard C++ library */
126#if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
127# define _SCL_SECURE_NO_DEPRECATE
128#endif
129
130
131
132#include <stdio.h>
133#include <tcl.h>
134#include <errno.h>
135#include <stdlib.h>
136#include <stdarg.h>
137#include <ctype.h>
138
139/* -----------------------------------------------------------------------------
140 * swigrun.swg
141 *
142 * This file contains generic C API SWIG runtime support for pointer
143 * type checking.
144 * ----------------------------------------------------------------------------- */
145
146/* This should only be incremented when either the layout of swig_type_info changes,
147   or for whatever reason, the runtime changes incompatibly */
148#define SWIG_RUNTIME_VERSION "4"
149
150/* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
151#ifdef SWIG_TYPE_TABLE
152# define SWIG_QUOTE_STRING(x) #x
153# define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
154# define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
155#else
156# define SWIG_TYPE_TABLE_NAME
157#endif
158
159/*
160  You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
161  creating a static or dynamic library from the SWIG runtime code.
162  In 99.9% of the cases, SWIG just needs to declare them as 'static'.
163
164  But only do this if strictly necessary, ie, if you have problems
165  with your compiler or suchlike.
166*/
167
168#ifndef SWIGRUNTIME
169# define SWIGRUNTIME SWIGINTERN
170#endif
171
172#ifndef SWIGRUNTIMEINLINE
173# define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
174#endif
175
176/*  Generic buffer size */
177#ifndef SWIG_BUFFER_SIZE
178# define SWIG_BUFFER_SIZE 1024
179#endif
180
181/* Flags for pointer conversions */
182#define SWIG_POINTER_DISOWN        0x1
183#define SWIG_CAST_NEW_MEMORY       0x2
184
185/* Flags for new pointer objects */
186#define SWIG_POINTER_OWN           0x1
187
188
189/*
190   Flags/methods for returning states.
191
192   The SWIG conversion methods, as ConvertPtr, return an integer
193   that tells if the conversion was successful or not. And if not,
194   an error code can be returned (see swigerrors.swg for the codes).
195
196   Use the following macros/flags to set or process the returning
197   states.
198
199   In old versions of SWIG, code such as the following was usually written:
200
201     if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
202       // success code
203     } else {
204       //fail code
205     }
206
207   Now you can be more explicit:
208
209    int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
210    if (SWIG_IsOK(res)) {
211      // success code
212    } else {
213      // fail code
214    }
215
216   which is the same really, but now you can also do
217
218    Type *ptr;
219    int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
220    if (SWIG_IsOK(res)) {
221      // success code
222      if (SWIG_IsNewObj(res) {
223        ...
224        delete *ptr;
225      } else {
226        ...
227      }
228    } else {
229      // fail code
230    }
231
232   I.e., now SWIG_ConvertPtr can return new objects and you can
233   identify the case and take care of the deallocation. Of course that
234   also requires SWIG_ConvertPtr to return new result values, such as
235
236      int SWIG_ConvertPtr(obj, ptr,...) {
237        if (<obj is ok>) {
238          if (<need new object>) {
239            *ptr = <ptr to new allocated object>;
240            return SWIG_NEWOBJ;
241          } else {
242            *ptr = <ptr to old object>;
243            return SWIG_OLDOBJ;
244          }
245        } else {
246          return SWIG_BADOBJ;
247        }
248      }
249
250   Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
251   more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
252   SWIG errors code.
253
254   Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
255   allows to return the 'cast rank', for example, if you have this
256
257       int food(double)
258       int fooi(int);
259
260   and you call
261
262      food(1)   // cast rank '1'  (1 -> 1.0)
263      fooi(1)   // cast rank '0'
264
265   just use the SWIG_AddCast()/SWIG_CheckState()
266*/
267
268#define SWIG_OK                    (0)
269#define SWIG_ERROR                 (-1)
270#define SWIG_IsOK(r)               (r >= 0)
271#define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
272
273/* The CastRankLimit says how many bits are used for the cast rank */
274#define SWIG_CASTRANKLIMIT         (1 << 8)
275/* The NewMask denotes the object was created (using new/malloc) */
276#define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
277/* The TmpMask is for in/out typemaps that use temporal objects */
278#define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
279/* Simple returning values */
280#define SWIG_BADOBJ                (SWIG_ERROR)
281#define SWIG_OLDOBJ                (SWIG_OK)
282#define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
283#define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
284/* Check, add and del mask methods */
285#define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
286#define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
287#define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
288#define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
289#define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
290#define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
291
292/* Cast-Rank Mode */
293#if defined(SWIG_CASTRANK_MODE)
294#  ifndef SWIG_TypeRank
295#    define SWIG_TypeRank             unsigned long
296#  endif
297#  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
298#    define SWIG_MAXCASTRANK          (2)
299#  endif
300#  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
301#  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
302SWIGINTERNINLINE int SWIG_AddCast(int r) {
303  return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
304}
305SWIGINTERNINLINE int SWIG_CheckState(int r) {
306  return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
307}
308#else /* no cast-rank mode */
309#  define SWIG_AddCast(r) (r)
310#  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
311#endif
312
313
314#include <string.h>
315
316#ifdef __cplusplus
317extern "C" {
318#endif
319
320typedef void *(*swig_converter_func)(void *, int *);
321typedef struct swig_type_info *(*swig_dycast_func)(void **);
322
323/* Structure to store information on one type */
324typedef struct swig_type_info {
325  const char             *name;                 /* mangled name of this type */
326  const char             *str;                  /* human readable name of this type */
327  swig_dycast_func        dcast;                /* dynamic cast function down a hierarchy */
328  struct swig_cast_info  *cast;                 /* linked list of types that can cast into this type */
329  void                   *clientdata;           /* language specific type data */
330  int                    owndata;               /* flag if the structure owns the clientdata */
331} swig_type_info;
332
333/* Structure to store a type and conversion function used for casting */
334typedef struct swig_cast_info {
335  swig_type_info         *type;                 /* pointer to type that is equivalent to this type */
336  swig_converter_func     converter;            /* function to cast the void pointers */
337  struct swig_cast_info  *next;                 /* pointer to next cast in linked list */
338  struct swig_cast_info  *prev;                 /* pointer to the previous cast */
339} swig_cast_info;
340
341/* Structure used to store module information
342 * Each module generates one structure like this, and the runtime collects
343 * all of these structures and stores them in a circularly linked list.*/
344typedef struct swig_module_info {
345  swig_type_info         **types;               /* Array of pointers to swig_type_info structures that are in this module */
346  size_t                 size;                  /* Number of types in this module */
347  struct swig_module_info *next;                /* Pointer to next element in circularly linked list */
348  swig_type_info         **type_initial;        /* Array of initially generated type structures */
349  swig_cast_info         **cast_initial;        /* Array of initially generated casting structures */
350  void                    *clientdata;          /* Language specific module data */
351} swig_module_info;
352
353/*
354  Compare two type names skipping the space characters, therefore
355  "char*" == "char *" and "Class<int>" == "Class<int >", etc.
356
357  Return 0 when the two name types are equivalent, as in
358  strncmp, but skipping ' '.
359*/
360SWIGRUNTIME int
361SWIG_TypeNameComp(const char *f1, const char *l1,
362                  const char *f2, const char *l2) {
363  for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
364    while ((*f1 == ' ') && (f1 != l1)) ++f1;
365    while ((*f2 == ' ') && (f2 != l2)) ++f2;
366    if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
367  }
368  return (int)((l1 - f1) - (l2 - f2));
369}
370
371/*
372  Check type equivalence in a name list like <name1>|<name2>|...
373  Return 0 if equal, -1 if nb < tb, 1 if nb > tb
374*/
375SWIGRUNTIME int
376SWIG_TypeCmp(const char *nb, const char *tb) {
377  int equiv = 1;
378  const char* te = tb + strlen(tb);
379  const char* ne = nb;
380  while (equiv != 0 && *ne) {
381    for (nb = ne; *ne; ++ne) {
382      if (*ne == '|') break;
383    }
384    equiv = SWIG_TypeNameComp(nb, ne, tb, te);
385    if (*ne) ++ne;
386  }
387  return equiv;
388}
389
390/*
391  Check type equivalence in a name list like <name1>|<name2>|...
392  Return 0 if not equal, 1 if equal
393*/
394SWIGRUNTIME int
395SWIG_TypeEquiv(const char *nb, const char *tb) {
396  return SWIG_TypeCmp(nb, tb) == 0 ? 1 : 0;
397}
398
399/*
400  Check the typename
401*/
402SWIGRUNTIME swig_cast_info *
403SWIG_TypeCheck(const char *c, swig_type_info *ty) {
404  if (ty) {
405    swig_cast_info *iter = ty->cast;
406    while (iter) {
407      if (strcmp(iter->type->name, c) == 0) {
408        if (iter == ty->cast)
409          return iter;
410        /* Move iter to the top of the linked list */
411        iter->prev->next = iter->next;
412        if (iter->next)
413          iter->next->prev = iter->prev;
414        iter->next = ty->cast;
415        iter->prev = 0;
416        if (ty->cast) ty->cast->prev = iter;
417        ty->cast = iter;
418        return iter;
419      }
420      iter = iter->next;
421    }
422  }
423  return 0;
424}
425
426/*
427  Identical to SWIG_TypeCheck, except strcmp is replaced with a pointer comparison
428*/
429SWIGRUNTIME swig_cast_info *
430SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *ty) {
431  if (ty) {
432    swig_cast_info *iter = ty->cast;
433    while (iter) {
434      if (iter->type == from) {
435        if (iter == ty->cast)
436          return iter;
437        /* Move iter to the top of the linked list */
438        iter->prev->next = iter->next;
439        if (iter->next)
440          iter->next->prev = iter->prev;
441        iter->next = ty->cast;
442        iter->prev = 0;
443        if (ty->cast) ty->cast->prev = iter;
444        ty->cast = iter;
445        return iter;
446      }
447      iter = iter->next;
448    }
449  }
450  return 0;
451}
452
453/*
454  Cast a pointer up an inheritance hierarchy
455*/
456SWIGRUNTIMEINLINE void *
457SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
458  return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
459}
460
461/*
462   Dynamic pointer casting. Down an inheritance hierarchy
463*/
464SWIGRUNTIME swig_type_info *
465SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
466  swig_type_info *lastty = ty;
467  if (!ty || !ty->dcast) return ty;
468  while (ty && (ty->dcast)) {
469    ty = (*ty->dcast)(ptr);
470    if (ty) lastty = ty;
471  }
472  return lastty;
473}
474
475/*
476  Return the name associated with this type
477*/
478SWIGRUNTIMEINLINE const char *
479SWIG_TypeName(const swig_type_info *ty) {
480  return ty->name;
481}
482
483/*
484  Return the pretty name associated with this type,
485  that is an unmangled type name in a form presentable to the user.
486*/
487SWIGRUNTIME const char *
488SWIG_TypePrettyName(const swig_type_info *type) {
489  /* The "str" field contains the equivalent pretty names of the
490     type, separated by vertical-bar characters.  We choose
491     to print the last name, as it is often (?) the most
492     specific. */
493  if (!type) return NULL;
494  if (type->str != NULL) {
495    const char *last_name = type->str;
496    const char *s;
497    for (s = type->str; *s; s++)
498      if (*s == '|') last_name = s+1;
499    return last_name;
500  }
501  else
502    return type->name;
503}
504
505/*
506   Set the clientdata field for a type
507*/
508SWIGRUNTIME void
509SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
510  swig_cast_info *cast = ti->cast;
511  /* if (ti->clientdata == clientdata) return; */
512  ti->clientdata = clientdata;
513
514  while (cast) {
515    if (!cast->converter) {
516      swig_type_info *tc = cast->type;
517      if (!tc->clientdata) {
518        SWIG_TypeClientData(tc, clientdata);
519      }
520    }
521    cast = cast->next;
522  }
523}
524SWIGRUNTIME void
525SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
526  SWIG_TypeClientData(ti, clientdata);
527  ti->owndata = 1;
528}
529
530/*
531  Search for a swig_type_info structure only by mangled name
532  Search is a O(log #types)
533
534  We start searching at module start, and finish searching when start == end.
535  Note: if start == end at the beginning of the function, we go all the way around
536  the circular list.
537*/
538SWIGRUNTIME swig_type_info *
539SWIG_MangledTypeQueryModule(swig_module_info *start,
540                            swig_module_info *end,
541                            const char *name) {
542  swig_module_info *iter = start;
543  do {
544    if (iter->size) {
545      size_t l = 0;
546      size_t r = iter->size - 1;
547      do {
548        /* since l+r >= 0, we can (>> 1) instead (/ 2) */
549        size_t i = (l + r) >> 1;
550        const char *iname = iter->types[i]->name;
551        if (iname) {
552          int compare = strcmp(name, iname);
553          if (compare == 0) {
554            return iter->types[i];
555          } else if (compare < 0) {
556            if (i) {
557              r = i - 1;
558            } else {
559              break;
560            }
561          } else if (compare > 0) {
562            l = i + 1;
563          }
564        } else {
565          break; /* should never happen */
566        }
567      } while (l <= r);
568    }
569    iter = iter->next;
570  } while (iter != end);
571  return 0;
572}
573
574/*
575  Search for a swig_type_info structure for either a mangled name or a human readable name.
576  It first searches the mangled names of the types, which is a O(log #types)
577  If a type is not found it then searches the human readable names, which is O(#types).
578
579  We start searching at module start, and finish searching when start == end.
580  Note: if start == end at the beginning of the function, we go all the way around
581  the circular list.
582*/
583SWIGRUNTIME swig_type_info *
584SWIG_TypeQueryModule(swig_module_info *start,
585                     swig_module_info *end,
586                     const char *name) {
587  /* STEP 1: Search the name field using binary search */
588  swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
589  if (ret) {
590    return ret;
591  } else {
592    /* STEP 2: If the type hasn't been found, do a complete search
593       of the str field (the human readable name) */
594    swig_module_info *iter = start;
595    do {
596      size_t i = 0;
597      for (; i < iter->size; ++i) {
598        if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
599          return iter->types[i];
600      }
601      iter = iter->next;
602    } while (iter != end);
603  }
604
605  /* neither found a match */
606  return 0;
607}
608
609/*
610   Pack binary data into a string
611*/
612SWIGRUNTIME char *
613SWIG_PackData(char *c, void *ptr, size_t sz) {
614  static const char hex[17] = "0123456789abcdef";
615  const unsigned char *u = (unsigned char *) ptr;
616  const unsigned char *eu =  u + sz;
617  for (; u != eu; ++u) {
618    unsigned char uu = *u;
619    *(c++) = hex[(uu & 0xf0) >> 4];
620    *(c++) = hex[uu & 0xf];
621  }
622  return c;
623}
624
625/*
626   Unpack binary data from a string
627*/
628SWIGRUNTIME const char *
629SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
630  unsigned char *u = (unsigned char *) ptr;
631  const unsigned char *eu = u + sz;
632  for (; u != eu; ++u) {
633    char d = *(c++);
634    unsigned char uu;
635    if ((d >= '0') && (d <= '9'))
636      uu = ((d - '0') << 4);
637    else if ((d >= 'a') && (d <= 'f'))
638      uu = ((d - ('a'-10)) << 4);
639    else
640      return (char *) 0;
641    d = *(c++);
642    if ((d >= '0') && (d <= '9'))
643      uu |= (d - '0');
644    else if ((d >= 'a') && (d <= 'f'))
645      uu |= (d - ('a'-10));
646    else
647      return (char *) 0;
648    *u = uu;
649  }
650  return c;
651}
652
653/*
654   Pack 'void *' into a string buffer.
655*/
656SWIGRUNTIME char *
657SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
658  char *r = buff;
659  if ((2*sizeof(void *) + 2) > bsz) return 0;
660  *(r++) = '_';
661  r = SWIG_PackData(r,&ptr,sizeof(void *));
662  if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
663  strcpy(r,name);
664  return buff;
665}
666
667SWIGRUNTIME const char *
668SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
669  if (*c != '_') {
670    if (strcmp(c,"NULL") == 0) {
671      *ptr = (void *) 0;
672      return name;
673    } else {
674      return 0;
675    }
676  }
677  return SWIG_UnpackData(++c,ptr,sizeof(void *));
678}
679
680SWIGRUNTIME char *
681SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
682  char *r = buff;
683  size_t lname = (name ? strlen(name) : 0);
684  if ((2*sz + 2 + lname) > bsz) return 0;
685  *(r++) = '_';
686  r = SWIG_PackData(r,ptr,sz);
687  if (lname) {
688    strncpy(r,name,lname+1);
689  } else {
690    *r = 0;
691  }
692  return buff;
693}
694
695SWIGRUNTIME const char *
696SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
697  if (*c != '_') {
698    if (strcmp(c,"NULL") == 0) {
699      memset(ptr,0,sz);
700      return name;
701    } else {
702      return 0;
703    }
704  }
705  return SWIG_UnpackData(++c,ptr,sz);
706}
707
708#ifdef __cplusplus
709}
710#endif
711
712/*  Errors in SWIG */
713#define  SWIG_UnknownError         -1
714#define  SWIG_IOError              -2
715#define  SWIG_RuntimeError         -3
716#define  SWIG_IndexError           -4
717#define  SWIG_TypeError            -5
718#define  SWIG_DivisionByZero       -6
719#define  SWIG_OverflowError        -7
720#define  SWIG_SyntaxError          -8
721#define  SWIG_ValueError           -9
722#define  SWIG_SystemError          -10
723#define  SWIG_AttributeError       -11
724#define  SWIG_MemoryError          -12
725#define  SWIG_NullReferenceError   -13
726
727
728
729/* -----------------------------------------------------------------------------
730 * error manipulation
731 * ----------------------------------------------------------------------------- */
732
733SWIGINTERN const char*
734SWIG_Tcl_ErrorType(int code) {
735  const char* type = 0;
736  switch(code) {
737  case SWIG_MemoryError:
738    type = "MemoryError";
739    break;
740  case SWIG_IOError:
741    type = "IOError";
742    break;
743  case SWIG_RuntimeError:
744    type = "RuntimeError";
745    break;
746  case SWIG_IndexError:
747    type = "IndexError";
748    break;
749  case SWIG_TypeError:
750    type = "TypeError";
751    break;
752  case SWIG_DivisionByZero:
753    type = "ZeroDivisionError";
754    break;
755  case SWIG_OverflowError:
756    type = "OverflowError";
757    break;
758  case SWIG_SyntaxError:
759    type = "SyntaxError";
760    break;
761  case SWIG_ValueError:
762    type = "ValueError";
763    break;
764  case SWIG_SystemError:
765    type = "SystemError";
766    break;
767  case SWIG_AttributeError:
768    type = "AttributeError";
769    break;
770  default:
771    type = "RuntimeError";
772  }
773  return type;
774}
775
776
777SWIGINTERN void
778SWIG_Tcl_SetErrorObj(Tcl_Interp *interp, const char *ctype, Tcl_Obj *obj)
779{
780  Tcl_ResetResult(interp);
781  Tcl_SetObjResult(interp, obj);
782  Tcl_SetErrorCode(interp, "SWIG", ctype, NULL);
783}
784
785SWIGINTERN void
786SWIG_Tcl_SetErrorMsg(Tcl_Interp *interp, const char *ctype, const char *mesg)
787{
788  Tcl_ResetResult(interp);
789  Tcl_SetErrorCode(interp, "SWIG", ctype, NULL);
790  Tcl_AppendResult(interp, ctype, " ", mesg, NULL);
791  /*
792  Tcl_AddErrorInfo(interp, ctype);
793  Tcl_AddErrorInfo(interp, " ");
794  Tcl_AddErrorInfo(interp, mesg);
795  */
796}
797
798SWIGINTERNINLINE void
799SWIG_Tcl_AddErrorMsg(Tcl_Interp *interp, const char* mesg)
800{
801  Tcl_AddErrorInfo(interp, mesg);
802}
803
804
805
806/* -----------------------------------------------------------------------------
807 * SWIG API. Portion that goes into the runtime
808 * ----------------------------------------------------------------------------- */
809#ifdef __cplusplus
810extern "C" {
811#endif
812
813/* -----------------------------------------------------------------------------
814 * Constant declarations
815 * ----------------------------------------------------------------------------- */
816
817/* Constant Types */
818#define SWIG_TCL_POINTER 4
819#define SWIG_TCL_BINARY  5
820
821/* Constant information structure */
822typedef struct swig_const_info {
823    int type;
824    char *name;
825    long lvalue;
826    double dvalue;
827    void   *pvalue;
828    swig_type_info **ptype;
829} swig_const_info;
830
831typedef int   (*swig_wrapper)(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST []);
832typedef int   (*swig_wrapper_func)(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST []);
833typedef char *(*swig_variable_func)(ClientData, Tcl_Interp *, char *, char *, int);
834typedef void  (*swig_delete_func)(ClientData);
835
836typedef struct swig_method {
837  const char     *name;
838  swig_wrapper   method;
839} swig_method;
840
841typedef struct swig_attribute {
842  const char     *name;
843  swig_wrapper   getmethod;
844  swig_wrapper   setmethod;
845} swig_attribute;
846
847typedef struct swig_class {
848  const char         *name;
849  swig_type_info   **type;
850  swig_wrapper       constructor;
851  void              (*destructor)(void *);
852  swig_method        *methods;
853  swig_attribute     *attributes;
854  struct swig_class **bases;
855  const char              **base_names;
856  swig_module_info   *module;
857  Tcl_HashTable       hashtable;
858} swig_class;
859
860typedef struct swig_instance {
861  Tcl_Obj       *thisptr;
862  void          *thisvalue;
863  swig_class   *classptr;
864  int            destroy;
865  Tcl_Command    cmdtok;
866} swig_instance;
867
868/* Structure for command table */
869typedef struct {
870  const char *name;
871  int       (*wrapper)(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST []);
872  ClientData  clientdata;
873} swig_command_info;
874
875/* Structure for variable linking table */
876typedef struct {
877  const char *name;
878  void *addr;
879  char * (*get)(ClientData, Tcl_Interp *, char *, char *, int);
880  char * (*set)(ClientData, Tcl_Interp *, char *, char *, int);
881} swig_var_info;
882
883
884/* -----------------------------------------------------------------------------*
885 *  Install a constant object
886 * -----------------------------------------------------------------------------*/
887
888static Tcl_HashTable   swigconstTable;
889static int             swigconstTableinit = 0;
890
891SWIGINTERN void
892SWIG_Tcl_SetConstantObj(Tcl_Interp *interp, const char* name, Tcl_Obj *obj) {
893  int newobj;
894  Tcl_ObjSetVar2(interp,Tcl_NewStringObj(name,-1), NULL, obj, TCL_GLOBAL_ONLY);
895  Tcl_SetHashValue(Tcl_CreateHashEntry(&swigconstTable, name, &newobj), (ClientData) obj);
896}
897
898SWIGINTERN Tcl_Obj *
899SWIG_Tcl_GetConstantObj(const char *key) {
900  Tcl_HashEntry *entryPtr;
901  if (!swigconstTableinit) return 0;
902  entryPtr = Tcl_FindHashEntry(&swigconstTable, key);
903  if (entryPtr) {
904    return (Tcl_Obj *) Tcl_GetHashValue(entryPtr);
905  }
906  return 0;
907}
908
909#ifdef __cplusplus
910}
911#endif
912
913
914
915/* -----------------------------------------------------------------------------
916 * tclrun.swg
917 *
918 * This file contains the runtime support for Tcl modules and includes
919 * code for managing global variables and pointer type checking.
920 * ----------------------------------------------------------------------------- */
921
922/* Common SWIG API */
923
924/* for raw pointers */
925#define SWIG_ConvertPtr(oc, ptr, ty, flags)             SWIG_Tcl_ConvertPtr(interp, oc, ptr, ty, flags)
926#define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Tcl_NewPointerObj(ptr, type, flags)
927
928/* for raw packed data */
929#define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Tcl_ConvertPacked(interp, obj, ptr, sz, ty)
930#define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Tcl_NewPackedObj(ptr, sz, type)
931
932/* for class or struct pointers */
933#define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_Tcl_ConvertPtr(interp, obj, pptr, type, flags)
934#define SWIG_NewInstanceObj(thisvalue, type, flags)     SWIG_Tcl_NewInstanceObj(interp, thisvalue, type, flags)
935
936/* for C or C++ function pointers */
937#define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_Tcl_ConvertPtr(interp, obj, pptr, type, 0)
938#define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_Tcl_NewPointerObj(ptr, type, 0)
939
940/* for C++ member pointers, ie, member methods */
941#define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Tcl_ConvertPacked(interp,obj, ptr, sz, ty)
942#define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Tcl_NewPackedObj(ptr, sz, type)
943
944
945/* Runtime API */
946
947#define SWIG_GetModule(clientdata)                      SWIG_Tcl_GetModule((Tcl_Interp *) (clientdata))     
948#define SWIG_SetModule(clientdata, pointer)             SWIG_Tcl_SetModule((Tcl_Interp *) (clientdata), pointer)
949
950
951/* Error manipulation */
952
953#define SWIG_ErrorType(code)                            SWIG_Tcl_ErrorType(code)                                     
954#define SWIG_Error(code, msg)                           SWIG_Tcl_SetErrorMsg(interp, SWIG_Tcl_ErrorType(code), msg)
955#define SWIG_fail                                       goto fail                                                   
956
957
958/* Tcl-specific SWIG API */
959
960#define SWIG_Acquire(ptr)                               SWIG_Tcl_Acquire(ptr)                                     
961#define SWIG_MethodCommand                              SWIG_Tcl_MethodCommand                                 
962#define SWIG_Disown(ptr)                                SWIG_Tcl_Disown(ptr)                                   
963#define SWIG_ConvertPtrFromString(c, ptr, ty, flags)    SWIG_Tcl_ConvertPtrFromString(interp, c, ptr, ty, flags) 
964#define SWIG_MakePtr(c, ptr, ty, flags)                 SWIG_Tcl_MakePtr(c, ptr, ty, flags)                   
965#define SWIG_PointerTypeFromString(c)                   SWIG_Tcl_PointerTypeFromString(c)                             
966#define SWIG_GetArgs                                    SWIG_Tcl_GetArgs                                               
967#define SWIG_GetConstantObj(key)                        SWIG_Tcl_GetConstantObj(key)                           
968#define SWIG_ObjectConstructor                          SWIG_Tcl_ObjectConstructor                                     
969#define SWIG_Thisown(ptr)                               SWIG_Tcl_Thisown(ptr)                                 
970#define SWIG_ObjectDelete                               SWIG_Tcl_ObjectDelete                                 
971
972
973#define SWIG_TCL_DECL_ARGS_2(arg1, arg2)                (Tcl_Interp *interp SWIGUNUSED, arg1, arg2)
974#define SWIG_TCL_CALL_ARGS_2(arg1, arg2)                (interp, arg1, arg2)
975/* -----------------------------------------------------------------------------
976 * pointers/data manipulation
977 * ----------------------------------------------------------------------------- */
978
979/* For backward compatibility only */
980#define SWIG_POINTER_EXCEPTION  0
981#define SWIG_GetConstant        SWIG_GetConstantObj
982#define SWIG_Tcl_GetConstant    SWIG_Tcl_GetConstantObj
983
984#include "assert.h"
985
986#ifdef __cplusplus
987extern "C" {
988#endif
989
990/* Object support */
991
992SWIGRUNTIME Tcl_HashTable*
993SWIG_Tcl_ObjectTable(void) {
994  static Tcl_HashTable  swigobjectTable;
995  static int            swigobjectTableinit = 0;
996  if (!swigobjectTableinit) {
997    Tcl_InitHashTable(&swigobjectTable, TCL_ONE_WORD_KEYS);
998    swigobjectTableinit = 1;
999  }
1000  return &swigobjectTable;
1001}
1002
1003/* Acquire ownership of a pointer */
1004SWIGRUNTIME void
1005SWIG_Tcl_Acquire(void *ptr) {
1006  int newobj;
1007  Tcl_CreateHashEntry(SWIG_Tcl_ObjectTable(), (char *) ptr, &newobj);
1008}
1009
1010SWIGRUNTIME int
1011SWIG_Tcl_Thisown(void *ptr) {
1012  if (Tcl_FindHashEntry(SWIG_Tcl_ObjectTable(), (char *) ptr)) {
1013    return 1;
1014  }
1015  return 0;
1016}
1017
1018/* Disown a pointer.  Returns 1 if we owned it to begin with */
1019SWIGRUNTIME int
1020SWIG_Tcl_Disown(void *ptr) {
1021  Tcl_HashEntry *entryPtr = Tcl_FindHashEntry(SWIG_Tcl_ObjectTable(), (char *) ptr);
1022  if (entryPtr) {
1023    Tcl_DeleteHashEntry(entryPtr);
1024    return 1;
1025  }
1026  return 0;
1027}
1028
1029/* Convert a pointer value */
1030SWIGRUNTIME int
1031SWIG_Tcl_ConvertPtrFromString(Tcl_Interp *interp, const char *c, void **ptr, swig_type_info *ty, int flags) {
1032  swig_cast_info *tc;
1033  /* Pointer values must start with leading underscore */
1034  while (*c != '_') {
1035    *ptr = (void *) 0;
1036    if (strcmp(c,"NULL") == 0) return SWIG_OK;
1037
1038    /* Empty string: not a pointer */
1039    if (*c == 0) return SWIG_ERROR; 
1040
1041    /* Hmmm. It could be an object name. */
1042
1043    /* Check if this is a command at all. Prevents <c> cget -this         */
1044    /* from being called when c is not a command, firing the unknown proc */
1045    if (Tcl_VarEval(interp,"info commands ", c, (char *) NULL) == TCL_OK) {
1046      Tcl_Obj *result = Tcl_GetObjResult(interp);
1047      if (*(Tcl_GetStringFromObj(result, NULL)) == 0) {
1048        /* It's not a command, so it can't be a pointer */
1049        Tcl_ResetResult(interp);
1050        return SWIG_ERROR;
1051      }
1052    } else {
1053      /* This will only fail if the argument is multiple words. */
1054      /* Multiple words are also not commands.                  */
1055      Tcl_ResetResult(interp);
1056      return SWIG_ERROR;
1057    }
1058
1059    /* Check if this is really a SWIG pointer */
1060    if (Tcl_VarEval(interp,c," cget -this", (char *) NULL) != TCL_OK) {
1061      Tcl_ResetResult(interp);
1062      return SWIG_ERROR;
1063    }
1064
1065    c = Tcl_GetStringFromObj(Tcl_GetObjResult(interp), NULL);
1066  }
1067
1068  c++;
1069  c = SWIG_UnpackData(c,ptr,sizeof(void *));
1070  if (ty) {
1071    tc = c ? SWIG_TypeCheck(c,ty) : 0;
1072    if (!tc) {
1073      return SWIG_ERROR;
1074    }
1075    if (flags & SWIG_POINTER_DISOWN) {
1076      SWIG_Disown((void *) *ptr);
1077    }
1078    {
1079      int newmemory = 0;
1080      *ptr = SWIG_TypeCast(tc,(void *) *ptr,&newmemory);
1081      assert(!newmemory); /* newmemory handling not yet implemented */
1082    }
1083  }
1084  return SWIG_OK;
1085}
1086
1087/* Convert a pointer value */
1088SWIGRUNTIMEINLINE int
1089SWIG_Tcl_ConvertPtr(Tcl_Interp *interp, Tcl_Obj *oc, void **ptr, swig_type_info *ty, int flags) {
1090  return SWIG_Tcl_ConvertPtrFromString(interp, Tcl_GetStringFromObj(oc,NULL), ptr, ty, flags);
1091}
1092
1093/* Convert a pointer value */
1094SWIGRUNTIME char *
1095SWIG_Tcl_PointerTypeFromString(char *c) {
1096  char d;
1097  /* Pointer values must start with leading underscore. NULL has no type */
1098  if (*c != '_') {
1099    return 0;
1100  }
1101  c++;
1102  /* Extract hex value from pointer */
1103  while ((d = *c)) {
1104    if (!(((d >= '0') && (d <= '9')) || ((d >= 'a') && (d <= 'f')))) break;
1105    c++;
1106  }
1107  return c;
1108}
1109
1110/* Convert a packed value value */
1111SWIGRUNTIME int
1112SWIG_Tcl_ConvertPacked(Tcl_Interp *SWIGUNUSEDPARM(interp) , Tcl_Obj *obj, void *ptr, int sz, swig_type_info *ty) {
1113  swig_cast_info *tc;
1114  const char  *c;
1115
1116  if (!obj) goto type_error;
1117  c = Tcl_GetStringFromObj(obj,NULL);
1118  /* Pointer values must start with leading underscore */
1119  if (*c != '_') goto type_error;
1120  c++;
1121  c = SWIG_UnpackData(c,ptr,sz);
1122  if (ty) {
1123    tc = SWIG_TypeCheck(c,ty);
1124    if (!tc) goto type_error;
1125  }
1126  return SWIG_OK;
1127
1128 type_error:
1129
1130  return SWIG_ERROR;
1131}
1132
1133
1134/* Take a pointer and convert it to a string */
1135SWIGRUNTIME void
1136SWIG_Tcl_MakePtr(char *c, void *ptr, swig_type_info *ty, int flags) {
1137  if (ptr) {
1138    *(c++) = '_';
1139    c = SWIG_PackData(c,&ptr,sizeof(void *));
1140    strcpy(c,ty->name);
1141  } else {
1142    strcpy(c,(char *)"NULL");
1143  }
1144  flags = 0;
1145}
1146
1147/* Create a new pointer object */
1148SWIGRUNTIMEINLINE Tcl_Obj *
1149SWIG_Tcl_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
1150  Tcl_Obj *robj;
1151  char result[SWIG_BUFFER_SIZE];
1152  SWIG_MakePtr(result,ptr,type,flags);
1153  robj = Tcl_NewStringObj(result,-1);
1154  return robj;
1155}
1156
1157SWIGRUNTIME Tcl_Obj *
1158SWIG_Tcl_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
1159  char result[1024];
1160  char *r = result;
1161  if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
1162  *(r++) = '_';
1163  r = SWIG_PackData(r,ptr,sz);
1164  strcpy(r,type->name);
1165  return Tcl_NewStringObj(result,-1);
1166}
1167
1168/* -----------------------------------------------------------------------------*
1169 *  Get type list
1170 * -----------------------------------------------------------------------------*/
1171
1172SWIGRUNTIME swig_module_info * 
1173SWIG_Tcl_GetModule(Tcl_Interp *interp) {
1174  const char *data;
1175  swig_module_info *ret = 0;
1176 
1177  /* first check if pointer already created */
1178  data = Tcl_GetVar(interp, (char *)"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, TCL_GLOBAL_ONLY);
1179  if (data) {
1180    SWIG_UnpackData(data, &ret, sizeof(swig_type_info **));
1181  }
1182
1183  return ret;
1184}
1185
1186SWIGRUNTIME void
1187SWIG_Tcl_SetModule(Tcl_Interp *interp, swig_module_info *module) {
1188  char buf[SWIG_BUFFER_SIZE];
1189  char *data;
1190
1191  /* create a new pointer */
1192  data = SWIG_PackData(buf, &module, sizeof(swig_type_info **));
1193  *data = 0;
1194  Tcl_SetVar(interp, (char *)"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, buf, TCL_GLOBAL_ONLY);
1195}
1196
1197/* -----------------------------------------------------------------------------*
1198 *  Object auxiliars
1199 * -----------------------------------------------------------------------------*/
1200
1201
1202SWIGRUNTIME void
1203SWIG_Tcl_ObjectDelete(ClientData clientData) {
1204  swig_instance *si = (swig_instance *) clientData;
1205  if ((si) && (si->destroy) && (SWIG_Disown(si->thisvalue))) {
1206    if (si->classptr->destructor) {
1207      (si->classptr->destructor)(si->thisvalue);
1208    }
1209  }
1210  Tcl_DecrRefCount(si->thisptr);
1211  free(si);
1212}
1213
1214/* Function to invoke object methods given an instance */
1215SWIGRUNTIME int
1216SWIG_Tcl_MethodCommand(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST _objv[]) {
1217  char *method,   *attrname;
1218  swig_instance   *inst = (swig_instance *) clientData;
1219  swig_method     *meth;
1220  swig_attribute  *attr;
1221  Tcl_Obj         *oldarg;
1222  Tcl_Obj         **objv;
1223  int              rcode;
1224  swig_class      *cls;
1225  swig_class      *cls_stack[64];
1226  int              cls_stack_bi[64];
1227  int              cls_stack_top = 0;
1228  int              numconf = 2;
1229  int              bi;
1230
1231  objv = (Tcl_Obj **) _objv;
1232  if (objc < 2) {
1233    Tcl_SetResult(interp, (char *) "wrong # args.", TCL_STATIC);
1234    return TCL_ERROR;
1235  }
1236  method = Tcl_GetStringFromObj(objv[1],NULL);
1237  if (strcmp(method,"-acquire") == 0) {
1238    inst->destroy = 1;
1239    SWIG_Acquire(inst->thisvalue);
1240    return TCL_OK;
1241  }
1242  if (strcmp(method,"-disown") == 0) {
1243    if (inst->destroy) {
1244      SWIG_Disown(inst->thisvalue);
1245    }
1246    inst->destroy = 0;
1247    return TCL_OK;
1248  }
1249  if (strcmp(method,"-delete") == 0) {
1250    Tcl_DeleteCommandFromToken(interp,inst->cmdtok);
1251    return TCL_OK;
1252  }
1253  cls_stack[cls_stack_top] = inst->classptr;
1254  cls_stack_bi[cls_stack_top] = -1;
1255  cls = inst->classptr;
1256  while (1) {
1257    Tcl_HashEntry* hashentry;
1258    bi = cls_stack_bi[cls_stack_top];
1259    cls = cls_stack[cls_stack_top];
1260    if (bi != -1) {
1261      if (!cls->bases[bi] && cls->base_names[bi]) {
1262        /* lookup and cache the base class */
1263        swig_type_info *info = SWIG_TypeQueryModule(cls->module, cls->module, cls->base_names[bi]);
1264        if (info) cls->bases[bi] = (swig_class *) info->clientdata;
1265      }
1266      cls = cls->bases[bi];
1267      if (cls) {
1268        cls_stack_bi[cls_stack_top]++;
1269        cls_stack_top++;
1270        cls_stack[cls_stack_top] = cls;
1271        cls_stack_bi[cls_stack_top] = -1;
1272        continue;
1273      }
1274    }
1275    if (!cls) {
1276      cls_stack_top--;
1277      if (cls_stack_top < 0) break;
1278      else continue;
1279    }
1280    cls_stack_bi[cls_stack_top]++;
1281
1282    hashentry = Tcl_FindHashEntry(&(cls->hashtable), method);
1283    if (hashentry) {
1284        ClientData cd = Tcl_GetHashValue(hashentry);
1285        swig_wrapper method_wrapper = (swig_wrapper)cd;
1286        oldarg = objv[1];
1287        objv[1] = inst->thisptr;
1288        Tcl_IncrRefCount(inst->thisptr);
1289        rcode = (method_wrapper)(clientData,interp,objc,objv);
1290        objv[1] = oldarg;
1291        Tcl_DecrRefCount(inst->thisptr);
1292        return rcode;
1293    }
1294    /* Check class methods for a match */
1295    if (strcmp(method,"cget") == 0) {
1296      if (objc < 3) {
1297        Tcl_SetResult(interp, (char *) "wrong # args.", TCL_STATIC);
1298        return TCL_ERROR;
1299      }
1300      attrname = Tcl_GetStringFromObj(objv[2],NULL);
1301      attr = cls->attributes;
1302      while (attr && attr->name) {
1303        if ((strcmp(attr->name, attrname) == 0) && (attr->getmethod)) {
1304          oldarg = objv[1];
1305          objv[1] = inst->thisptr;
1306          Tcl_IncrRefCount(inst->thisptr);
1307          rcode = (*attr->getmethod)(clientData,interp,2, objv);
1308          objv[1] = oldarg;
1309          Tcl_DecrRefCount(inst->thisptr);
1310          return rcode;
1311        }
1312        attr++;
1313      }
1314      if (strcmp(attrname, "-this") == 0) {
1315        Tcl_SetObjResult(interp, Tcl_DuplicateObj(inst->thisptr));
1316        return TCL_OK;
1317      }
1318      if (strcmp(attrname, "-thisown") == 0) {
1319        if (SWIG_Thisown(inst->thisvalue)) {
1320          Tcl_SetResult(interp,(char*)"1",TCL_STATIC);
1321        } else {
1322          Tcl_SetResult(interp,(char*)"0",TCL_STATIC);
1323        }
1324        return TCL_OK;
1325      }
1326    } else if (strcmp(method, "configure") == 0) {
1327      int i;
1328      if (objc < 4) {
1329        Tcl_SetResult(interp, (char *) "wrong # args.", TCL_STATIC);
1330        return TCL_ERROR;
1331      }
1332      i = 2;
1333      while (i < objc) {
1334        attrname = Tcl_GetStringFromObj(objv[i],NULL);
1335        attr = cls->attributes;
1336        while (attr && attr->name) {
1337          if ((strcmp(attr->name, attrname) == 0) && (attr->setmethod)) {
1338            oldarg = objv[i];
1339            objv[i] = inst->thisptr;
1340            Tcl_IncrRefCount(inst->thisptr);
1341            rcode = (*attr->setmethod)(clientData,interp,3, &objv[i-1]);
1342            objv[i] = oldarg;
1343            Tcl_DecrRefCount(inst->thisptr);
1344            if (rcode != TCL_OK) return rcode;
1345            numconf += 2;
1346          }
1347          attr++;
1348        }
1349        i+=2;
1350      }
1351    }
1352  }
1353  if (strcmp(method,"configure") == 0) {
1354    if (numconf >= objc) {
1355      return TCL_OK;
1356    } else {
1357      Tcl_SetResult(interp,(char *) "Invalid attribute name.", TCL_STATIC);
1358      return TCL_ERROR;
1359    }
1360  }
1361  if (strcmp(method,"cget") == 0) {
1362    Tcl_SetResult(interp,(char *) "Invalid attribute name.", TCL_STATIC);
1363    return TCL_ERROR;
1364  }
1365  Tcl_SetResult(interp, (char *) "Invalid method. Must be one of: configure cget -acquire -disown -delete", TCL_STATIC);
1366  cls = inst->classptr;
1367  bi = 0;
1368  while (cls) {
1369    meth = cls->methods;
1370    while (meth && meth->name) {
1371      char *cr = (char *) Tcl_GetStringResult(interp);
1372      size_t meth_len = strlen(meth->name);
1373      char* where = strchr(cr,':');
1374      while(where) {
1375        where = strstr(where, meth->name);
1376        if(where) {
1377          if(where[-1] == ' ' && (where[meth_len] == ' ' || where[meth_len]==0)) {
1378            break;
1379          } else {
1380            where++;
1381          }
1382        }
1383      }
1384
1385      if (!where)
1386        Tcl_AppendElement(interp, (char *) meth->name);
1387      meth++;
1388    }
1389    cls = inst->classptr->bases[bi++];
1390  }
1391  return TCL_ERROR;
1392}
1393
1394/* This function takes the current result and turns it into an object command */
1395SWIGRUNTIME Tcl_Obj *
1396SWIG_Tcl_NewInstanceObj(Tcl_Interp *interp, void *thisvalue, swig_type_info *type, int flags) {
1397  Tcl_Obj *robj = SWIG_NewPointerObj(thisvalue, type,0);
1398  /* Check to see if this pointer belongs to a class or not */
1399  if (thisvalue && (type->clientdata) && (interp)) {
1400    Tcl_CmdInfo    ci;
1401    char          *name;
1402    name = Tcl_GetStringFromObj(robj,NULL);
1403    if (!Tcl_GetCommandInfo(interp,name, &ci) || (flags)) {
1404      swig_instance *newinst = (swig_instance *) malloc(sizeof(swig_instance));
1405      newinst->thisptr = Tcl_DuplicateObj(robj);
1406      Tcl_IncrRefCount(newinst->thisptr);
1407      newinst->thisvalue = thisvalue;
1408      newinst->classptr = (swig_class *) type->clientdata;
1409      newinst->destroy = flags;
1410      newinst->cmdtok = Tcl_CreateObjCommand(interp, Tcl_GetStringFromObj(robj,NULL), (swig_wrapper_func) SWIG_MethodCommand, (ClientData) newinst, (swig_delete_func) SWIG_ObjectDelete);
1411      if (flags) {
1412        SWIG_Acquire(thisvalue);
1413      }
1414    }
1415  }
1416  return robj;
1417}
1418
1419/* Function to create objects */
1420SWIGRUNTIME int
1421SWIG_Tcl_ObjectConstructor(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
1422  Tcl_Obj          *newObj = 0;
1423  void             *thisvalue = 0;
1424  swig_instance   *newinst = 0;
1425  swig_class      *classptr = (swig_class *) clientData;
1426  swig_wrapper     cons = 0;
1427  char             *name = 0;
1428  int               firstarg = 0;
1429  int               thisarg = 0;
1430  int               destroy = 1;
1431
1432  if (!classptr) {
1433    Tcl_SetResult(interp, (char *) "swig: internal runtime error. No class object defined.", TCL_STATIC);
1434    return TCL_ERROR;
1435  }
1436  cons = classptr->constructor;
1437  if (objc > 1) {
1438    char *s = Tcl_GetStringFromObj(objv[1],NULL);
1439    if (strcmp(s,"-this") == 0) {
1440      thisarg = 2;
1441      cons = 0;
1442    } else if (strcmp(s,"-args") == 0) {
1443      firstarg = 1;
1444    } else if (objc == 2) {
1445      firstarg = 1;
1446      name = s;
1447    } else if (objc >= 3) {
1448      char *s1;
1449      name = s;
1450      s1 = Tcl_GetStringFromObj(objv[2],NULL);
1451      if (strcmp(s1,"-this") == 0) {
1452        thisarg = 3;
1453        cons = 0;
1454      } else {
1455        firstarg = 1;
1456      }
1457    }
1458  }
1459  if (cons) {
1460    int result;
1461    result = (*cons)(0, interp, objc-firstarg, &objv[firstarg]);
1462    if (result != TCL_OK) {
1463      return result;
1464    }
1465    newObj = Tcl_DuplicateObj(Tcl_GetObjResult(interp));
1466    if (!name) name = Tcl_GetStringFromObj(newObj,NULL);
1467  } else if (thisarg > 0) {
1468    if (thisarg < objc) {
1469      destroy = 0;
1470      newObj = Tcl_DuplicateObj(objv[thisarg]);
1471      if (!name) name = Tcl_GetStringFromObj(newObj,NULL);
1472    } else {
1473      Tcl_SetResult(interp, (char *) "wrong # args.", TCL_STATIC);
1474      return TCL_ERROR;
1475    }
1476  } else {
1477    Tcl_SetResult(interp, (char *) "No constructor available.", TCL_STATIC);
1478    return TCL_ERROR;
1479  }
1480  if (SWIG_Tcl_ConvertPtr(interp,newObj, (void **) &thisvalue, *(classptr->type), 0) != SWIG_OK) {
1481    Tcl_DecrRefCount(newObj);
1482    return TCL_ERROR;
1483  }
1484  newinst = (swig_instance *) malloc(sizeof(swig_instance));
1485  newinst->thisptr = newObj;
1486  Tcl_IncrRefCount(newObj);
1487  newinst->thisvalue = thisvalue;
1488  newinst->classptr = classptr;
1489  newinst->destroy = destroy;
1490  if (destroy) {
1491    SWIG_Acquire(thisvalue);
1492  }
1493  newinst->cmdtok = Tcl_CreateObjCommand(interp,name, (swig_wrapper) SWIG_MethodCommand, (ClientData) newinst, (swig_delete_func) SWIG_ObjectDelete);
1494  return TCL_OK;
1495}
1496
1497/* -----------------------------------------------------------------------------*
1498 *   Get arguments
1499 * -----------------------------------------------------------------------------*/
1500SWIGRUNTIME int
1501SWIG_Tcl_GetArgs(Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[], const char *fmt, ...) {
1502  int        argno = 0, opt = 0;
1503  long       tempi;
1504  double     tempd;
1505  const char *c;
1506  va_list    ap;
1507  void      *vptr;
1508  Tcl_Obj   *obj = 0;
1509  swig_type_info *ty;
1510
1511  va_start(ap,fmt);
1512  for (c = fmt; (*c && (*c != ':') && (*c != ';')); c++,argno++) {
1513    if (*c == '|') {
1514      opt = 1;
1515      c++;
1516    }
1517    if (argno >= (objc-1)) {
1518      if (!opt) {
1519        Tcl_SetResult(interp, (char *) "Wrong number of arguments ", TCL_STATIC);
1520        goto argerror;
1521      } else {
1522        va_end(ap);
1523        return TCL_OK;
1524      }
1525    }
1526
1527    vptr = va_arg(ap,void *);
1528    if (vptr) {
1529      if (isupper(*c)) {
1530        obj = SWIG_Tcl_GetConstantObj(Tcl_GetStringFromObj(objv[argno+1],0));
1531        if (!obj) obj = objv[argno+1];
1532      } else {
1533        obj = objv[argno+1];
1534      }
1535      switch(*c) {
1536      case 'i': case 'I':
1537      case 'l': case 'L':
1538      case 'h': case 'H':
1539      case 'b': case 'B':
1540        if (Tcl_GetLongFromObj(interp,obj,&tempi) != TCL_OK) goto argerror;
1541        if ((*c == 'i') || (*c == 'I')) *((int *)vptr) = (int)tempi;
1542        else if ((*c == 'l') || (*c == 'L')) *((long *)vptr) = (long)tempi;
1543        else if ((*c == 'h') || (*c == 'H')) *((short*)vptr) = (short)tempi;
1544        else if ((*c == 'b') || (*c == 'B')) *((unsigned char *)vptr) = (unsigned char)tempi;
1545        break;
1546      case 'f': case 'F':
1547      case 'd': case 'D':
1548        if (Tcl_GetDoubleFromObj(interp,obj,&tempd) != TCL_OK) goto argerror;
1549        if ((*c == 'f') || (*c == 'F')) *((float *) vptr) = (float)tempd;
1550        else if ((*c == 'd') || (*c == 'D')) *((double*) vptr) = tempd;
1551        break;
1552      case 's': case 'S':
1553        if (*(c+1) == '#') {
1554          int *vlptr = (int *) va_arg(ap, void *);
1555          *((char **) vptr) = Tcl_GetStringFromObj(obj, vlptr);
1556          c++;
1557        } else {
1558          *((char **)vptr) = Tcl_GetStringFromObj(obj,NULL);
1559        }
1560        break;
1561      case 'c': case 'C':
1562        *((char *)vptr) = *(Tcl_GetStringFromObj(obj,NULL));
1563        break;
1564      case 'p': case 'P':
1565        ty = (swig_type_info *) va_arg(ap, void *);
1566        if (SWIG_Tcl_ConvertPtr(interp, obj, (void **) vptr, ty, 0) != SWIG_OK) goto argerror;
1567        break;
1568      case 'o': case 'O':
1569        *((Tcl_Obj **)vptr) = objv[argno+1];
1570        break;
1571      default:
1572        break;
1573      }
1574    }
1575  }
1576
1577  if ((*c != ';') && ((objc-1) > argno)) {
1578    Tcl_SetResult(interp, (char *) "Wrong # args.", TCL_STATIC);
1579    goto argerror;
1580  }
1581  va_end(ap);
1582  return TCL_OK;
1583
1584 argerror:
1585  {
1586    char temp[32];
1587    sprintf(temp,"%d", argno+1);
1588    c = strchr(fmt,':');
1589    if (!c) c = strchr(fmt,';');
1590    if (!c) c = (char *)"";
1591    Tcl_AppendResult(interp,c," argument ", temp, NULL);
1592    va_end(ap);
1593    return TCL_ERROR;
1594  }
1595}
1596
1597#ifdef __cplusplus
1598}
1599#endif
1600
1601
1602
1603#define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
1604
1605#define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
1606
1607
1608
1609/* -------- TYPES TABLE (BEGIN) -------- */
1610
1611#define SWIGTYPE_p_char swig_types[0]
1612#define SWIGTYPE_p_int swig_types[1]
1613#define SWIGTYPE_p_macho swig_types[2]
1614#define SWIGTYPE_p_macho_arch swig_types[3]
1615#define SWIGTYPE_p_macho_handle swig_types[4]
1616#define SWIGTYPE_p_macho_loadcmd swig_types[5]
1617#define SWIGTYPE_p_p_macho swig_types[6]
1618#define SWIGTYPE_p_unsigned_int swig_types[7]
1619static swig_type_info *swig_types[9];
1620static swig_module_info swig_module = {swig_types, 8, 0, 0, 0, 0};
1621#define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1622#define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1623
1624/* -------- TYPES TABLE (END) -------- */
1625
1626#define SWIG_init    Machista_Init
1627#define SWIG_name    "machista"
1628#define SWIG_prefix  "machista::"
1629#define SWIG_namespace "machista"
1630
1631#define SWIG_version "1.0"
1632
1633#define SWIGVERSION 0x030005
1634#define SWIG_VERSION SWIGVERSION
1635
1636
1637#define SWIG_as_voidptr(a) (void *)((const void *)(a))
1638#define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
1639
1640
1641
1642#ifdef __cplusplus
1643extern "C" {
1644#endif
1645#ifdef MAC_TCL
1646#pragma export on
1647#endif
1648SWIGEXPORT int SWIG_init(Tcl_Interp *);
1649#ifdef MAC_TCL
1650#pragma export off
1651#endif
1652#ifdef __cplusplus
1653}
1654#endif
1655
1656/* Compatibility version for TCL stubs */
1657#ifndef SWIG_TCL_STUBS_VERSION
1658#define SWIG_TCL_STUBS_VERSION "8.1"
1659#endif
1660
1661
1662
1663#include <tcl.h>
1664#include "libmachista.h"
1665
1666
1667#ifdef __MACH__
1668    #include <mach-o/arch.h>
1669#endif
1670    #include <inttypes.h>
1671    #include <stdint.h>
1672
1673
1674#include <limits.h>
1675#if !defined(SWIG_NO_LLONG_MAX)
1676# if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
1677#   define LLONG_MAX __LONG_LONG_MAX__
1678#   define LLONG_MIN (-LLONG_MAX - 1LL)
1679#   define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
1680# endif
1681#endif
1682
1683
1684SWIGINTERNINLINE Tcl_Obj* 
1685SWIG_From_long  (long value)
1686{
1687  if (((long) INT_MIN <= value) && (value <= (long) INT_MAX)) {
1688    return Tcl_NewIntObj((int)(value));
1689  } else {
1690    return Tcl_NewLongObj(value);
1691  }
1692}
1693
1694
1695SWIGINTERNINLINE Tcl_Obj *
1696SWIG_From_int  (int value)
1697{   
1698  return SWIG_From_long  (value);
1699}
1700
1701
1702SWIGINTERNINLINE Tcl_Obj *
1703SWIG_FromCharPtrAndSize(const char* carray, size_t size)
1704{
1705  return (size < INT_MAX) ? Tcl_NewStringObj(carray, (int)(size)) : NULL;
1706}
1707
1708
1709SWIGINTERNINLINE Tcl_Obj * 
1710SWIG_FromCharPtr(const char *cptr)
1711{ 
1712  return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
1713}
1714
1715
1716#include <stdio.h>
1717#if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
1718# ifndef snprintf
1719#  define snprintf _snprintf
1720# endif
1721#endif
1722
1723
1724SWIGINTERNINLINE Tcl_Obj* 
1725SWIG_From_unsigned_SS_long  (unsigned long value)
1726{
1727  if (value < (unsigned long) LONG_MAX) {
1728    return SWIG_From_long  ((long)(value));
1729  } else {
1730    char temp[256]; 
1731    sprintf(temp, "%lu", value);
1732    return Tcl_NewStringObj(temp,-1);
1733  }
1734}
1735
1736
1737SWIGINTERNINLINE Tcl_Obj *
1738SWIG_From_unsigned_SS_int  (unsigned int value)
1739{   
1740  return SWIG_From_unsigned_SS_long  (value);
1741}
1742
1743
1744SWIGINTERN int
1745SWIG_AsCharPtrAndSize(Tcl_Obj *obj, char** cptr, size_t* psize, int *alloc)
1746{ 
1747  int len = 0;
1748  char *cstr = Tcl_GetStringFromObj(obj, &len);
1749  if (cstr) {
1750    if (cptr)  *cptr = cstr;
1751    if (psize) *psize = len + 1;
1752    if (alloc) *alloc = SWIG_OLDOBJ;
1753    return SWIG_OK;
1754  }
1755  return SWIG_TypeError;
1756}
1757
1758
1759
1760
1761
1762SWIGINTERN int
1763SWIG_AsVal_long SWIG_TCL_DECL_ARGS_2(Tcl_Obj *obj, long* val)
1764{
1765  long v;
1766  if (Tcl_GetLongFromObj(0,obj, &v) == TCL_OK) {
1767    if (val) *val = (long) v;
1768    return SWIG_OK;
1769  }
1770  return SWIG_TypeError;
1771}
1772
1773
1774SWIGINTERN int
1775SWIG_AsVal_int SWIG_TCL_DECL_ARGS_2(Tcl_Obj * obj, int *val)
1776{
1777  long v;
1778  int res = SWIG_AsVal_long SWIG_TCL_CALL_ARGS_2(obj, &v);
1779  if (SWIG_IsOK(res)) {
1780    if ((v < INT_MIN || v > INT_MAX)) {
1781      return SWIG_OverflowError;
1782    } else {
1783      if (val) *val = (int)(v);
1784    }
1785  } 
1786  return res;
1787}
1788
1789
1790SWIGINTERN int
1791SWIG_AsVal_unsigned_SS_long SWIG_TCL_DECL_ARGS_2(Tcl_Obj *obj, unsigned long *val) {
1792  long v;
1793  if (Tcl_GetLongFromObj(0,obj, &v) == TCL_OK) {
1794    if (v >= 0) {
1795      if (val) *val = (unsigned long) v;
1796      return SWIG_OK;
1797    }
1798    /* If v is negative, then this could be a negative number, or an
1799       unsigned value which doesn't fit in a signed long, so try to
1800       get it as a string so we can distinguish these cases. */
1801  }
1802  {
1803    int len = 0;
1804    const char *nptr = Tcl_GetStringFromObj(obj, &len);
1805    if (nptr && len > 0) {
1806      char *endptr;
1807      unsigned long v;
1808      if (*nptr == '-') return SWIG_OverflowError;
1809      errno = 0;
1810      v = strtoul(nptr, &endptr,0);
1811      if (nptr[0] == '\0' || *endptr != '\0')
1812        return SWIG_TypeError;
1813      if (v == ULONG_MAX && errno == ERANGE) {
1814        errno = 0;
1815        return SWIG_OverflowError;
1816      } else {
1817        if (*endptr == '\0') {
1818          if (val) *val = v;
1819          return SWIG_OK;
1820        }
1821      }
1822    }
1823  }
1824 
1825  return SWIG_TypeError;
1826}
1827
1828
1829SWIGINTERN int
1830SWIG_AsVal_unsigned_SS_int SWIG_TCL_DECL_ARGS_2(Tcl_Obj * obj, unsigned int *val)
1831{
1832  unsigned long v;
1833  int res = SWIG_AsVal_unsigned_SS_long SWIG_TCL_CALL_ARGS_2(obj, &v);
1834  if (SWIG_IsOK(res)) {
1835    if ((v > UINT_MAX)) {
1836      return SWIG_OverflowError;
1837    } else {
1838      if (val) *val = (unsigned int)(v);
1839    }
1840  } 
1841  return res;
1842}
1843
1844#ifdef __cplusplus
1845extern "C" {
1846#endif
1847static swig_method swig_macho_handle_methods[] = {
1848    {0,0}
1849};
1850static swig_attribute swig_macho_handle_attributes[] = {
1851    {0,0,0}
1852};
1853static swig_class *swig_macho_handle_bases[] = {0};
1854static const char * swig_macho_handle_base_names[] = {0};
1855static swig_class _wrap_class_macho_handle = { "macho_handle", &SWIGTYPE_p_macho_handle,0,0, swig_macho_handle_methods, swig_macho_handle_attributes, swig_macho_handle_bases,swig_macho_handle_base_names, &swig_module };
1856SWIGINTERN int
1857_wrap_macho_loadcmd_mlt_install_name_get(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
1858  struct macho_loadcmd *arg1 = (struct macho_loadcmd *) 0 ;
1859  void *argp1 = 0 ;
1860  int res1 = 0 ;
1861  char *result = 0 ;
1862 
1863  if (SWIG_GetArgs(interp, objc, objv,"o:machista::macho_loadcmd_mlt_install_name_get self ",(void *)0) == TCL_ERROR) SWIG_fail;
1864  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_macho_loadcmd, 0 |  0 );
1865  if (!SWIG_IsOK(res1)) {
1866    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "macho_loadcmd_mlt_install_name_get" "', argument " "1"" of type '" "struct macho_loadcmd *""'"); 
1867  }
1868  arg1 = (struct macho_loadcmd *)(argp1);
1869  result = (char *) ((arg1)->mlt_install_name);
1870  Tcl_SetObjResult(interp,SWIG_FromCharPtr((const char *)result));
1871  return TCL_OK;
1872fail:
1873  return TCL_ERROR;
1874}
1875
1876
1877SWIGINTERN int
1878_wrap_macho_loadcmd_mlt_type_get(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
1879  struct macho_loadcmd *arg1 = (struct macho_loadcmd *) 0 ;
1880  void *argp1 = 0 ;
1881  int res1 = 0 ;
1882  uint32_t result;
1883 
1884  if (SWIG_GetArgs(interp, objc, objv,"o:machista::macho_loadcmd_mlt_type_get self ",(void *)0) == TCL_ERROR) SWIG_fail;
1885  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_macho_loadcmd, 0 |  0 );
1886  if (!SWIG_IsOK(res1)) {
1887    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "macho_loadcmd_mlt_type_get" "', argument " "1"" of type '" "struct macho_loadcmd *""'"); 
1888  }
1889  arg1 = (struct macho_loadcmd *)(argp1);
1890  result = (uint32_t) ((arg1)->mlt_type);
1891  Tcl_SetObjResult(interp,SWIG_From_unsigned_SS_int((unsigned int)(result)));
1892  return TCL_OK;
1893fail:
1894  return TCL_ERROR;
1895}
1896
1897
1898SWIGINTERN int
1899_wrap_macho_loadcmd_mlt_comp_version_get(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
1900  struct macho_loadcmd *arg1 = (struct macho_loadcmd *) 0 ;
1901  void *argp1 = 0 ;
1902  int res1 = 0 ;
1903  uint32_t result;
1904 
1905  if (SWIG_GetArgs(interp, objc, objv,"o:machista::macho_loadcmd_mlt_comp_version_get self ",(void *)0) == TCL_ERROR) SWIG_fail;
1906  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_macho_loadcmd, 0 |  0 );
1907  if (!SWIG_IsOK(res1)) {
1908    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "macho_loadcmd_mlt_comp_version_get" "', argument " "1"" of type '" "struct macho_loadcmd *""'"); 
1909  }
1910  arg1 = (struct macho_loadcmd *)(argp1);
1911  result = (uint32_t) ((arg1)->mlt_comp_version);
1912  Tcl_SetObjResult(interp,SWIG_From_unsigned_SS_int((unsigned int)(result)));
1913  return TCL_OK;
1914fail:
1915  return TCL_ERROR;
1916}
1917
1918
1919SWIGINTERN int
1920_wrap_macho_loadcmd_mlt_version_get(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
1921  struct macho_loadcmd *arg1 = (struct macho_loadcmd *) 0 ;
1922  void *argp1 = 0 ;
1923  int res1 = 0 ;
1924  uint32_t result;
1925 
1926  if (SWIG_GetArgs(interp, objc, objv,"o:machista::macho_loadcmd_mlt_version_get self ",(void *)0) == TCL_ERROR) SWIG_fail;
1927  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_macho_loadcmd, 0 |  0 );
1928  if (!SWIG_IsOK(res1)) {
1929    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "macho_loadcmd_mlt_version_get" "', argument " "1"" of type '" "struct macho_loadcmd *""'"); 
1930  }
1931  arg1 = (struct macho_loadcmd *)(argp1);
1932  result = (uint32_t) ((arg1)->mlt_version);
1933  Tcl_SetObjResult(interp,SWIG_From_unsigned_SS_int((unsigned int)(result)));
1934  return TCL_OK;
1935fail:
1936  return TCL_ERROR;
1937}
1938
1939
1940SWIGINTERN int
1941_wrap_macho_loadcmd_next_get(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
1942  struct macho_loadcmd *arg1 = (struct macho_loadcmd *) 0 ;
1943  void *argp1 = 0 ;
1944  int res1 = 0 ;
1945  struct macho_loadcmd *result = 0 ;
1946 
1947  if (SWIG_GetArgs(interp, objc, objv,"o:machista::macho_loadcmd_next_get self ",(void *)0) == TCL_ERROR) SWIG_fail;
1948  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_macho_loadcmd, 0 |  0 );
1949  if (!SWIG_IsOK(res1)) {
1950    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "macho_loadcmd_next_get" "', argument " "1"" of type '" "struct macho_loadcmd *""'"); 
1951  }
1952  arg1 = (struct macho_loadcmd *)(argp1);
1953  result = (struct macho_loadcmd *) ((arg1)->next);
1954  Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_macho_loadcmd,0));
1955  return TCL_OK;
1956fail:
1957  return TCL_ERROR;
1958}
1959
1960
1961static swig_method swig_macho_loadcmd_methods[] = {
1962    {0,0}
1963};
1964static swig_attribute swig_macho_loadcmd_attributes[] = {
1965    { "-mlt_install_name",_wrap_macho_loadcmd_mlt_install_name_get, 0 },
1966    { "-mlt_type",_wrap_macho_loadcmd_mlt_type_get, 0 },
1967    { "-mlt_comp_version",_wrap_macho_loadcmd_mlt_comp_version_get, 0 },
1968    { "-mlt_version",_wrap_macho_loadcmd_mlt_version_get, 0 },
1969    { "-next",_wrap_macho_loadcmd_next_get, 0 },
1970    {0,0,0}
1971};
1972static swig_class *swig_macho_loadcmd_bases[] = {0};
1973static const char * swig_macho_loadcmd_base_names[] = {0};
1974static swig_class _wrap_class_macho_loadcmd = { "macho_loadcmd", &SWIGTYPE_p_macho_loadcmd,0,0, swig_macho_loadcmd_methods, swig_macho_loadcmd_attributes, swig_macho_loadcmd_bases,swig_macho_loadcmd_base_names, &swig_module };
1975SWIGINTERN int
1976_wrap_macho_arch_mat_install_name_get(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
1977  struct macho_arch *arg1 = (struct macho_arch *) 0 ;
1978  void *argp1 = 0 ;
1979  int res1 = 0 ;
1980  char *result = 0 ;
1981 
1982  if (SWIG_GetArgs(interp, objc, objv,"o:machista::macho_arch_mat_install_name_get self ",(void *)0) == TCL_ERROR) SWIG_fail;
1983  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_macho_arch, 0 |  0 );
1984  if (!SWIG_IsOK(res1)) {
1985    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "macho_arch_mat_install_name_get" "', argument " "1"" of type '" "struct macho_arch *""'"); 
1986  }
1987  arg1 = (struct macho_arch *)(argp1);
1988  result = (char *) ((arg1)->mat_install_name);
1989  Tcl_SetObjResult(interp,SWIG_FromCharPtr((const char *)result));
1990  return TCL_OK;
1991fail:
1992  return TCL_ERROR;
1993}
1994
1995
1996SWIGINTERN int
1997_wrap_macho_arch_mat_rpath_get(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
1998  struct macho_arch *arg1 = (struct macho_arch *) 0 ;
1999  void *argp1 = 0 ;
2000  int res1 = 0 ;
2001  char *result = 0 ;
2002 
2003  if (SWIG_GetArgs(interp, objc, objv,"o:machista::macho_arch_mat_rpath_get self ",(void *)0) == TCL_ERROR) SWIG_fail;
2004  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_macho_arch, 0 |  0 );
2005  if (!SWIG_IsOK(res1)) {
2006    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "macho_arch_mat_rpath_get" "', argument " "1"" of type '" "struct macho_arch *""'"); 
2007  }
2008  arg1 = (struct macho_arch *)(argp1);
2009  result = (char *) ((arg1)->mat_rpath);
2010  Tcl_SetObjResult(interp,SWIG_FromCharPtr((const char *)result));
2011  return TCL_OK;
2012fail:
2013  return TCL_ERROR;
2014}
2015
2016
2017SWIGINTERN int
2018_wrap_macho_arch_mat_arch_get(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2019  struct macho_arch *arg1 = (struct macho_arch *) 0 ;
2020  void *argp1 = 0 ;
2021  int res1 = 0 ;
2022  cpu_type_t result;
2023 
2024  if (SWIG_GetArgs(interp, objc, objv,"o:machista::macho_arch_mat_arch_get self ",(void *)0) == TCL_ERROR) SWIG_fail;
2025  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_macho_arch, 0 |  0 );
2026  if (!SWIG_IsOK(res1)) {
2027    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "macho_arch_mat_arch_get" "', argument " "1"" of type '" "struct macho_arch *""'"); 
2028  }
2029  arg1 = (struct macho_arch *)(argp1);
2030  result = (cpu_type_t) ((arg1)->mat_arch);
2031  Tcl_SetObjResult(interp,SWIG_From_int((int)(result)));
2032  return TCL_OK;
2033fail:
2034  return TCL_ERROR;
2035}
2036
2037
2038SWIGINTERN int
2039_wrap_macho_arch_mat_comp_version_get(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2040  struct macho_arch *arg1 = (struct macho_arch *) 0 ;
2041  void *argp1 = 0 ;
2042  int res1 = 0 ;
2043  uint32_t result;
2044 
2045  if (SWIG_GetArgs(interp, objc, objv,"o:machista::macho_arch_mat_comp_version_get self ",(void *)0) == TCL_ERROR) SWIG_fail;
2046  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_macho_arch, 0 |  0 );
2047  if (!SWIG_IsOK(res1)) {
2048    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "macho_arch_mat_comp_version_get" "', argument " "1"" of type '" "struct macho_arch *""'"); 
2049  }
2050  arg1 = (struct macho_arch *)(argp1);
2051  result = (uint32_t) ((arg1)->mat_comp_version);
2052  Tcl_SetObjResult(interp,SWIG_From_unsigned_SS_int((unsigned int)(result)));
2053  return TCL_OK;
2054fail:
2055  return TCL_ERROR;
2056}
2057
2058
2059SWIGINTERN int
2060_wrap_macho_arch_mat_version_get(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2061  struct macho_arch *arg1 = (struct macho_arch *) 0 ;
2062  void *argp1 = 0 ;
2063  int res1 = 0 ;
2064  uint32_t result;
2065 
2066  if (SWIG_GetArgs(interp, objc, objv,"o:machista::macho_arch_mat_version_get self ",(void *)0) == TCL_ERROR) SWIG_fail;
2067  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_macho_arch, 0 |  0 );
2068  if (!SWIG_IsOK(res1)) {
2069    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "macho_arch_mat_version_get" "', argument " "1"" of type '" "struct macho_arch *""'"); 
2070  }
2071  arg1 = (struct macho_arch *)(argp1);
2072  result = (uint32_t) ((arg1)->mat_version);
2073  Tcl_SetObjResult(interp,SWIG_From_unsigned_SS_int((unsigned int)(result)));
2074  return TCL_OK;
2075fail:
2076  return TCL_ERROR;
2077}
2078
2079
2080SWIGINTERN int
2081_wrap_macho_arch_mat_loadcmds_get(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2082  struct macho_arch *arg1 = (struct macho_arch *) 0 ;
2083  void *argp1 = 0 ;
2084  int res1 = 0 ;
2085  struct macho_loadcmd *result = 0 ;
2086 
2087  if (SWIG_GetArgs(interp, objc, objv,"o:machista::macho_arch_mat_loadcmds_get self ",(void *)0) == TCL_ERROR) SWIG_fail;
2088  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_macho_arch, 0 |  0 );
2089  if (!SWIG_IsOK(res1)) {
2090    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "macho_arch_mat_loadcmds_get" "', argument " "1"" of type '" "struct macho_arch *""'"); 
2091  }
2092  arg1 = (struct macho_arch *)(argp1);
2093  result = (struct macho_loadcmd *) ((arg1)->mat_loadcmds);
2094  Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_macho_loadcmd,0));
2095  return TCL_OK;
2096fail:
2097  return TCL_ERROR;
2098}
2099
2100
2101SWIGINTERN int
2102_wrap_macho_arch_next_get(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2103  struct macho_arch *arg1 = (struct macho_arch *) 0 ;
2104  void *argp1 = 0 ;
2105  int res1 = 0 ;
2106  struct macho_arch *result = 0 ;
2107 
2108  if (SWIG_GetArgs(interp, objc, objv,"o:machista::macho_arch_next_get self ",(void *)0) == TCL_ERROR) SWIG_fail;
2109  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_macho_arch, 0 |  0 );
2110  if (!SWIG_IsOK(res1)) {
2111    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "macho_arch_next_get" "', argument " "1"" of type '" "struct macho_arch *""'"); 
2112  }
2113  arg1 = (struct macho_arch *)(argp1);
2114  result = (struct macho_arch *) ((arg1)->next);
2115  Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_macho_arch,0));
2116  return TCL_OK;
2117fail:
2118  return TCL_ERROR;
2119}
2120
2121
2122static swig_method swig_macho_arch_methods[] = {
2123    {0,0}
2124};
2125static swig_attribute swig_macho_arch_attributes[] = {
2126    { "-mat_install_name",_wrap_macho_arch_mat_install_name_get, 0 },
2127    { "-mat_rpath",_wrap_macho_arch_mat_rpath_get, 0 },
2128    { "-mat_arch",_wrap_macho_arch_mat_arch_get, 0 },
2129    { "-mat_comp_version",_wrap_macho_arch_mat_comp_version_get, 0 },
2130    { "-mat_version",_wrap_macho_arch_mat_version_get, 0 },
2131    { "-mat_loadcmds",_wrap_macho_arch_mat_loadcmds_get, 0 },
2132    { "-next",_wrap_macho_arch_next_get, 0 },
2133    {0,0,0}
2134};
2135static swig_class *swig_macho_arch_bases[] = {0};
2136static const char * swig_macho_arch_base_names[] = {0};
2137static swig_class _wrap_class_macho_arch = { "macho_arch", &SWIGTYPE_p_macho_arch,0,0, swig_macho_arch_methods, swig_macho_arch_attributes, swig_macho_arch_bases,swig_macho_arch_base_names, &swig_module };
2138SWIGINTERN int
2139_wrap_macho_mt_archs_get(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2140  struct macho *arg1 = (struct macho *) 0 ;
2141  void *argp1 = 0 ;
2142  int res1 = 0 ;
2143  struct macho_arch *result = 0 ;
2144 
2145  if (SWIG_GetArgs(interp, objc, objv,"o:machista::macho_mt_archs_get self ",(void *)0) == TCL_ERROR) SWIG_fail;
2146  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_macho, 0 |  0 );
2147  if (!SWIG_IsOK(res1)) {
2148    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "macho_mt_archs_get" "', argument " "1"" of type '" "struct macho *""'"); 
2149  }
2150  arg1 = (struct macho *)(argp1);
2151  result = (struct macho_arch *) ((arg1)->mt_archs);
2152  Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_macho_arch,0));
2153  return TCL_OK;
2154fail:
2155  return TCL_ERROR;
2156}
2157
2158
2159static swig_method swig_macho_methods[] = {
2160    {0,0}
2161};
2162static swig_attribute swig_macho_attributes[] = {
2163    { "-mt_archs",_wrap_macho_mt_archs_get, 0 },
2164    {0,0,0}
2165};
2166static swig_class *swig_macho_bases[] = {0};
2167static const char * swig_macho_base_names[] = {0};
2168static swig_class _wrap_class_macho = { "macho", &SWIGTYPE_p_macho,0,0, swig_macho_methods, swig_macho_attributes, swig_macho_bases,swig_macho_base_names, &swig_module };
2169SWIGINTERN int
2170_wrap_create_handle(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2171  struct macho_handle *result = 0 ;
2172 
2173  if (SWIG_GetArgs(interp, objc, objv,":machista::create_handle ") == TCL_ERROR) SWIG_fail;
2174  result = (struct macho_handle *)macho_create_handle();
2175  Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_macho_handle,0));
2176  return TCL_OK;
2177fail:
2178  return TCL_ERROR;
2179}
2180
2181
2182SWIGINTERN int
2183_wrap_destroy_handle(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2184  struct macho_handle *arg1 = (struct macho_handle *) 0 ;
2185  void *argp1 = 0 ;
2186  int res1 = 0 ;
2187 
2188  if (SWIG_GetArgs(interp, objc, objv,"o:machista::destroy_handle INPUT ",(void *)0) == TCL_ERROR) SWIG_fail;
2189  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_macho_handle, 0 |  0 );
2190  if (!SWIG_IsOK(res1)) {
2191    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "destroy_handle" "', argument " "1"" of type '" "struct macho_handle *""'"); 
2192  }
2193  arg1 = (struct macho_handle *)(argp1);
2194  macho_destroy_handle(arg1);
2195 
2196  return TCL_OK;
2197fail:
2198  return TCL_ERROR;
2199}
2200
2201
2202SWIGINTERN int
2203_wrap_parse_file(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2204  struct macho_handle *arg1 = (struct macho_handle *) 0 ;
2205  char *arg2 = (char *) 0 ;
2206  struct macho **arg3 = (struct macho **) 0 ;
2207  void *argp1 = 0 ;
2208  int res1 = 0 ;
2209  int res2 ;
2210  char *buf2 = 0 ;
2211  int alloc2 = 0 ;
2212  struct macho *res3 ;
2213  int result;
2214 
2215  {
2216    arg3 = &res3;
2217  }
2218  if (SWIG_GetArgs(interp, objc, objv,"oo:machista::parse_file handle filename ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2219  res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_macho_handle, 0 |  0 );
2220  if (!SWIG_IsOK(res1)) {
2221    SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "parse_file" "', argument " "1"" of type '" "struct macho_handle *""'"); 
2222  }
2223  arg1 = (struct macho_handle *)(argp1);
2224  res2 = SWIG_AsCharPtrAndSize(objv[2], &buf2, NULL, &alloc2);
2225  if (!SWIG_IsOK(res2)) {
2226    SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "parse_file" "', argument " "2"" of type '" "char const *""'");
2227  }
2228  arg2 = (char *)(buf2);
2229  result = (int)macho_parse_file(arg1,(char const *)arg2,(struct macho const **)arg3);
2230  Tcl_SetObjResult(interp,SWIG_From_int((int)(result)));
2231  {
2232    Tcl_ListObjAppendElement(interp, (Tcl_GetObjResult(interp)), SWIG_NewInstanceObj(SWIG_as_voidptr(*arg3), SWIGTYPE_p_macho, 0));
2233  }
2234  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2235  return TCL_OK;
2236fail:
2237  if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2238  return TCL_ERROR;
2239}
2240
2241
2242SWIGINTERN int
2243_wrap_strerror(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2244  int arg1 ;
2245  int val1 ;
2246  int ecode1 = 0 ;
2247  char *result = 0 ;
2248 
2249  if (SWIG_GetArgs(interp, objc, objv,"o:machista::strerror err ",(void *)0) == TCL_ERROR) SWIG_fail;
2250  ecode1 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[1], &val1);
2251  if (!SWIG_IsOK(ecode1)) {
2252    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "strerror" "', argument " "1"" of type '" "int""'");
2253  } 
2254  arg1 = (int)(val1);
2255  result = (char *)macho_strerror(arg1);
2256  Tcl_SetObjResult(interp,SWIG_FromCharPtr((const char *)result));
2257  return TCL_OK;
2258fail:
2259  return TCL_ERROR;
2260}
2261
2262
2263SWIGINTERN int
2264_wrap_get_arch_name(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2265  cpu_type_t arg1 ;
2266  int val1 ;
2267  int ecode1 = 0 ;
2268  char *result = 0 ;
2269 
2270  if (SWIG_GetArgs(interp, objc, objv,"o:machista::get_arch_name cpu_type_t ",(void *)0) == TCL_ERROR) SWIG_fail;
2271  ecode1 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[1], &val1);
2272  if (!SWIG_IsOK(ecode1)) {
2273    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "get_arch_name" "', argument " "1"" of type '" "cpu_type_t""'");
2274  } 
2275  arg1 = (cpu_type_t)(val1);
2276  result = (char *)macho_get_arch_name(arg1);
2277  Tcl_SetObjResult(interp,SWIG_FromCharPtr((const char *)result));
2278  return TCL_OK;
2279fail:
2280  return TCL_ERROR;
2281}
2282
2283
2284SWIGINTERN int
2285_wrap_format_dylib_version(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2286  uint32_t arg1 ;
2287  unsigned int val1 ;
2288  int ecode1 = 0 ;
2289  char *result = 0 ;
2290 
2291  if (SWIG_GetArgs(interp, objc, objv,"o:machista::format_dylib_version uint32_t ",(void *)0) == TCL_ERROR) SWIG_fail;
2292  ecode1 = SWIG_AsVal_unsigned_SS_int SWIG_TCL_CALL_ARGS_2(objv[1], &val1);
2293  if (!SWIG_IsOK(ecode1)) {
2294    SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "format_dylib_version" "', argument " "1"" of type '" "uint32_t""'");
2295  } 
2296  arg1 = (uint32_t)(val1);
2297  result = (char *)macho_format_dylib_version(arg1);
2298  Tcl_SetObjResult(interp,SWIG_FromCharPtr((const char *)result));
2299  {
2300    free(result);
2301  }
2302  return TCL_OK;
2303fail:
2304  return TCL_ERROR;
2305}
2306
2307
2308
2309static swig_command_info swig_commands[] = {
2310    { SWIG_prefix "macho_handle", (swig_wrapper_func) SWIG_ObjectConstructor, (ClientData)&_wrap_class_macho_handle},
2311    { SWIG_prefix "macho_loadcmd_mlt_install_name_get", (swig_wrapper_func) _wrap_macho_loadcmd_mlt_install_name_get, NULL},
2312    { SWIG_prefix "macho_loadcmd_mlt_type_get", (swig_wrapper_func) _wrap_macho_loadcmd_mlt_type_get, NULL},
2313    { SWIG_prefix "macho_loadcmd_mlt_comp_version_get", (swig_wrapper_func) _wrap_macho_loadcmd_mlt_comp_version_get, NULL},
2314    { SWIG_prefix "macho_loadcmd_mlt_version_get", (swig_wrapper_func) _wrap_macho_loadcmd_mlt_version_get, NULL},
2315    { SWIG_prefix "macho_loadcmd_next_get", (swig_wrapper_func) _wrap_macho_loadcmd_next_get, NULL},
2316    { SWIG_prefix "macho_loadcmd", (swig_wrapper_func) SWIG_ObjectConstructor, (ClientData)&_wrap_class_macho_loadcmd},
2317    { SWIG_prefix "macho_arch_mat_install_name_get", (swig_wrapper_func) _wrap_macho_arch_mat_install_name_get, NULL},
2318    { SWIG_prefix "macho_arch_mat_rpath_get", (swig_wrapper_func) _wrap_macho_arch_mat_rpath_get, NULL},
2319    { SWIG_prefix "macho_arch_mat_arch_get", (swig_wrapper_func) _wrap_macho_arch_mat_arch_get, NULL},
2320    { SWIG_prefix "macho_arch_mat_comp_version_get", (swig_wrapper_func) _wrap_macho_arch_mat_comp_version_get, NULL},
2321    { SWIG_prefix "macho_arch_mat_version_get", (swig_wrapper_func) _wrap_macho_arch_mat_version_get, NULL},
2322    { SWIG_prefix "macho_arch_mat_loadcmds_get", (swig_wrapper_func) _wrap_macho_arch_mat_loadcmds_get, NULL},
2323    { SWIG_prefix "macho_arch_next_get", (swig_wrapper_func) _wrap_macho_arch_next_get, NULL},
2324    { SWIG_prefix "macho_arch", (swig_wrapper_func) SWIG_ObjectConstructor, (ClientData)&_wrap_class_macho_arch},
2325    { SWIG_prefix "macho_mt_archs_get", (swig_wrapper_func) _wrap_macho_mt_archs_get, NULL},
2326    { SWIG_prefix "macho", (swig_wrapper_func) SWIG_ObjectConstructor, (ClientData)&_wrap_class_macho},
2327    { SWIG_prefix "create_handle", (swig_wrapper_func) _wrap_create_handle, NULL},
2328    { SWIG_prefix "destroy_handle", (swig_wrapper_func) _wrap_destroy_handle, NULL},
2329    { SWIG_prefix "parse_file", (swig_wrapper_func) _wrap_parse_file, NULL},
2330    { SWIG_prefix "strerror", (swig_wrapper_func) _wrap_strerror, NULL},
2331    { SWIG_prefix "get_arch_name", (swig_wrapper_func) _wrap_get_arch_name, NULL},
2332    { SWIG_prefix "format_dylib_version", (swig_wrapper_func) _wrap_format_dylib_version, NULL},
2333    {0, 0, 0}
2334};
2335
2336static swig_var_info swig_variables[] = {
2337    {0,0,0,0}
2338};
2339
2340static swig_const_info swig_constants[] = {
2341    {0,0,0,0,0,0}
2342};
2343
2344/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
2345
2346static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
2347static swig_type_info _swigt__p_int = {"_p_int", "int *|cpu_type_t *", 0, 0, (void*)0, 0};
2348static swig_type_info _swigt__p_macho = {"_p_macho", "struct macho *|macho *", 0, 0, (void*)&_wrap_class_macho, 0};
2349static swig_type_info _swigt__p_macho_arch = {"_p_macho_arch", "struct macho_arch *|macho_arch *", 0, 0, (void*)&_wrap_class_macho_arch, 0};
2350static swig_type_info _swigt__p_macho_handle = {"_p_macho_handle", "macho_handle *|struct macho_handle *", 0, 0, (void*)&_wrap_class_macho_handle, 0};
2351static swig_type_info _swigt__p_macho_loadcmd = {"_p_macho_loadcmd", "struct macho_loadcmd *|macho_loadcmd *", 0, 0, (void*)&_wrap_class_macho_loadcmd, 0};
2352static swig_type_info _swigt__p_p_macho = {"_p_p_macho", "struct macho **", 0, 0, (void*)0, 0};
2353static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "uint32_t *|unsigned int *", 0, 0, (void*)0, 0};
2354
2355static swig_type_info *swig_type_initial[] = {
2356  &_swigt__p_char,
2357  &_swigt__p_int,
2358  &_swigt__p_macho,
2359  &_swigt__p_macho_arch,
2360  &_swigt__p_macho_handle,
2361  &_swigt__p_macho_loadcmd,
2362  &_swigt__p_p_macho,
2363  &_swigt__p_unsigned_int,
2364};
2365
2366static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
2367static swig_cast_info _swigc__p_int[] = {  {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
2368static swig_cast_info _swigc__p_macho[] = {  {&_swigt__p_macho, 0, 0, 0},{0, 0, 0, 0}};
2369static swig_cast_info _swigc__p_macho_arch[] = {  {&_swigt__p_macho_arch, 0, 0, 0},{0, 0, 0, 0}};
2370static swig_cast_info _swigc__p_macho_handle[] = {  {&_swigt__p_macho_handle, 0, 0, 0},{0, 0, 0, 0}};
2371static swig_cast_info _swigc__p_macho_loadcmd[] = {  {&_swigt__p_macho_loadcmd, 0, 0, 0},{0, 0, 0, 0}};
2372static swig_cast_info _swigc__p_p_macho[] = {  {&_swigt__p_p_macho, 0, 0, 0},{0, 0, 0, 0}};
2373static swig_cast_info _swigc__p_unsigned_int[] = {  {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
2374
2375static swig_cast_info *swig_cast_initial[] = {
2376  _swigc__p_char,
2377  _swigc__p_int,
2378  _swigc__p_macho,
2379  _swigc__p_macho_arch,
2380  _swigc__p_macho_handle,
2381  _swigc__p_macho_loadcmd,
2382  _swigc__p_p_macho,
2383  _swigc__p_unsigned_int,
2384};
2385
2386
2387/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
2388
2389#ifdef __cplusplus
2390}
2391#endif
2392/* -----------------------------------------------------------------------------
2393 * Type initialization:
2394 * This problem is tough by the requirement that no dynamic
2395 * memory is used. Also, since swig_type_info structures store pointers to
2396 * swig_cast_info structures and swig_cast_info structures store pointers back
2397 * to swig_type_info structures, we need some lookup code at initialization.
2398 * The idea is that swig generates all the structures that are needed.
2399 * The runtime then collects these partially filled structures.
2400 * The SWIG_InitializeModule function takes these initial arrays out of
2401 * swig_module, and does all the lookup, filling in the swig_module.types
2402 * array with the correct data and linking the correct swig_cast_info
2403 * structures together.
2404 *
2405 * The generated swig_type_info structures are assigned statically to an initial
2406 * array. We just loop through that array, and handle each type individually.
2407 * First we lookup if this type has been already loaded, and if so, use the
2408 * loaded structure instead of the generated one. Then we have to fill in the
2409 * cast linked list. The cast data is initially stored in something like a
2410 * two-dimensional array. Each row corresponds to a type (there are the same
2411 * number of rows as there are in the swig_type_initial array). Each entry in
2412 * a column is one of the swig_cast_info structures for that type.
2413 * The cast_initial array is actually an array of arrays, because each row has
2414 * a variable number of columns. So to actually build the cast linked list,
2415 * we find the array of casts associated with the type, and loop through it
2416 * adding the casts to the list. The one last trick we need to do is making
2417 * sure the type pointer in the swig_cast_info struct is correct.
2418 *
2419 * First off, we lookup the cast->type name to see if it is already loaded.
2420 * There are three cases to handle:
2421 *  1) If the cast->type has already been loaded AND the type we are adding
2422 *     casting info to has not been loaded (it is in this module), THEN we
2423 *     replace the cast->type pointer with the type pointer that has already
2424 *     been loaded.
2425 *  2) If BOTH types (the one we are adding casting info to, and the
2426 *     cast->type) are loaded, THEN the cast info has already been loaded by
2427 *     the previous module so we just ignore it.
2428 *  3) Finally, if cast->type has not already been loaded, then we add that
2429 *     swig_cast_info to the linked list (because the cast->type) pointer will
2430 *     be correct.
2431 * ----------------------------------------------------------------------------- */
2432
2433#ifdef __cplusplus
2434extern "C" {
2435#if 0
2436} /* c-mode */
2437#endif
2438#endif
2439
2440#if 0
2441#define SWIGRUNTIME_DEBUG
2442#endif
2443
2444
2445SWIGRUNTIME void
2446SWIG_InitializeModule(void *clientdata) {
2447  size_t i;
2448  swig_module_info *module_head, *iter;
2449  int init;
2450 
2451  /* check to see if the circular list has been setup, if not, set it up */
2452  if (swig_module.next==0) {
2453    /* Initialize the swig_module */
2454    swig_module.type_initial = swig_type_initial;
2455    swig_module.cast_initial = swig_cast_initial;
2456    swig_module.next = &swig_module;
2457    init = 1;
2458  } else {
2459    init = 0;
2460  }
2461 
2462  /* Try and load any already created modules */
2463  module_head = SWIG_GetModule(clientdata);
2464  if (!module_head) {
2465    /* This is the first module loaded for this interpreter */
2466    /* so set the swig module into the interpreter */
2467    SWIG_SetModule(clientdata, &swig_module);
2468  } else {
2469    /* the interpreter has loaded a SWIG module, but has it loaded this one? */
2470    iter=module_head;
2471    do {
2472      if (iter==&swig_module) {
2473        /* Our module is already in the list, so there's nothing more to do. */
2474        return;
2475      }
2476      iter=iter->next;
2477    } while (iter!= module_head);
2478   
2479    /* otherwise we must add our module into the list */
2480    swig_module.next = module_head->next;
2481    module_head->next = &swig_module;
2482  }
2483 
2484  /* When multiple interpreters are used, a module could have already been initialized in
2485       a different interpreter, but not yet have a pointer in this interpreter.
2486       In this case, we do not want to continue adding types... everything should be
2487       set up already */
2488  if (init == 0) return;
2489 
2490  /* Now work on filling in swig_module.types */
2491#ifdef SWIGRUNTIME_DEBUG
2492  printf("SWIG_InitializeModule: size %d\n", swig_module.size);
2493#endif
2494  for (i = 0; i < swig_module.size; ++i) {
2495    swig_type_info *type = 0;
2496    swig_type_info *ret;
2497    swig_cast_info *cast;
2498   
2499#ifdef SWIGRUNTIME_DEBUG
2500    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
2501#endif
2502   
2503    /* if there is another module already loaded */
2504    if (swig_module.next != &swig_module) {
2505      type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
2506    }
2507    if (type) {
2508      /* Overwrite clientdata field */
2509#ifdef SWIGRUNTIME_DEBUG
2510      printf("SWIG_InitializeModule: found type %s\n", type->name);
2511#endif
2512      if (swig_module.type_initial[i]->clientdata) {
2513        type->clientdata = swig_module.type_initial[i]->clientdata;
2514#ifdef SWIGRUNTIME_DEBUG
2515        printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
2516#endif
2517      }
2518    } else {
2519      type = swig_module.type_initial[i];
2520    }
2521   
2522    /* Insert casting types */
2523    cast = swig_module.cast_initial[i];
2524    while (cast->type) {
2525      /* Don't need to add information already in the list */
2526      ret = 0;
2527#ifdef SWIGRUNTIME_DEBUG
2528      printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
2529#endif
2530      if (swig_module.next != &swig_module) {
2531        ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
2532#ifdef SWIGRUNTIME_DEBUG
2533        if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
2534#endif
2535      }
2536      if (ret) {
2537        if (type == swig_module.type_initial[i]) {
2538#ifdef SWIGRUNTIME_DEBUG
2539          printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
2540#endif
2541          cast->type = ret;
2542          ret = 0;
2543        } else {
2544          /* Check for casting already in the list */
2545          swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
2546#ifdef SWIGRUNTIME_DEBUG
2547          if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
2548#endif
2549          if (!ocast) ret = 0;
2550        }
2551      }
2552     
2553      if (!ret) {
2554#ifdef SWIGRUNTIME_DEBUG
2555        printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
2556#endif
2557        if (type->cast) {
2558          type->cast->prev = cast;
2559          cast->next = type->cast;
2560        }
2561        type->cast = cast;
2562      }
2563      cast++;
2564    }
2565    /* Set entry in modules->types array equal to the type */
2566    swig_module.types[i] = type;
2567  }
2568  swig_module.types[i] = 0;
2569 
2570#ifdef SWIGRUNTIME_DEBUG
2571  printf("**** SWIG_InitializeModule: Cast List ******\n");
2572  for (i = 0; i < swig_module.size; ++i) {
2573    int j = 0;
2574    swig_cast_info *cast = swig_module.cast_initial[i];
2575    printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
2576    while (cast->type) {
2577      printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
2578      cast++;
2579      ++j;
2580    }
2581    printf("---- Total casts: %d\n",j);
2582  }
2583  printf("**** SWIG_InitializeModule: Cast List ******\n");
2584#endif
2585}
2586
2587/* This function will propagate the clientdata field of type to
2588* any new swig_type_info structures that have been added into the list
2589* of equivalent types.  It is like calling
2590* SWIG_TypeClientData(type, clientdata) a second time.
2591*/
2592SWIGRUNTIME void
2593SWIG_PropagateClientData(void) {
2594  size_t i;
2595  swig_cast_info *equiv;
2596  static int init_run = 0;
2597 
2598  if (init_run) return;
2599  init_run = 1;
2600 
2601  for (i = 0; i < swig_module.size; i++) {
2602    if (swig_module.types[i]->clientdata) {
2603      equiv = swig_module.types[i]->cast;
2604      while (equiv) {
2605        if (!equiv->converter) {
2606          if (equiv->type && !equiv->type->clientdata)
2607          SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
2608        }
2609        equiv = equiv->next;
2610      }
2611    }
2612  }
2613}
2614
2615#ifdef __cplusplus
2616#if 0
2617{
2618  /* c-mode */
2619#endif
2620}
2621#endif
2622
2623
2624#ifdef __cplusplus
2625extern "C" {
2626#endif
2627 
2628  /* -----------------------------------------------------------------------------
2629   * constants/methods manipulation
2630   * ----------------------------------------------------------------------------- */
2631 
2632  /* Install Constants */
2633 
2634  SWIGINTERN void
2635  SWIG_Tcl_InstallConstants(Tcl_Interp *interp, swig_const_info constants[]) {
2636    size_t i;
2637    Tcl_Obj *obj;
2638   
2639    if (!swigconstTableinit) {
2640      Tcl_InitHashTable(&swigconstTable, TCL_STRING_KEYS);
2641      swigconstTableinit = 1;
2642    }
2643    for (i = 0; constants[i].type; i++) {
2644      switch(constants[i].type) {
2645      case SWIG_TCL_POINTER:
2646        obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
2647        break;
2648      case SWIG_TCL_BINARY:
2649        obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
2650        break;
2651      default:
2652        obj = 0;
2653        break;
2654      }
2655      if (obj) {
2656        SWIG_Tcl_SetConstantObj(interp, constants[i].name, obj);
2657      }
2658    }
2659  }
2660 
2661  /* Create fast method lookup tables */
2662 
2663  SWIGINTERN void
2664  SWIG_Tcl_InstallMethodLookupTables(void) {
2665    size_t i;
2666   
2667    for (i = 0; i < swig_module.size; ++i) {
2668      swig_type_info *type = swig_module.type_initial[i];
2669      if (type->clientdata) {
2670        swig_class* klass = (swig_class*) type->clientdata;
2671        swig_method* meth;
2672        Tcl_InitHashTable(&(klass->hashtable), TCL_STRING_KEYS);
2673        for (meth = klass->methods; meth && meth->name; ++meth) {
2674          int newEntry;
2675          Tcl_HashEntry* hashentry = Tcl_CreateHashEntry(&(klass->hashtable), meth->name, &newEntry);
2676          Tcl_SetHashValue(hashentry, (ClientData)meth->method);
2677        }
2678      }
2679    }
2680  }
2681 
2682#ifdef __cplusplus
2683}
2684#endif
2685
2686/* -----------------------------------------------------------------------------*
2687 *  Partial Init method
2688 * -----------------------------------------------------------------------------*/
2689
2690SWIGEXPORT int SWIG_init(Tcl_Interp *interp) {
2691  size_t i;
2692  if (interp == 0) return TCL_ERROR;
2693#ifdef USE_TCL_STUBS
2694  /* (char*) cast is required to avoid compiler warning/error for Tcl < 8.4. */
2695  if (Tcl_InitStubs(interp, (char*)SWIG_TCL_STUBS_VERSION, 0) == NULL) {
2696    return TCL_ERROR;
2697  }
2698#endif 
2699#ifdef USE_TK_STUBS
2700  /* (char*) cast is required to avoid compiler warning/error. */
2701  if (Tk_InitStubs(interp, (char*)SWIG_TCL_STUBS_VERSION, 0) == NULL) {
2702    return TCL_ERROR;
2703  }
2704#endif
2705 
2706  Tcl_PkgProvide(interp, (char*)SWIG_name, (char*)SWIG_version);
2707 
2708#ifdef SWIG_namespace
2709  Tcl_Eval(interp, "namespace eval " SWIG_namespace " { }");
2710#endif
2711 
2712  SWIG_InitializeModule((void *) interp);
2713  SWIG_PropagateClientData();
2714 
2715  for (i = 0; swig_commands[i].name; i++) {
2716    Tcl_CreateObjCommand(interp, (char *) swig_commands[i].name, (swig_wrapper_func) swig_commands[i].wrapper,
2717      swig_commands[i].clientdata, NULL);
2718  }
2719  for (i = 0; swig_variables[i].name; i++) {
2720    Tcl_SetVar(interp, (char *) swig_variables[i].name, (char *) "", TCL_GLOBAL_ONLY);
2721    Tcl_TraceVar(interp, (char *) swig_variables[i].name, TCL_TRACE_READS | TCL_GLOBAL_ONLY, 
2722      (Tcl_VarTraceProc *) swig_variables[i].get, (ClientData) swig_variables[i].addr);
2723    Tcl_TraceVar(interp, (char *) swig_variables[i].name, TCL_TRACE_WRITES | TCL_GLOBAL_ONLY, 
2724      (Tcl_VarTraceProc *) swig_variables[i].set, (ClientData) swig_variables[i].addr);
2725  }
2726 
2727  SWIG_Tcl_InstallConstants(interp, swig_constants);
2728  SWIG_Tcl_InstallMethodLookupTables();
2729 
2730 
2731  SWIG_Tcl_SetConstantObj(interp, "machista::SUCCESS", SWIG_From_int((int)((0x00))));
2732  SWIG_Tcl_SetConstantObj(interp, "machista::EFILE", SWIG_From_int((int)((0x01))));
2733  SWIG_Tcl_SetConstantObj(interp, "machista::EMMAP", SWIG_From_int((int)((0x02))));
2734  SWIG_Tcl_SetConstantObj(interp, "machista::EMEM", SWIG_From_int((int)((0x04))));
2735  SWIG_Tcl_SetConstantObj(interp, "machista::ERANGE", SWIG_From_int((int)((0x08))));
2736  SWIG_Tcl_SetConstantObj(interp, "machista::EMAGIC", SWIG_From_int((int)((0x10))));
2737  return TCL_OK;
2738}
2739SWIGEXPORT int Machista_SafeInit(Tcl_Interp *interp) {
2740  return SWIG_init(interp);
2741}
2742
Note: See TracBrowser for help on using the repository browser.