crypto/external/bsd/netpgp/dist/bindings/tcl/netpgptcl_wrap.c

   1 /* ----------------------------------------------------------------------------
   2  * This file was automatically generated by SWIG (http://www.swig.org).
   3  * Version 1.3.31
   4  *
   5  * This file is not intended to be easily readable and contains a number of
   6  * coding conventions designed to improve portability and efficiency. Do not make
   7  * changes to this file unless you know what you are doing--modify the SWIG
   8  * interface file instead.
   9  * ----------------------------------------------------------------------------- */
  10
  11 /* -----------------------------------------------------------------------------
  12  *  This section contains generic SWIG labels for method/variable
  13  *  declarations/attributes, and other compiler dependent labels.
  14  * ----------------------------------------------------------------------------- */
  15
  16 /* template workaround for compilers that cannot correctly implement the C++ standard */
  17 #ifndef SWIGTEMPLATEDISAMBIGUATOR
  18 # if defined(__SUNPRO_CC)
  19 #   if (__SUNPRO_CC <= 0x560)
  20 #     define SWIGTEMPLATEDISAMBIGUATOR template
  21 #   else
  22 #     define SWIGTEMPLATEDISAMBIGUATOR
  23 #   endif
  24 # else
  25 #   define SWIGTEMPLATEDISAMBIGUATOR
  26 # endif
  27 #endif
  28
  29 /* inline attribute */
  30 #ifndef SWIGINLINE
  31 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
  32 #   define SWIGINLINE inline
  33 # else
  34 #   define SWIGINLINE
  35 # endif
  36 #endif
  37
  38 /* attribute recognised by some compilers to avoid 'unused' warnings */
  39 #ifndef SWIGUNUSED
  40 # if defined(__GNUC__)
  41 #   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
  42 #     define SWIGUNUSED __attribute__ ((__unused__))
  43 #   else
  44 #     define SWIGUNUSED
  45 #   endif
  46 # elif defined(__ICC)
  47 #   define SWIGUNUSED __attribute__ ((__unused__))
  48 # else
  49 #   define SWIGUNUSED
  50 # endif
  51 #endif
  52
  53 #ifndef SWIGUNUSEDPARM
  54 # ifdef __cplusplus
  55 #   define SWIGUNUSEDPARM(p)
  56 # else
  57 #   define SWIGUNUSEDPARM(p) p SWIGUNUSED
  58 # endif
  59 #endif
  60
  61 /* internal SWIG method */
  62 #ifndef SWIGINTERN
  63 # define SWIGINTERN static SWIGUNUSED
  64 #endif
  65
  66 /* internal inline SWIG method */
  67 #ifndef SWIGINTERNINLINE
  68 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
  69 #endif
  70
  71 /* exporting methods */
  72 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
  73 #  ifndef GCC_HASCLASSVISIBILITY
  74 #    define GCC_HASCLASSVISIBILITY
  75 #  endif
  76 #endif
  77
  78 #ifndef SWIGEXPORT
  79 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
  80 #   if defined(STATIC_LINKED)
  81 #     define SWIGEXPORT
  82 #   else
  83 #     define SWIGEXPORT __declspec(dllexport)
  84 #   endif
  85 # else
  86 #   if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
  87 #     define SWIGEXPORT __attribute__ ((visibility("default")))
  88 #   else
  89 #     define SWIGEXPORT
  90 #   endif
  91 # endif
  92 #endif
  93
  94 /* calling conventions for Windows */
  95 #ifndef SWIGSTDCALL
  96 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
  97 #   define SWIGSTDCALL __stdcall
  98 # else
  99 #   define SWIGSTDCALL
 100 # endif
 101 #endif
 102
 103 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
 104 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
 105 # define _CRT_SECURE_NO_DEPRECATE
 106 #endif
 107
 108
 109 #include <stdio.h>
 110 #include <tcl.h>
 111 #include <errno.h>
 112 #include <stdlib.h>
 113 #include <stdarg.h>
 114 #include <ctype.h>
 115
 116 /* -----------------------------------------------------------------------------
 117  * swigrun.swg
 118  *
 119  * This file contains generic CAPI SWIG runtime support for pointer
 120  * type checking.
 121  * ----------------------------------------------------------------------------- */
 122
 123 /* This should only be incremented when either the layout of swig_type_info changes,
 124    or for whatever reason, the runtime changes incompatibly */
 125 #define SWIG_RUNTIME_VERSION "3"
 126
 127 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
 128 #ifdef SWIG_TYPE_TABLE
 129 # define SWIG_QUOTE_STRING(x) #x
 130 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
 131 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
 132 #else
 133 # define SWIG_TYPE_TABLE_NAME
 134 #endif
 135
 136 /*
 137   You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
 138   creating a static or dynamic library from the swig runtime code.
 139   In 99.9% of the cases, swig just needs to declare them as 'static'.
 140
 141   But only do this if is strictly necessary, ie, if you have problems
 142   with your compiler or so.
 143 */
 144
 145 #ifndef SWIGRUNTIME
 146 # define SWIGRUNTIME SWIGINTERN
 147 #endif
 148
 149 #ifndef SWIGRUNTIMEINLINE
 150 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
 151 #endif
 152
 153 /*  Generic buffer size */
 154 #ifndef SWIG_BUFFER_SIZE
 155 # define SWIG_BUFFER_SIZE 1024
 156 #endif
 157
 158 /* Flags for pointer conversions */
 159 #define SWIG_POINTER_DISOWN        0x1
 160
 161 /* Flags for new pointer objects */
 162 #define SWIG_POINTER_OWN           0x1
 163
 164
 165 /*
 166    Flags/methods for returning states.
 167
 168    The swig conversion methods, as ConvertPtr, return and integer
 169    that tells if the conversion was successful or not. And if not,
 170    an error code can be returned (see swigerrors.swg for the codes).
 171
 172    Use the following macros/flags to set or process the returning
 173    states.
 174
 175    In old swig versions, you usually write code as:
 176
 177      if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
 178        // success code
 179      } else {
 180        //fail code
 181      }
 182
 183    Now you can be more explicit as:
 184
 185     int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
 186     if (SWIG_IsOK(res)) {
 187       // success code
 188     } else {
 189       // fail code
 190     }
 191
 192    that seems to be the same, but now you can also do
 193
 194     Type *ptr;
 195     int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
 196     if (SWIG_IsOK(res)) {
 197       // success code
 198       if (SWIG_IsNewObj(res) {
 199         ...
 200         delete *ptr;
 201       } else {
 202         ...
 203       }
 204     } else {
 205       // fail code
 206     }
 207
 208    I.e., now SWIG_ConvertPtr can return new objects and you can
 209    identify the case and take care of the deallocation. Of course that
 210    requires also to SWIG_ConvertPtr to return new result values, as
 211
 212       int SWIG_ConvertPtr(obj, ptr,...) {
 213         if (<obj is ok>) {
 214           if (<need new object>) {
 215             *ptr = <ptr to new allocated object>;
 216             return SWIG_NEWOBJ;
 217           } else {
 218             *ptr = <ptr to old object>;
 219             return SWIG_OLDOBJ;
 220           }
 221         } else {
 222           return SWIG_BADOBJ;
 223         }
 224       }
 225
 226    Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
 227    more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
 228    swig errors code.
 229
 230    Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
 231    allows to return the 'cast rank', for example, if you have this
 232
 233        int food(double)
 234        int fooi(int);
 235
 236    and you call
 237
 238       food(1)   // cast rank '1'  (1 -> 1.0)
 239       fooi(1)   // cast rank '0'
 240
 241    just use the SWIG_AddCast()/SWIG_CheckState()
 242
 243
 244  */
 245 #define SWIG_OK                    (0)
 246 #define SWIG_ERROR                 (-1)
 247 #define SWIG_IsOK(r)               (r >= 0)
 248 #define SWIG_ArgError(r)           ((r != SWIG_ERROR) ? r : SWIG_TypeError)
 249
 250 /* The CastRankLimit says how many bits are used for the cast rank */
 251 #define SWIG_CASTRANKLIMIT         (1 << 8)
 252 /* The NewMask denotes the object was created (using new/malloc) */
 253 #define SWIG_NEWOBJMASK            (SWIG_CASTRANKLIMIT  << 1)
 254 /* The TmpMask is for in/out typemaps that use temporal objects */
 255 #define SWIG_TMPOBJMASK            (SWIG_NEWOBJMASK << 1)
 256 /* Simple returning values */
 257 #define SWIG_BADOBJ                (SWIG_ERROR)
 258 #define SWIG_OLDOBJ                (SWIG_OK)
 259 #define SWIG_NEWOBJ                (SWIG_OK | SWIG_NEWOBJMASK)
 260 #define SWIG_TMPOBJ                (SWIG_OK | SWIG_TMPOBJMASK)
 261 /* Check, add and del mask methods */
 262 #define SWIG_AddNewMask(r)         (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
 263 #define SWIG_DelNewMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
 264 #define SWIG_IsNewObj(r)           (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
 265 #define SWIG_AddTmpMask(r)         (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
 266 #define SWIG_DelTmpMask(r)         (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
 267 #define SWIG_IsTmpObj(r)           (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
 268
 269
 270 /* Cast-Rank Mode */
 271 #if defined(SWIG_CASTRANK_MODE)
 272 #  ifndef SWIG_TypeRank
 273 #    define SWIG_TypeRank             unsigned long
 274 #  endif
 275 #  ifndef SWIG_MAXCASTRANK            /* Default cast allowed */
 276 #    define SWIG_MAXCASTRANK          (2)
 277 #  endif
 278 #  define SWIG_CASTRANKMASK          ((SWIG_CASTRANKLIMIT) -1)
 279 #  define SWIG_CastRank(r)           (r & SWIG_CASTRANKMASK)
 280 SWIGINTERNINLINE int SWIG_AddCast(int r) {
 281   return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
 282 }
 283 SWIGINTERNINLINE int SWIG_CheckState(int r) {
 284   return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
 285 }
 286 #else /* no cast-rank mode */
 287 #  define SWIG_AddCast
 288 #  define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
 289 #endif
 290
 291
 292
 293
 294 #include <string.h>
 295
 296 #ifdef __cplusplus
 297 extern "C" {
 298 #endif
 299
 300 typedef void *(*swig_converter_func)(void *);
 301 typedef struct swig_type_info *(*swig_dycast_func)(void **);
 302
 303 /* Structure to store inforomation on one type */
 304 typedef struct swig_type_info {
 305   const char             *name;                 /* mangled name of this type */
 306   const char             *str;                  /* human readable name of this type */
 307   swig_dycast_func        dcast;                /* dynamic cast function down a hierarchy */
 308   struct swig_cast_info  *cast;                 /* linked list of types that can cast into this type */
 309   void                   *clientdata;           /* language specific type data */
 310   int                    owndata;               /* flag if the structure owns the clientdata */
 311 } swig_type_info;
 312
 313 /* Structure to store a type and conversion function used for casting */
 314 typedef struct swig_cast_info {
 315   swig_type_info         *type;                 /* pointer to type that is equivalent to this type */
 316   swig_converter_func     converter;            /* function to cast the void pointers */
 317   struct swig_cast_info  *next;                 /* pointer to next cast in linked list */
 318   struct swig_cast_info  *prev;                 /* pointer to the previous cast */
 319 } swig_cast_info;
 320
 321 /* Structure used to store module information
 322  * Each module generates one structure like this, and the runtime collects
 323  * all of these structures and stores them in a circularly linked list.*/
 324 typedef struct swig_module_info {
 325   swig_type_info         **types;               /* Array of pointers to swig_type_info structures that are in this module */
 326   size_t                 size;                  /* Number of types in this module */
 327   struct swig_module_info *next;                /* Pointer to next element in circularly linked list */
 328   swig_type_info         **type_initial;        /* Array of initially generated type structures */
 329   swig_cast_info         **cast_initial;        /* Array of initially generated casting structures */
 330   void                    *clientdata;          /* Language specific module data */
 331 } swig_module_info;
 332
 333 /*
 334   Compare two type names skipping the space characters, therefore
 335   "char*" == "char *" and "Class<int>" == "Class<int >", etc.
 336
 337   Return 0 when the two name types are equivalent, as in
 338   strncmp, but skipping ' '.
 339 */
 340 SWIGRUNTIME int
 341 SWIG_TypeNameComp(const char *f1, const char *l1,
 342                   const char *f2, const char *l2) {
 343   for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
 344     while ((*f1 == ' ') && (f1 != l1)) ++f1;
 345     while ((*f2 == ' ') && (f2 != l2)) ++f2;
 346     if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
 347   }
 348   return (l1 - f1) - (l2 - f2);
 349 }
 350
 351 /*
 352   Check type equivalence in a name list like <name1>|<name2>|...
 353   Return 0 if not equal, 1 if equal
 354 */
 355 SWIGRUNTIME int
 356 SWIG_TypeEquiv(const char *nb, const char *tb) {
 357   int equiv = 0;
 358   const char* te = tb + strlen(tb);
 359   const char* ne = nb;
 360   while (!equiv && *ne) {
 361     for (nb = ne; *ne; ++ne) {
 362       if (*ne == '|') break;
 363     }
 364     equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
 365     if (*ne) ++ne;
 366   }
 367   return equiv;
 368 }
 369
 370 /*
 371   Check type equivalence in a name list like <name1>|<name2>|...
 372   Return 0 if equal, -1 if nb < tb, 1 if nb > tb
 373 */
 374 SWIGRUNTIME int
 375 SWIG_TypeCompare(const char *nb, const char *tb) {
 376   int equiv = 0;
 377   const char* te = tb + strlen(tb);
 378   const char* ne = nb;
 379   while (!equiv && *ne) {
 380     for (nb = ne; *ne; ++ne) {
 381       if (*ne == '|') break;
 382     }
 383     equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
 384     if (*ne) ++ne;
 385   }
 386   return equiv;
 387 }
 388
 389
 390 /* think of this as a c++ template<> or a scheme macro */
 391 #define SWIG_TypeCheck_Template(comparison, ty)         \
 392   if (ty) {                                             \
 393     swig_cast_info *iter = ty->cast;                    \
 394     while (iter) {                                      \
 395       if (comparison) {                                 \
 396         if (iter == ty->cast) return iter;              \
 397         /* Move iter to the top of the linked list */   \
 398         iter->prev->next = iter->next;                  \
 399         if (iter->next)                                 \
 400           iter->next->prev = iter->prev;                \
 401         iter->next = ty->cast;                          \
 402         iter->prev = 0;                                 \
 403         if (ty->cast) ty->cast->prev = iter;            \
 404         ty->cast = iter;                                \
 405         return iter;                                    \
 406       }                                                 \
 407       iter = iter->next;                                \
 408     }                                                   \
 409   }                                                     \
 410   return 0
 411
 412 /*
 413   Check the typename
 414 */
 415 SWIGRUNTIME swig_cast_info *
 416 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
 417   SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
 418 }
 419
 420 /* Same as previous function, except strcmp is replaced with a pointer comparison */
 421 SWIGRUNTIME swig_cast_info *
 422 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
 423   SWIG_TypeCheck_Template(iter->type == from, into);
 424 }
 425
 426 /*
 427   Cast a pointer up an inheritance hierarchy
 428 */
 429 SWIGRUNTIMEINLINE void *
 430 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
 431   return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
 432 }
 433
 434 /*
 435    Dynamic pointer casting. Down an inheritance hierarchy
 436 */
 437 SWIGRUNTIME swig_type_info *
 438 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
 439   swig_type_info *lastty = ty;
 440   if (!ty || !ty->dcast) return ty;
 441   while (ty && (ty->dcast)) {
 442     ty = (*ty->dcast)(ptr);
 443     if (ty) lastty = ty;
 444   }
 445   return lastty;
 446 }
 447
 448 /*
 449   Return the name associated with this type
 450 */
 451 SWIGRUNTIMEINLINE const char *
 452 SWIG_TypeName(const swig_type_info *ty) {
 453   return ty->name;
 454 }
 455
 456 /*
 457   Return the pretty name associated with this type,
 458   that is an unmangled type name in a form presentable to the user.
 459 */
 460 SWIGRUNTIME const char *
 461 SWIG_TypePrettyName(const swig_type_info *type) {
 462   /* The "str" field contains the equivalent pretty names of the
 463      type, separated by vertical-bar characters.  We choose
 464      to print the last name, as it is often (?) the most
 465      specific. */
 466   if (!type) return NULL;
 467   if (type->str != NULL) {
 468     const char *last_name = type->str;
 469     const char *s;
 470     for (s = type->str; *s; s++)
 471       if (*s == '|') last_name = s+1;
 472     return last_name;
 473   }
 474   else
 475     return type->name;
 476 }
 477
 478 /*
 479    Set the clientdata field for a type
 480 */
 481 SWIGRUNTIME void
 482 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
 483   swig_cast_info *cast = ti->cast;
 484   /* if (ti->clientdata == clientdata) return; */
 485   ti->clientdata = clientdata;
 486
 487   while (cast) {
 488     if (!cast->converter) {
 489       swig_type_info *tc = cast->type;
 490       if (!tc->clientdata) {
 491         SWIG_TypeClientData(tc, clientdata);
 492       }
 493     }
 494     cast = cast->next;
 495   }
 496 }
 497 SWIGRUNTIME void
 498 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
 499   SWIG_TypeClientData(ti, clientdata);
 500   ti->owndata = 1;
 501 }
 502
 503 /*
 504   Search for a swig_type_info structure only by mangled name
 505   Search is a O(log #types)
 506
 507   We start searching at module start, and finish searching when start == end.
 508   Note: if start == end at the beginning of the function, we go all the way around
 509   the circular list.
 510 */
 511 SWIGRUNTIME swig_type_info *
 512 SWIG_MangledTypeQueryModule(swig_module_info *start,
 513                             swig_module_info *end,
 514                             const char *name) {
 515   swig_module_info *iter = start;
 516   do {
 517     if (iter->size) {
 518       register size_t l = 0;
 519       register size_t r = iter->size - 1;
 520       do {
 521         /* since l+r >= 0, we can (>> 1) instead (/ 2) */
 522         register size_t i = (l + r) >> 1;
 523         const char *iname = iter->types[i]->name;
 524         if (iname) {
 525           register int compare = strcmp(name, iname);
 526           if (compare == 0) {
 527             return iter->types[i];
 528           } else if (compare < 0) {
 529             if (i) {
 530               r = i - 1;
 531             } else {
 532               break;
 533             }
 534           } else if (compare > 0) {
 535             l = i + 1;
 536           }
 537         } else {
 538           break; /* should never happen */
 539         }
 540       } while (l <= r);
 541     }
 542     iter = iter->next;
 543   } while (iter != end);
 544   return 0;
 545 }
 546
 547 /*
 548   Search for a swig_type_info structure for either a mangled name or a human readable name.
 549   It first searches the mangled names of the types, which is a O(log #types)
 550   If a type is not found it then searches the human readable names, which is O(#types).
 551
 552   We start searching at module start, and finish searching when start == end.
 553   Note: if start == end at the beginning of the function, we go all the way around
 554   the circular list.
 555 */
 556 SWIGRUNTIME swig_type_info *
 557 SWIG_TypeQueryModule(swig_module_info *start,
 558                      swig_module_info *end,
 559                      const char *name) {
 560   /* STEP 1: Search the name field using binary search */
 561   swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
 562   if (ret) {
 563     return ret;
 564   } else {
 565     /* STEP 2: If the type hasn't been found, do a complete search
 566        of the str field (the human readable name) */
 567     swig_module_info *iter = start;
 568     do {
 569       register size_t i = 0;
 570       for (; i < iter->size; ++i) {
 571         if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
 572           return iter->types[i];
 573       }
 574       iter = iter->next;
 575     } while (iter != end);
 576   }
 577
 578   /* neither found a match */
 579   return 0;
 580 }
 581
 582 /*
 583    Pack binary data into a string
 584 */
 585 SWIGRUNTIME char *
 586 SWIG_PackData(char *c, void *ptr, size_t sz) {
 587   static const char hex[17] = "0123456789abcdef";
 588   register const unsigned char *u = (unsigned char *) ptr;
 589   register const unsigned char *eu =  u + sz;
 590   for (; u != eu; ++u) {
 591     register unsigned char uu = *u;
 592     *(c++) = hex[(uu & 0xf0) >> 4];
 593     *(c++) = hex[uu & 0xf];
 594   }
 595   return c;
 596 }
 597
 598 /*
 599    Unpack binary data from a string
 600 */
 601 SWIGRUNTIME const char *
 602 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
 603   register unsigned char *u = (unsigned char *) ptr;
 604   register const unsigned char *eu = u + sz;
 605   for (; u != eu; ++u) {
 606     register char d = *(c++);
 607     register unsigned char uu;
 608     if ((d >= '0') && (d <= '9'))
 609       uu = ((d - '0') << 4);
 610     else if ((d >= 'a') && (d <= 'f'))
 611       uu = ((d - ('a'-10)) << 4);
 612     else
 613       return (char *) 0;
 614     d = *(c++);
 615     if ((d >= '0') && (d <= '9'))
 616       uu |= (d - '0');
 617     else if ((d >= 'a') && (d <= 'f'))
 618       uu |= (d - ('a'-10));
 619     else
 620       return (char *) 0;
 621     *u = uu;
 622   }
 623   return c;
 624 }
 625
 626 /*
 627    Pack 'void *' into a string buffer.
 628 */
 629 SWIGRUNTIME char *
 630 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
 631   char *r = buff;
 632   if ((2*sizeof(void *) + 2) > bsz) return 0;
 633   *(r++) = '_';
 634   r = SWIG_PackData(r,&ptr,sizeof(void *));
 635   if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
 636   strcpy(r,name);
 637   return buff;
 638 }
 639
 640 SWIGRUNTIME const char *
 641 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
 642   if (*c != '_') {
 643     if (strcmp(c,"NULL") == 0) {
 644       *ptr = (void *) 0;
 645       return name;
 646     } else {
 647       return 0;
 648     }
 649   }
 650   return SWIG_UnpackData(++c,ptr,sizeof(void *));
 651 }
 652
 653 SWIGRUNTIME char *
 654 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
 655   char *r = buff;
 656   size_t lname = (name ? strlen(name) : 0);
 657   if ((2*sz + 2 + lname) > bsz) return 0;
 658   *(r++) = '_';
 659   r = SWIG_PackData(r,ptr,sz);
 660   if (lname) {
 661     strncpy(r,name,lname+1);
 662   } else {
 663     *r = 0;
 664   }
 665   return buff;
 666 }
 667
 668 SWIGRUNTIME const char *
 669 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
 670   if (*c != '_') {
 671     if (strcmp(c,"NULL") == 0) {
 672       memset(ptr,0,sz);
 673       return name;
 674     } else {
 675       return 0;
 676     }
 677   }
 678   return SWIG_UnpackData(++c,ptr,sz);
 679 }
 680
 681 #ifdef __cplusplus
 682 }
 683 #endif
 684
 685 /*  Errors in SWIG */
 686 #define  SWIG_UnknownError         -1
 687 #define  SWIG_IOError              -2
 688 #define  SWIG_RuntimeError         -3
 689 #define  SWIG_IndexError           -4
 690 #define  SWIG_TypeError            -5
 691 #define  SWIG_DivisionByZero       -6
 692 #define  SWIG_OverflowError        -7
 693 #define  SWIG_SyntaxError          -8
 694 #define  SWIG_ValueError           -9
 695 #define  SWIG_SystemError          -10
 696 #define  SWIG_AttributeError       -11
 697 #define  SWIG_MemoryError          -12
 698 #define  SWIG_NullReferenceError   -13
 699
 700
 701
 702 /* -----------------------------------------------------------------------------
 703  * error manipulation
 704  * ----------------------------------------------------------------------------- */
 705
 706 SWIGINTERN const char*
 707 SWIG_Tcl_ErrorType(int code) {
 708   const char* type = 0;
 709   switch(code) {
 710   case SWIG_MemoryError:
 711     type = "MemoryError";
 712     break;
 713   case SWIG_IOError:
 714     type = "IOError";
 715     break;
 716   case SWIG_RuntimeError:
 717     type = "RuntimeError";
 718     break;
 719   case SWIG_IndexError:
 720     type = "IndexError";
 721     break;
 722   case SWIG_TypeError:
 723     type = "TypeError";
 724     break;
 725   case SWIG_DivisionByZero:
 726     type = "ZeroDivisionError";
 727     break;
 728   case SWIG_OverflowError:
 729     type = "OverflowError";
 730     break;
 731   case SWIG_SyntaxError:
 732     type = "SyntaxError";
 733     break;
 734   case SWIG_ValueError:
 735     type = "ValueError";
 736     break;
 737   case SWIG_SystemError:
 738     type = "SystemError";
 739     break;
 740   case SWIG_AttributeError:
 741     type = "AttributeError";
 742     break;
 743   default:
 744     type = "RuntimeError";
 745   }
 746   return type;
 747 }
 748
 749
 750 SWIGINTERN void
 751 SWIG_Tcl_SetErrorObj(Tcl_Interp *interp, const char *ctype, Tcl_Obj *obj)
 752 {
 753   Tcl_ResetResult(interp);
 754   Tcl_SetObjResult(interp, obj);
 755   Tcl_SetErrorCode(interp, "SWIG", ctype, NULL);
 756 }
 757
 758 SWIGINTERN void
 759 SWIG_Tcl_SetErrorMsg(Tcl_Interp *interp, const char *ctype, const char *mesg)
 760 {
 761   Tcl_ResetResult(interp);
 762   Tcl_SetErrorCode(interp, "SWIG", ctype, NULL);
 763   Tcl_AppendResult(interp, ctype, " ", mesg, NULL);
 764   /*
 765   Tcl_AddErrorInfo(interp, ctype);
 766   Tcl_AddErrorInfo(interp, " ");
 767   Tcl_AddErrorInfo(interp, mesg);
 768   */
 769 }
 770
 771 SWIGINTERNINLINE void
 772 SWIG_Tcl_AddErrorMsg(Tcl_Interp *interp, const char* mesg)
 773 {
 774   Tcl_AddErrorInfo(interp, mesg);
 775 }
 776
 777
 778
 779 /* -----------------------------------------------------------------------------
 780  * SWIG API. Portion that goes into the runtime
 781  * ----------------------------------------------------------------------------- */
 782 #ifdef __cplusplus
 783 extern "C" {
 784 #endif
 785
 786 /* -----------------------------------------------------------------------------
 787  * Constant declarations
 788  * ----------------------------------------------------------------------------- */
 789
 790 /* Constant Types */
 791 #define SWIG_TCL_POINTER 4
 792 #define SWIG_TCL_BINARY  5
 793
 794 /* Constant information structure */
 795 typedef struct swig_const_info {
 796     int type;
 797     char *name;
 798     long lvalue;
 799     double dvalue;
 800     void   *pvalue;
 801     swig_type_info **ptype;
 802 } swig_const_info;
 803
 804 typedef int   (*swig_wrapper)(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST []);
 805 typedef int   (*swig_wrapper_func)(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST []);
 806 typedef char *(*swig_variable_func)(ClientData, Tcl_Interp *, char *, char *, int);
 807 typedef void  (*swig_delete_func)(ClientData);
 808
 809 typedef struct swig_method {
 810   const char     *name;
 811   swig_wrapper   method;
 812 } swig_method;
 813
 814 typedef struct swig_attribute {
 815   const char     *name;
 816   swig_wrapper   getmethod;
 817   swig_wrapper   setmethod;
 818 } swig_attribute;
 819
 820 typedef struct swig_class {
 821   const char         *name;
 822   swig_type_info   **type;
 823   swig_wrapper       constructor;
 824   void              (*destructor)(void *);
 825   swig_method        *methods;
 826   swig_attribute     *attributes;
 827   struct swig_class **bases;
 828   char              **base_names;
 829   swig_module_info   *module;
 830 } swig_class;
 831
 832 typedef struct swig_instance {
 833   Tcl_Obj       *thisptr;
 834   void          *thisvalue;
 835   swig_class   *classptr;
 836   int            destroy;
 837   Tcl_Command    cmdtok;
 838 } swig_instance;
 839
 840 /* Structure for command table */
 841 typedef struct {
 842   const char *name;
 843   int       (*wrapper)(ClientData, Tcl_Interp *, int, Tcl_Obj *CONST []);
 844   ClientData  clientdata;
 845 } swig_command_info;
 846
 847 /* Structure for variable linking table */
 848 typedef struct {
 849   const char *name;
 850   void *addr;
 851   char * (*get)(ClientData, Tcl_Interp *, char *, char *, int);
 852   char * (*set)(ClientData, Tcl_Interp *, char *, char *, int);
 853 } swig_var_info;
 854
 855
 856 /* -----------------------------------------------------------------------------*
 857  *  Install a constant object
 858  * -----------------------------------------------------------------------------*/
 859
 860 static Tcl_HashTable   swigconstTable;
 861 static int             swigconstTableinit = 0;
 862
 863 SWIGINTERN void
 864 SWIG_Tcl_SetConstantObj(Tcl_Interp *interp, const char* name, Tcl_Obj *obj) {
 865   int newobj;
 866   Tcl_ObjSetVar2(interp,Tcl_NewStringObj(name,-1), NULL, obj, TCL_GLOBAL_ONLY);
 867   Tcl_SetHashValue(Tcl_CreateHashEntry(&swigconstTable, name, &newobj), (ClientData) obj);
 868 }
 869
 870 SWIGINTERN Tcl_Obj *
 871 SWIG_Tcl_GetConstantObj(const char *key) {
 872   Tcl_HashEntry *entryPtr;
 873   if (!swigconstTableinit) return 0;
 874   entryPtr = Tcl_FindHashEntry(&swigconstTable, key);
 875   if (entryPtr) {
 876     return (Tcl_Obj *) Tcl_GetHashValue(entryPtr);
 877   }
 878   return 0;
 879 }
 880
 881 #ifdef __cplusplus
 882 }
 883 #endif
 884
 885
 886
 887 /* -----------------------------------------------------------------------------
 888  * See the LICENSE file for information on copyright, usage and redistribution
 889  * of SWIG, and the README file for authors - http://www.swig.org/release.html.
 890  *
 891  * tclrun.swg
 892  *
 893  * This file contains the runtime support for Tcl modules and includes
 894  * code for managing global variables and pointer type checking.
 895  * ----------------------------------------------------------------------------- */
 896
 897 /* Common SWIG API */
 898
 899 /* for raw pointers */
 900 #define SWIG_ConvertPtr(oc, ptr, ty, flags)             SWIG_Tcl_ConvertPtr(interp, oc, ptr, ty, flags)
 901 #define SWIG_NewPointerObj(ptr, type, flags)            SWIG_Tcl_NewPointerObj(ptr, type, flags)
 902
 903 /* for raw packed data */
 904 #define SWIG_ConvertPacked(obj, ptr, sz, ty)            SWIG_Tcl_ConvertPacked(interp, obj, ptr, sz, ty)
 905 #define SWIG_NewPackedObj(ptr, sz, type)                SWIG_Tcl_NewPackedObj(ptr, sz, type)
 906
 907 /* for class or struct pointers */
 908 #define SWIG_ConvertInstance(obj, pptr, type, flags)    SWIG_Tcl_ConvertPtr(interp, obj, pptr, type, flags)
 909 #define SWIG_NewInstanceObj(thisvalue, type, flags)     SWIG_Tcl_NewInstanceObj(interp, thisvalue, type, flags)
 910
 911 /* for C or C++ function pointers */
 912 #define SWIG_ConvertFunctionPtr(obj, pptr, type)        SWIG_Tcl_ConvertPtr(interp, obj, pptr, type, 0)
 913 #define SWIG_NewFunctionPtrObj(ptr, type)               SWIG_Tcl_NewPointerObj(ptr, type, 0)
 914
 915 /* for C++ member pointers, ie, member methods */
 916 #define SWIG_ConvertMember(obj, ptr, sz, ty)            SWIG_Tcl_ConvertPacked(interp,obj, ptr, sz, ty)
 917 #define SWIG_NewMemberObj(ptr, sz, type)                SWIG_Tcl_NewPackedObj(ptr, sz, type)
 918
 919
 920 /* Runtime API */
 921
 922 #define SWIG_GetModule(clientdata)                      SWIG_Tcl_GetModule((Tcl_Interp *) (clientdata))
 923 #define SWIG_SetModule(clientdata, pointer)             SWIG_Tcl_SetModule((Tcl_Interp *) (clientdata), pointer)
 924
 925
 926 /* Error manipulation */
 927
 928 #define SWIG_ErrorType(code)                            SWIG_Tcl_ErrorType(code)
 929 #define SWIG_Error(code, msg)                           SWIG_Tcl_SetErrorMsg(interp, SWIG_Tcl_ErrorType(code), msg)
 930 #define SWIG_fail                                       goto fail
 931
 932
 933 /* Tcl-specific SWIG API */
 934
 935 #define SWIG_Acquire(ptr)                               SWIG_Tcl_Acquire(ptr)
 936 #define SWIG_MethodCommand                              SWIG_Tcl_MethodCommand
 937 #define SWIG_Disown(ptr)                                SWIG_Tcl_Disown(ptr)
 938 #define SWIG_ConvertPtrFromString(c, ptr, ty, flags)    SWIG_Tcl_ConvertPtrFromString(interp, c, ptr, ty, flags)
 939 #define SWIG_MakePtr(c, ptr, ty, flags)                 SWIG_Tcl_MakePtr(c, ptr, ty, flags)
 940 #define SWIG_PointerTypeFromString(c)                   SWIG_Tcl_PointerTypeFromString(c)
 941 #define SWIG_GetArgs                                    SWIG_Tcl_GetArgs
 942 #define SWIG_GetConstantObj(key)                        SWIG_Tcl_GetConstantObj(key)
 943 #define SWIG_ObjectConstructor                          SWIG_Tcl_ObjectConstructor
 944 #define SWIG_Thisown(ptr)                               SWIG_Tcl_Thisown(ptr)
 945 #define SWIG_ObjectDelete                               SWIG_Tcl_ObjectDelete
 946
 947
 948 #define SWIG_TCL_DECL_ARGS_2(arg1, arg2)                (Tcl_Interp *interp SWIGUNUSED, arg1, arg2)
 949 #define SWIG_TCL_CALL_ARGS_2(arg1, arg2)                (interp, arg1, arg2)
 950 /* -----------------------------------------------------------------------------
 951  * pointers/data manipulation
 952  * ----------------------------------------------------------------------------- */
 953
 954 /* For backward compatibility only */
 955 #define SWIG_POINTER_EXCEPTION  0
 956 #define SWIG_GetConstant        SWIG_GetConstantObj
 957 #define SWIG_Tcl_GetConstant    SWIG_Tcl_GetConstantObj
 958
 959
 960 #ifdef __cplusplus
 961 extern "C" {
 962 #if 0
 963 } /* cc-mode */
 964 #endif
 965 #endif
 966
 967 /* Object support */
 968
 969 SWIGRUNTIME Tcl_HashTable*
 970 SWIG_Tcl_ObjectTable(void) {
 971   static Tcl_HashTable  swigobjectTable;
 972   static int            swigobjectTableinit = 0;
 973   if (!swigobjectTableinit) {
 974     Tcl_InitHashTable(&swigobjectTable, TCL_ONE_WORD_KEYS);
 975     swigobjectTableinit = 1;
 976   }
 977   return &swigobjectTable;
 978 }
 979
 980 /* Acquire ownership of a pointer */
 981 SWIGRUNTIME void
 982 SWIG_Tcl_Acquire(void *ptr) {
 983   int newobj;
 984   Tcl_CreateHashEntry(SWIG_Tcl_ObjectTable(), (char *) ptr, &newobj);
 985 }
 986
 987 SWIGRUNTIME int
 988 SWIG_Tcl_Thisown(void *ptr) {
 989   if (Tcl_FindHashEntry(SWIG_Tcl_ObjectTable(), (char *) ptr)) {
 990     return 1;
 991   }
 992   return 0;
 993 }
 994
 995 /* Disown a pointer.  Returns 1 if we owned it to begin with */
 996 SWIGRUNTIME int
 997 SWIG_Tcl_Disown(void *ptr) {
 998   Tcl_HashEntry *entryPtr = Tcl_FindHashEntry(SWIG_Tcl_ObjectTable(), (char *) ptr);
 999   if (entryPtr) {
1000     Tcl_DeleteHashEntry(entryPtr);
1001     return 1;
1002   }
1003   return 0;
1004 }
1005
1006 /* Convert a pointer value */
1007 SWIGRUNTIME int
1008 SWIG_Tcl_ConvertPtrFromString(Tcl_Interp *interp, const char *c, void **ptr, swig_type_info *ty, int flags) {
1009   swig_cast_info *tc;
1010   /* Pointer values must start with leading underscore */
1011   while (*c != '_') {
1012     *ptr = (void *) 0;
1013     if (strcmp(c,"NULL") == 0) return SWIG_OK;
1014     /* Hmmm. It could be an object name. */
1015     if (Tcl_VarEval(interp,c," cget -this", (char *) NULL) == TCL_OK) {
1016       Tcl_Obj *result = Tcl_GetObjResult(interp);
1017       c = Tcl_GetStringFromObj(result, NULL);
1018       continue;
1019     }
1020     Tcl_ResetResult(interp);
1021     return SWIG_ERROR;
1022   }
1023   c++;
1024   c = SWIG_UnpackData(c,ptr,sizeof(void *));
1025   if (ty) {
1026     tc = c ? SWIG_TypeCheck(c,ty) : 0;
1027     if (!tc) {
1028       return SWIG_ERROR;
1029     }
1030     if (flags & SWIG_POINTER_DISOWN) {
1031       SWIG_Disown((void *) *ptr);
1032     }
1033     *ptr = SWIG_TypeCast(tc,(void *) *ptr);
1034   }
1035   return SWIG_OK;
1036 }
1037
1038 /* Convert a pointer value */
1039 SWIGRUNTIMEINLINE int
1040 SWIG_Tcl_ConvertPtr(Tcl_Interp *interp, Tcl_Obj *oc, void **ptr, swig_type_info *ty, int flags) {
1041   return SWIG_Tcl_ConvertPtrFromString(interp, Tcl_GetStringFromObj(oc,NULL), ptr, ty, flags);
1042 }
1043
1044 /* Convert a pointer value */
1045 SWIGRUNTIME char *
1046 SWIG_Tcl_PointerTypeFromString(char *c) {
1047   char d;
1048   /* Pointer values must start with leading underscore. NULL has no type */
1049   if (*c != '_') {
1050     return 0;
1051   }
1052   c++;
1053   /* Extract hex value from pointer */
1054   while ((d = *c)) {
1055     if (!(((d >= '0') && (d <= '9')) || ((d >= 'a') && (d <= 'f')))) break;
1056     c++;
1057   }
1058   return c;
1059 }
1060
1061 /* Convert a packed value value */
1062 SWIGRUNTIME int
1063 SWIG_Tcl_ConvertPacked(Tcl_Interp *SWIGUNUSEDPARM(interp) , Tcl_Obj *obj, void *ptr, int sz, swig_type_info *ty) {
1064   swig_cast_info *tc;
1065   const char  *c;
1066
1067   if (!obj) goto type_error;
1068   c = Tcl_GetStringFromObj(obj,NULL);
1069   /* Pointer values must start with leading underscore */
1070   if (*c != '_') goto type_error;
1071   c++;
1072   c = SWIG_UnpackData(c,ptr,sz);
1073   if (ty) {
1074     tc = SWIG_TypeCheck(c,ty);
1075     if (!tc) goto type_error;
1076   }
1077   return SWIG_OK;
1078
1079  type_error:
1080
1081   return SWIG_ERROR;
1082 }
1083
1084
1085 /* Take a pointer and convert it to a string */
1086 SWIGRUNTIME void
1087 SWIG_Tcl_MakePtr(char *c, void *ptr, swig_type_info *ty, int flags) {
1088   if (ptr) {
1089     *(c++) = '_';
1090     c = SWIG_PackData(c,&ptr,sizeof(void *));
1091     strcpy(c,ty->name);
1092   } else {
1093     strcpy(c,(char *)"NULL");
1094   }
1095   flags = 0;
1096 }
1097
1098 /* Create a new pointer object */
1099 SWIGRUNTIMEINLINE Tcl_Obj *
1100 SWIG_Tcl_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
1101   Tcl_Obj *robj;
1102   char result[SWIG_BUFFER_SIZE];
1103   SWIG_MakePtr(result,ptr,type,flags);
1104   robj = Tcl_NewStringObj(result,-1);
1105   return robj;
1106 }
1107
1108 SWIGRUNTIME Tcl_Obj *
1109 SWIG_Tcl_NewPackedObj(void *ptr, int sz, swig_type_info *type) {
1110   char result[1024];
1111   char *r = result;
1112   if ((2*sz + 1 + strlen(type->name)) > 1000) return 0;
1113   *(r++) = '_';
1114   r = SWIG_PackData(r,ptr,sz);
1115   strcpy(r,type->name);
1116   return Tcl_NewStringObj(result,-1);
1117 }
1118
1119 /* -----------------------------------------------------------------------------*
1120  *  Get type list
1121  * -----------------------------------------------------------------------------*/
1122
1123 SWIGRUNTIME swig_module_info *
1124 SWIG_Tcl_GetModule(Tcl_Interp *interp) {
1125   const char *data;
1126   swig_module_info *ret = 0;
1127
1128   /* first check if pointer already created */
1129   data = Tcl_GetVar(interp, (char *)"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, TCL_GLOBAL_ONLY);
1130   if (data) {
1131     SWIG_UnpackData(data, &ret, sizeof(swig_type_info **));
1132   }
1133
1134   return ret;
1135 }
1136
1137 SWIGRUNTIME void
1138 SWIG_Tcl_SetModule(Tcl_Interp *interp, swig_module_info *module) {
1139   char buf[SWIG_BUFFER_SIZE];
1140   char *data;
1141
1142   /* create a new pointer */
1143   data = SWIG_PackData(buf, &module, sizeof(swig_type_info **));
1144   *data = 0;
1145   Tcl_SetVar(interp, (char *)"swig_runtime_data_type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, buf, 0);
1146 }
1147
1148 /* -----------------------------------------------------------------------------*
1149  *  Object auxiliars
1150  * -----------------------------------------------------------------------------*/
1151
1152
1153 SWIGRUNTIME void
1154 SWIG_Tcl_ObjectDelete(ClientData clientData) {
1155   swig_instance *si = (swig_instance *) clientData;
1156   if ((si) && (si->destroy) && (SWIG_Disown(si->thisvalue))) {
1157     if (si->classptr->destructor) {
1158       (si->classptr->destructor)(si->thisvalue);
1159     }
1160   }
1161   Tcl_DecrRefCount(si->thisptr);
1162   free(si);
1163 }
1164
1165 /* Function to invoke object methods given an instance */
1166 SWIGRUNTIME int
1167 SWIG_Tcl_MethodCommand(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST _objv[]) {
1168   char *method,   *attrname;
1169   swig_instance   *inst = (swig_instance *) clientData;
1170   swig_method     *meth;
1171   swig_attribute  *attr;
1172   Tcl_Obj         *oldarg;
1173   Tcl_Obj         **objv;
1174   int              rcode;
1175   swig_class      *cls;
1176   swig_class      *cls_stack[64];
1177   int              cls_stack_bi[64];
1178   int              cls_stack_top = 0;
1179   int              numconf = 2;
1180   int              bi;
1181
1182   objv = (Tcl_Obj **) _objv;
1183   if (objc < 2) {
1184     Tcl_SetResult(interp, (char *) "wrong # args.", TCL_STATIC);
1185     return TCL_ERROR;
1186   }
1187   method = Tcl_GetStringFromObj(objv[1],NULL);
1188   if (strcmp(method,"-acquire") == 0) {
1189     inst->destroy = 1;
1190     SWIG_Acquire(inst->thisvalue);
1191     return TCL_OK;
1192   }
1193   if (strcmp(method,"-disown") == 0) {
1194     if (inst->destroy) {
1195       SWIG_Disown(inst->thisvalue);
1196     }
1197     inst->destroy = 0;
1198     return TCL_OK;
1199   }
1200   if (strcmp(method,"-delete") == 0) {
1201     Tcl_DeleteCommandFromToken(interp,inst->cmdtok);
1202     return TCL_OK;
1203   }
1204   cls_stack[cls_stack_top] = inst->classptr;
1205   cls_stack_bi[cls_stack_top] = -1;
1206   cls = inst->classptr;
1207   while (1) {
1208     bi = cls_stack_bi[cls_stack_top];
1209     cls = cls_stack[cls_stack_top];
1210     if (bi != -1) {
1211       if (!cls->bases[bi] && cls->base_names[bi]) {
1212         /* lookup and cache the base class */
1213         swig_type_info *info = SWIG_TypeQueryModule(cls->module, cls->module, cls->base_names[bi]);
1214         if (info) cls->bases[bi] = (swig_class *) info->clientdata;
1215       }
1216       cls = cls->bases[bi];
1217       if (cls) {
1218         cls_stack_bi[cls_stack_top]++;
1219         cls_stack_top++;
1220         cls_stack[cls_stack_top] = cls;
1221         cls_stack_bi[cls_stack_top] = -1;
1222         continue;
1223       }
1224     }
1225     if (!cls) {
1226       cls_stack_top--;
1227       if (cls_stack_top < 0) break;
1228       else continue;
1229     }
1230     cls_stack_bi[cls_stack_top]++;
1231
1232     meth = cls->methods;
1233     /* Check for methods */
1234     while (meth && meth->name) {
1235       if (strcmp(meth->name,method) == 0) {
1236         oldarg = objv[1];
1237         objv[1] = inst->thisptr;
1238         Tcl_IncrRefCount(inst->thisptr);
1239         rcode = (*meth->method)(clientData,interp,objc,objv);
1240         objv[1] = oldarg;
1241         Tcl_DecrRefCount(inst->thisptr);
1242         return rcode;
1243       }
1244       meth++;
1245     }
1246     /* Check class methods for a match */
1247     if (strcmp(method,"cget") == 0) {
1248       if (objc < 3) {
1249         Tcl_SetResult(interp, (char *) "wrong # args.", TCL_STATIC);
1250         return TCL_ERROR;
1251       }
1252       attrname = Tcl_GetStringFromObj(objv[2],NULL);
1253       attr = cls->attributes;
1254       while (attr && attr->name) {
1255         if ((strcmp(attr->name, attrname) == 0) && (attr->getmethod)) {
1256           oldarg = objv[1];
1257           objv[1] = inst->thisptr;
1258           Tcl_IncrRefCount(inst->thisptr);
1259           rcode = (*attr->getmethod)(clientData,interp,2, objv);
1260           objv[1] = oldarg;
1261           Tcl_DecrRefCount(inst->thisptr);
1262           return rcode;
1263         }
1264         attr++;
1265       }
1266       if (strcmp(attrname, "-this") == 0) {
1267         Tcl_SetObjResult(interp, Tcl_DuplicateObj(inst->thisptr));
1268         return TCL_OK;
1269       }
1270       if (strcmp(attrname, "-thisown") == 0) {
1271         if (SWIG_Thisown(inst->thisvalue)) {
1272           Tcl_SetResult(interp,(char*)"1",TCL_STATIC);
1273         } else {
1274           Tcl_SetResult(interp,(char*)"0",TCL_STATIC);
1275         }
1276         return TCL_OK;
1277       }
1278     } else if (strcmp(method, "configure") == 0) {
1279       int i;
1280       if (objc < 4) {
1281         Tcl_SetResult(interp, (char *) "wrong # args.", TCL_STATIC);
1282         return TCL_ERROR;
1283       }
1284       i = 2;
1285       while (i < objc) {
1286         attrname = Tcl_GetStringFromObj(objv[i],NULL);
1287         attr = cls->attributes;
1288         while (attr && attr->name) {
1289           if ((strcmp(attr->name, attrname) == 0) && (attr->setmethod)) {
1290             oldarg = objv[i];
1291             objv[i] = inst->thisptr;
1292             Tcl_IncrRefCount(inst->thisptr);
1293             rcode = (*attr->setmethod)(clientData,interp,3, &objv[i-1]);
1294             objv[i] = oldarg;
1295             Tcl_DecrRefCount(inst->thisptr);
1296             if (rcode != TCL_OK) return rcode;
1297             numconf += 2;
1298           }
1299           attr++;
1300         }
1301         i+=2;
1302       }
1303     }
1304   }
1305   if (strcmp(method,"configure") == 0) {
1306     if (numconf >= objc) {
1307       return TCL_OK;
1308     } else {
1309       Tcl_SetResult(interp,(char *) "Invalid attribute name.", TCL_STATIC);
1310       return TCL_ERROR;
1311     }
1312   }
1313   if (strcmp(method,"cget") == 0) {
1314     Tcl_SetResult(interp,(char *) "Invalid attribute name.", TCL_STATIC);
1315     return TCL_ERROR;
1316   }
1317   Tcl_SetResult(interp, (char *) "Invalid method. Must be one of: configure cget -acquire -disown -delete", TCL_STATIC);
1318   cls = inst->classptr;
1319   bi = 0;
1320   while (cls) {
1321     meth = cls->methods;
1322     while (meth && meth->name) {
1323       char *cr = (char *) Tcl_GetStringResult(interp);
1324       int meth_len = strlen(meth->name);
1325       char* where = strchr(cr,':');
1326       while(where) {
1327         where = strstr(where, meth->name);
1328         if(where) {
1329           if(where[-1] == ' ' && (where[meth_len] == ' ' || where[meth_len]==0)) {
1330             break;
1331           } else {
1332             where++;
1333           }
1334         }
1335       }
1336
1337       if (!where)
1338         Tcl_AppendElement(interp, (char *) meth->name);
1339       meth++;
1340     }
1341     cls = inst->classptr->bases[bi++];
1342   }
1343   return TCL_ERROR;
1344 }
1345
1346 /* This function takes the current result and turns it into an object command */
1347 SWIGRUNTIME Tcl_Obj *
1348 SWIG_Tcl_NewInstanceObj(Tcl_Interp *interp, void *thisvalue, swig_type_info *type, int flags) {
1349   Tcl_Obj *robj = SWIG_NewPointerObj(thisvalue, type,0);
1350   /* Check to see if this pointer belongs to a class or not */
1351   if ((type->clientdata) && (interp)) {
1352     Tcl_CmdInfo    ci;
1353     char          *name;
1354     name = Tcl_GetStringFromObj(robj,NULL);
1355     if (!Tcl_GetCommandInfo(interp,name, &ci) || (flags)) {
1356       swig_instance *newinst = (swig_instance *) malloc(sizeof(swig_instance));
1357       newinst->thisptr = Tcl_DuplicateObj(robj);
1358       Tcl_IncrRefCount(newinst->thisptr);
1359       newinst->thisvalue = thisvalue;
1360       newinst->classptr = (swig_class *) type->clientdata;
1361       newinst->destroy = flags;
1362       newinst->cmdtok = Tcl_CreateObjCommand(interp, Tcl_GetStringFromObj(robj,NULL), (swig_wrapper_func) SWIG_MethodCommand, (ClientData) newinst, (swig_delete_func) SWIG_ObjectDelete);
1363       if (flags) {
1364         SWIG_Acquire(thisvalue);
1365       }
1366     }
1367   }
1368   return robj;
1369 }
1370
1371 /* Function to create objects */
1372 SWIGRUNTIME int
1373 SWIG_Tcl_ObjectConstructor(ClientData clientData, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
1374   Tcl_Obj          *newObj = 0;
1375   void             *thisvalue = 0;
1376   swig_instance   *newinst = 0;
1377   swig_class      *classptr = (swig_class *) clientData;
1378   swig_wrapper     cons = 0;
1379   char             *name = 0;
1380   int               firstarg = 0;
1381   int               thisarg = 0;
1382   int               destroy = 1;
1383
1384   if (!classptr) {
1385     Tcl_SetResult(interp, (char *) "swig: internal runtime error. No class object defined.", TCL_STATIC);
1386     return TCL_ERROR;
1387   }
1388   cons = classptr->constructor;
1389   if (objc > 1) {
1390     char *s = Tcl_GetStringFromObj(objv[1],NULL);
1391     if (strcmp(s,"-this") == 0) {
1392       thisarg = 2;
1393       cons = 0;
1394     } else if (strcmp(s,"-args") == 0) {
1395       firstarg = 1;
1396     } else if (objc == 2) {
1397       firstarg = 1;
1398       name = s;
1399     } else if (objc >= 3) {
1400       char *s1;
1401       name = s;
1402       s1 = Tcl_GetStringFromObj(objv[2],NULL);
1403       if (strcmp(s1,"-this") == 0) {
1404         thisarg = 3;
1405         cons = 0;
1406       } else {
1407         firstarg = 1;
1408       }
1409     }
1410   }
1411   if (cons) {
1412     int result;
1413     result = (*cons)(0, interp, objc-firstarg, &objv[firstarg]);
1414     if (result != TCL_OK) {
1415       return result;
1416     }
1417     newObj = Tcl_DuplicateObj(Tcl_GetObjResult(interp));
1418     if (!name) name = Tcl_GetStringFromObj(newObj,NULL);
1419   } else if (thisarg > 0) {
1420     if (thisarg < objc) {
1421       destroy = 0;
1422       newObj = Tcl_DuplicateObj(objv[thisarg]);
1423       if (!name) name = Tcl_GetStringFromObj(newObj,NULL);
1424     } else {
1425       Tcl_SetResult(interp, (char *) "wrong # args.", TCL_STATIC);
1426       return TCL_ERROR;
1427     }
1428   } else {
1429     Tcl_SetResult(interp, (char *) "No constructor available.", TCL_STATIC);
1430     return TCL_ERROR;
1431   }
1432   if (SWIG_Tcl_ConvertPtr(interp,newObj, (void **) &thisvalue, *(classptr->type), 0) != SWIG_OK) {
1433     Tcl_DecrRefCount(newObj);
1434     return TCL_ERROR;
1435   }
1436   newinst = (swig_instance *) malloc(sizeof(swig_instance));
1437   newinst->thisptr = newObj;
1438   Tcl_IncrRefCount(newObj);
1439   newinst->thisvalue = thisvalue;
1440   newinst->classptr = classptr;
1441   newinst->destroy = destroy;
1442   if (destroy) {
1443     SWIG_Acquire(thisvalue);
1444   }
1445   newinst->cmdtok = Tcl_CreateObjCommand(interp,name, (swig_wrapper) SWIG_MethodCommand, (ClientData) newinst, (swig_delete_func) SWIG_ObjectDelete);
1446   return TCL_OK;
1447 }
1448
1449 /* -----------------------------------------------------------------------------*
1450  *   Get arguments
1451  * -----------------------------------------------------------------------------*/
1452 SWIGRUNTIME int
1453 SWIG_Tcl_GetArgs(Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[], const char *fmt, ...) {
1454   int        argno = 0, opt = 0;
1455   long       tempi;
1456   double     tempd;
1457   const char *c;
1458   va_list    ap;
1459   void      *vptr;
1460   Tcl_Obj   *obj = 0;
1461   swig_type_info *ty;
1462
1463   va_start(ap,fmt);
1464   for (c = fmt; (*c && (*c != ':') && (*c != ';')); c++,argno++) {
1465     if (*c == '|') {
1466       opt = 1;
1467       c++;
1468     }
1469     if (argno >= (objc-1)) {
1470       if (!opt) {
1471         Tcl_SetResult(interp, (char *) "Wrong number of arguments ", TCL_STATIC);
1472         goto argerror;
1473       } else {
1474         va_end(ap);
1475         return TCL_OK;
1476       }
1477     }
1478
1479     vptr = va_arg(ap,void *);
1480     if (vptr) {
1481       if (isupper(*c)) {
1482         obj = SWIG_Tcl_GetConstantObj(Tcl_GetStringFromObj(objv[argno+1],0));
1483         if (!obj) obj = objv[argno+1];
1484       } else {
1485         obj = objv[argno+1];
1486       }
1487       switch(*c) {
1488       case 'i': case 'I':
1489       case 'l': case 'L':
1490       case 'h': case 'H':
1491       case 'b': case 'B':
1492         if (Tcl_GetLongFromObj(interp,obj,&tempi) != TCL_OK) goto argerror;
1493         if ((*c == 'i') || (*c == 'I')) *((int *)vptr) = (int)tempi;
1494         else if ((*c == 'l') || (*c == 'L')) *((long *)vptr) = (long)tempi;
1495         else if ((*c == 'h') || (*c == 'H')) *((short*)vptr) = (short)tempi;
1496         else if ((*c == 'b') || (*c == 'B')) *((unsigned char *)vptr) = (unsigned char)tempi;
1497         break;
1498       case 'f': case 'F':
1499       case 'd': case 'D':
1500         if (Tcl_GetDoubleFromObj(interp,obj,&tempd) != TCL_OK) goto argerror;
1501         if ((*c == 'f') || (*c == 'F')) *((float *) vptr) = (float)tempd;
1502         else if ((*c == 'd') || (*c == 'D')) *((double*) vptr) = tempd;
1503         break;
1504       case 's': case 'S':
1505         if (*(c+1) == '#') {
1506           int *vlptr = (int *) va_arg(ap, void *);
1507           *((char **) vptr) = Tcl_GetStringFromObj(obj, vlptr);
1508           c++;
1509         } else {
1510           *((char **)vptr) = Tcl_GetStringFromObj(obj,NULL);
1511         }
1512         break;
1513       case 'c': case 'C':
1514         *((char *)vptr) = *(Tcl_GetStringFromObj(obj,NULL));
1515         break;
1516       case 'p': case 'P':
1517         ty = (swig_type_info *) va_arg(ap, void *);
1518         if (SWIG_Tcl_ConvertPtr(interp, obj, (void **) vptr, ty, 0) != SWIG_OK) goto argerror;
1519         break;
1520       case 'o': case 'O':
1521         *((Tcl_Obj **)vptr) = objv[argno+1];
1522         break;
1523       default:
1524         break;
1525       }
1526     }
1527   }
1528
1529   if ((*c != ';') && ((objc-1) > argno)) {
1530     Tcl_SetResult(interp, (char *) "Wrong # args.", TCL_STATIC);
1531     goto argerror;
1532   }
1533   va_end(ap);
1534   return TCL_OK;
1535
1536  argerror:
1537   {
1538     char temp[32];
1539     sprintf(temp,"%d", argno+1);
1540     c = strchr(fmt,':');
1541     if (!c) c = strchr(fmt,';');
1542     if (!c) c = (char *)"";
1543     Tcl_AppendResult(interp,c," argument ", temp, NULL);
1544     va_end(ap);
1545     return TCL_ERROR;
1546   }
1547 }
1548
1549 #ifdef __cplusplus
1550 #if 0
1551 { /* cc-mode */
1552 #endif
1553 }
1554 #endif
1555
1556
1557
1558 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
1559
1560 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
1561
1562
1563
1564 /* -------- TYPES TABLE (BEGIN) -------- */
1565
1566 #define SWIGTYPE_p_char swig_types[0]
1567 #define SWIGTYPE_p_netpgp_t swig_types[1]
1568 #define SWIGTYPE_p_p_char swig_types[2]
1569 #define SWIGTYPE_p_void swig_types[3]
1570 static swig_type_info *swig_types[5];
1571 static swig_module_info swig_module = {swig_types, 4, 0, 0, 0, 0};
1572 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
1573 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
1574
1575 /* -------- TYPES TABLE (END) -------- */
1576
1577 #define SWIG_init    Netpgptcl_Init
1578 #define SWIG_name    "netpgptcl"
1579 #define SWIG_prefix  ""
1580 #define SWIG_version "0.0"
1581
1582 #define SWIGVERSION 0x010331
1583 #define SWIG_VERSION SWIGVERSION
1584
1585
1586 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
1587 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
1588
1589
1590
1591 #ifdef __cplusplus
1592 extern "C" {
1593 #endif
1594 #ifdef MAC_TCL
1595 #pragma export on
1596 #endif
1597 SWIGEXPORT int SWIG_init(Tcl_Interp *);
1598 #ifdef MAC_TCL
1599 #pragma export off
1600 #endif
1601 #ifdef __cplusplus
1602 }
1603 #endif
1604
1605
1606
1607 #include <netpgp.h>
1608
1609
1610
1611
1612 #include <limits.h>
1613 #ifndef LLONG_MIN
1614 # define LLONG_MIN      LONG_LONG_MIN
1615 #endif
1616 #ifndef LLONG_MAX
1617 # define LLONG_MAX      LONG_LONG_MAX
1618 #endif
1619 #ifndef ULLONG_MAX
1620 # define ULLONG_MAX     ULONG_LONG_MAX
1621 #endif
1622
1623
1624 SWIGINTERN int
1625 SWIG_AsVal_unsigned_SS_long SWIG_TCL_DECL_ARGS_2(Tcl_Obj *obj, unsigned long *val) {
1626   long v;
1627   if (Tcl_GetLongFromObj(0,obj, &v) == TCL_OK) {
1628     if (v >= 0) {
1629       if (val) *val = (unsigned long) v;
1630       return SWIG_OK;
1631     }
1632     /* If v is negative, then this could be a negative number, or an
1633        unsigned value which doesn't fit in a signed long, so try to
1634        get it as a string so we can distinguish these cases. */
1635   }
1636   {
1637     int len = 0;
1638     const char *nptr = Tcl_GetStringFromObj(obj, &len);
1639     if (nptr && len > 0) {
1640       char *endptr;
1641       unsigned long v;
1642       if (*nptr == '-') return SWIG_OverflowError;
1643       v = strtoul(nptr, &endptr,0);
1644       if (errno == ERANGE) {
1645         errno = 0;
1646         return SWIG_OverflowError;
1647       } else {
1648         if (*endptr == '\0') {
1649           if (val) *val = v;
1650           return SWIG_OK;
1651         }
1652       }
1653     }
1654   }
1655
1656   return SWIG_TypeError;
1657 }
1658
1659
1660 SWIGINTERN int
1661 SWIG_AsVal_unsigned_SS_int SWIG_TCL_DECL_ARGS_2(Tcl_Obj * obj, unsigned int *val)
1662 {
1663   unsigned long v;
1664   int res = SWIG_AsVal_unsigned_SS_long SWIG_TCL_CALL_ARGS_2(obj, &v);
1665   if (SWIG_IsOK(res)) {
1666     if ((v > UINT_MAX)) {
1667       return SWIG_OverflowError;
1668     } else {
1669       if (val) *val = (unsigned int)(v);
1670     }
1671   }
1672   return res;
1673 }
1674
1675
1676 SWIGINTERNINLINE Tcl_Obj*
1677 SWIG_From_long  (long value)
1678 {
1679   if (((long) INT_MIN <= value) && (value <= (long) INT_MAX)) {
1680     return Tcl_NewIntObj((int)(value));
1681   } else {
1682     return Tcl_NewLongObj(value);
1683   }
1684 }
1685
1686
1687 #include <stdio.h>
1688 #if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
1689 # ifndef snprintf
1690 #  define snprintf _snprintf
1691 # endif
1692 #endif
1693
1694
1695 SWIGINTERNINLINE Tcl_Obj*
1696 SWIG_From_unsigned_SS_long  (unsigned long value)
1697 {
1698   if (value < (unsigned long) LONG_MAX) {
1699     return SWIG_From_long  ((long)(value));
1700   } else {
1701     char temp[256];
1702     sprintf(temp, "%lu", value);
1703     return Tcl_NewStringObj(temp,-1);
1704   }
1705 }
1706
1707
1708 SWIGINTERNINLINE Tcl_Obj *
1709 SWIG_From_unsigned_SS_int  (unsigned int value)
1710 {
1711   return SWIG_From_unsigned_SS_long  (value);
1712 }
1713
1714
1715 SWIGINTERNINLINE Tcl_Obj *
1716 SWIG_From_int  (int value)
1717 {
1718   return SWIG_From_long  (value);
1719 }
1720
1721
1722 SWIGINTERN int
1723 SWIG_AsCharPtrAndSize(Tcl_Obj *obj, char** cptr, size_t* psize, int *alloc)
1724 {
1725   int len = 0;
1726   char *cstr = Tcl_GetStringFromObj(obj, &len);
1727   if (cstr) {
1728     if (cptr)  *cptr = cstr;
1729     if (psize) *psize = len + 1;
1730     if (alloc) *alloc = SWIG_OLDOBJ;
1731     return SWIG_OK;
1732   }
1733   return SWIG_TypeError;
1734 }
1735
1736
1737
1738
1739
1740 SWIGINTERNINLINE Tcl_Obj *
1741 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
1742 {
1743   return (size < INT_MAX) ? Tcl_NewStringObj(carray, (int)(size)) : NULL;
1744 }
1745
1746
1747 SWIGINTERNINLINE Tcl_Obj *
1748 SWIG_FromCharPtr(const char *cptr)
1749 {
1750   return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
1751 }
1752
1753
1754 SWIGINTERN int
1755 SWIG_AsVal_long SWIG_TCL_DECL_ARGS_2(Tcl_Obj *obj, long* val)
1756 {
1757   long v;
1758   if (Tcl_GetLongFromObj(0,obj, &v) == TCL_OK) {
1759     if (val) *val = (long) v;
1760     return SWIG_OK;
1761   }
1762   return SWIG_TypeError;
1763 }
1764
1765
1766 SWIGINTERN int
1767 SWIG_AsVal_int SWIG_TCL_DECL_ARGS_2(Tcl_Obj * obj, int *val)
1768 {
1769   long v;
1770   int res = SWIG_AsVal_long SWIG_TCL_CALL_ARGS_2(obj, &v);
1771   if (SWIG_IsOK(res)) {
1772     if ((v < INT_MIN || v > INT_MAX)) {
1773       return SWIG_OverflowError;
1774     } else {
1775       if (val) *val = (int)(v);
1776     }
1777   }
1778   return res;
1779 }
1780
1781
1782 SWIGINTERNINLINE int
1783 SWIG_AsVal_size_t SWIG_TCL_DECL_ARGS_2(Tcl_Obj * obj, size_t *val)
1784 {
1785   unsigned long v;
1786   int res = SWIG_AsVal_unsigned_SS_long SWIG_TCL_CALL_ARGS_2(obj, val ? &v : 0);
1787   if (SWIG_IsOK(res) && val) *val = (size_t)(v);
1788   return res;
1789 }
1790
1791 #ifdef __cplusplus
1792 extern "C" {
1793 #endif
1794 SWIGINTERN int
1795 _wrap_netpgp_t_c_set(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
1796   netpgp_t *arg1 = (netpgp_t *) 0 ;
1797   unsigned int arg2 ;
1798   void *argp1 = 0 ;
1799   int res1 = 0 ;
1800   unsigned int val2 ;
1801   int ecode2 = 0 ;
1802
1803   if (SWIG_GetArgs(interp, objc, objv,"oo:netpgp_t_c_set self c ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
1804   res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
1805   if (!SWIG_IsOK(res1)) {
1806     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_c_set" "', argument " "1"" of type '" "netpgp_t *""'");
1807   }
1808   arg1 = (netpgp_t *)(argp1);
1809   ecode2 = SWIG_AsVal_unsigned_SS_int SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
1810   if (!SWIG_IsOK(ecode2)) {
1811     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "netpgp_t_c_set" "', argument " "2"" of type '" "unsigned int""'");
1812   }
1813   arg2 = (unsigned int)(val2);
1814   if (arg1) (arg1)->c = arg2;
1815
1816
1817   return TCL_OK;
1818 fail:
1819   return TCL_ERROR;
1820 }
1821
1822
1823 SWIGINTERN int
1824 _wrap_netpgp_t_c_get(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
1825   netpgp_t *arg1 = (netpgp_t *) 0 ;
1826   unsigned int result;
1827   void *argp1 = 0 ;
1828   int res1 = 0 ;
1829
1830   if (SWIG_GetArgs(interp, objc, objv,"o:netpgp_t_c_get self ",(void *)0) == TCL_ERROR) SWIG_fail;
1831   res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
1832   if (!SWIG_IsOK(res1)) {
1833     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_c_get" "', argument " "1"" of type '" "netpgp_t *""'");
1834   }
1835   arg1 = (netpgp_t *)(argp1);
1836   result = (unsigned int) ((arg1)->c);
1837   Tcl_SetObjResult(interp,SWIG_From_unsigned_SS_int((unsigned int)(result)));
1838   return TCL_OK;
1839 fail:
1840   return TCL_ERROR;
1841 }
1842
1843
1844 SWIGINTERN int
1845 _wrap_netpgp_t_size_set(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
1846   netpgp_t *arg1 = (netpgp_t *) 0 ;
1847   unsigned int arg2 ;
1848   void *argp1 = 0 ;
1849   int res1 = 0 ;
1850   unsigned int val2 ;
1851   int ecode2 = 0 ;
1852
1853   if (SWIG_GetArgs(interp, objc, objv,"oo:netpgp_t_size_set self size ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
1854   res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
1855   if (!SWIG_IsOK(res1)) {
1856     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_size_set" "', argument " "1"" of type '" "netpgp_t *""'");
1857   }
1858   arg1 = (netpgp_t *)(argp1);
1859   ecode2 = SWIG_AsVal_unsigned_SS_int SWIG_TCL_CALL_ARGS_2(objv[2], &val2);
1860   if (!SWIG_IsOK(ecode2)) {
1861     SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "netpgp_t_size_set" "', argument " "2"" of type '" "unsigned int""'");
1862   }
1863   arg2 = (unsigned int)(val2);
1864   if (arg1) (arg1)->size = arg2;
1865
1866
1867   return TCL_OK;
1868 fail:
1869   return TCL_ERROR;
1870 }
1871
1872
1873 SWIGINTERN int
1874 _wrap_netpgp_t_size_get(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
1875   netpgp_t *arg1 = (netpgp_t *) 0 ;
1876   unsigned int result;
1877   void *argp1 = 0 ;
1878   int res1 = 0 ;
1879
1880   if (SWIG_GetArgs(interp, objc, objv,"o:netpgp_t_size_get self ",(void *)0) == TCL_ERROR) SWIG_fail;
1881   res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
1882   if (!SWIG_IsOK(res1)) {
1883     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_size_get" "', argument " "1"" of type '" "netpgp_t *""'");
1884   }
1885   arg1 = (netpgp_t *)(argp1);
1886   result = (unsigned int) ((arg1)->size);
1887   Tcl_SetObjResult(interp,SWIG_From_unsigned_SS_int((unsigned int)(result)));
1888   return TCL_OK;
1889 fail:
1890   return TCL_ERROR;
1891 }
1892
1893
1894 SWIGINTERN int
1895 _wrap_netpgp_t_name_set(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
1896   netpgp_t *arg1 = (netpgp_t *) 0 ;
1897   char **arg2 = (char **) 0 ;
1898   void *argp1 = 0 ;
1899   int res1 = 0 ;
1900   void *argp2 = 0 ;
1901   int res2 = 0 ;
1902
1903   if (SWIG_GetArgs(interp, objc, objv,"oo:netpgp_t_name_set self name ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
1904   res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
1905   if (!SWIG_IsOK(res1)) {
1906     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_name_set" "', argument " "1"" of type '" "netpgp_t *""'");
1907   }
1908   arg1 = (netpgp_t *)(argp1);
1909   res2 = SWIG_ConvertPtr(objv[2], &argp2,SWIGTYPE_p_p_char, 0 |  0 );
1910   if (!SWIG_IsOK(res2)) {
1911     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_t_name_set" "', argument " "2"" of type '" "char **""'");
1912   }
1913   arg2 = (char **)(argp2);
1914   if (arg1) (arg1)->name = arg2;
1915
1916
1917   return TCL_OK;
1918 fail:
1919   return TCL_ERROR;
1920 }
1921
1922
1923 SWIGINTERN int
1924 _wrap_netpgp_t_name_get(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
1925   netpgp_t *arg1 = (netpgp_t *) 0 ;
1926   char **result = 0 ;
1927   void *argp1 = 0 ;
1928   int res1 = 0 ;
1929
1930   if (SWIG_GetArgs(interp, objc, objv,"o:netpgp_t_name_get self ",(void *)0) == TCL_ERROR) SWIG_fail;
1931   res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
1932   if (!SWIG_IsOK(res1)) {
1933     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_name_get" "', argument " "1"" of type '" "netpgp_t *""'");
1934   }
1935   arg1 = (netpgp_t *)(argp1);
1936   result = (char **) ((arg1)->name);
1937   Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_p_char,0));
1938   return TCL_OK;
1939 fail:
1940   return TCL_ERROR;
1941 }
1942
1943
1944 SWIGINTERN int
1945 _wrap_netpgp_t_value_set(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
1946   netpgp_t *arg1 = (netpgp_t *) 0 ;
1947   char **arg2 = (char **) 0 ;
1948   void *argp1 = 0 ;
1949   int res1 = 0 ;
1950   void *argp2 = 0 ;
1951   int res2 = 0 ;
1952
1953   if (SWIG_GetArgs(interp, objc, objv,"oo:netpgp_t_value_set self value ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
1954   res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
1955   if (!SWIG_IsOK(res1)) {
1956     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_value_set" "', argument " "1"" of type '" "netpgp_t *""'");
1957   }
1958   arg1 = (netpgp_t *)(argp1);
1959   res2 = SWIG_ConvertPtr(objv[2], &argp2,SWIGTYPE_p_p_char, 0 |  0 );
1960   if (!SWIG_IsOK(res2)) {
1961     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_t_value_set" "', argument " "2"" of type '" "char **""'");
1962   }
1963   arg2 = (char **)(argp2);
1964   if (arg1) (arg1)->value = arg2;
1965
1966
1967   return TCL_OK;
1968 fail:
1969   return TCL_ERROR;
1970 }
1971
1972
1973 SWIGINTERN int
1974 _wrap_netpgp_t_value_get(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
1975   netpgp_t *arg1 = (netpgp_t *) 0 ;
1976   char **result = 0 ;
1977   void *argp1 = 0 ;
1978   int res1 = 0 ;
1979
1980   if (SWIG_GetArgs(interp, objc, objv,"o:netpgp_t_value_get self ",(void *)0) == TCL_ERROR) SWIG_fail;
1981   res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
1982   if (!SWIG_IsOK(res1)) {
1983     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_value_get" "', argument " "1"" of type '" "netpgp_t *""'");
1984   }
1985   arg1 = (netpgp_t *)(argp1);
1986   result = (char **) ((arg1)->value);
1987   Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_p_char,0));
1988   return TCL_OK;
1989 fail:
1990   return TCL_ERROR;
1991 }
1992
1993
1994 SWIGINTERN int
1995 _wrap_netpgp_t_pubring_set(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
1996   netpgp_t *arg1 = (netpgp_t *) 0 ;
1997   void *arg2 = (void *) 0 ;
1998   void *argp1 = 0 ;
1999   int res1 = 0 ;
2000   int res2 ;
2001
2002   if (SWIG_GetArgs(interp, objc, objv,"oo:netpgp_t_pubring_set self pubring ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2003   res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2004   if (!SWIG_IsOK(res1)) {
2005     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_pubring_set" "', argument " "1"" of type '" "netpgp_t *""'");
2006   }
2007   arg1 = (netpgp_t *)(argp1);
2008   res2 = SWIG_ConvertPtr(objv[2],SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
2009   if (!SWIG_IsOK(res2)) {
2010     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_t_pubring_set" "', argument " "2"" of type '" "void *""'");
2011   }
2012   if (arg1) (arg1)->pubring = arg2;
2013
2014
2015   return TCL_OK;
2016 fail:
2017   return TCL_ERROR;
2018 }
2019
2020
2021 SWIGINTERN int
2022 _wrap_netpgp_t_pubring_get(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2023   netpgp_t *arg1 = (netpgp_t *) 0 ;
2024   void *result = 0 ;
2025   void *argp1 = 0 ;
2026   int res1 = 0 ;
2027
2028   if (SWIG_GetArgs(interp, objc, objv,"o:netpgp_t_pubring_get self ",(void *)0) == TCL_ERROR) SWIG_fail;
2029   res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2030   if (!SWIG_IsOK(res1)) {
2031     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_pubring_get" "', argument " "1"" of type '" "netpgp_t *""'");
2032   }
2033   arg1 = (netpgp_t *)(argp1);
2034   result = (void *) ((arg1)->pubring);
2035   Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_void,0));
2036   return TCL_OK;
2037 fail:
2038   return TCL_ERROR;
2039 }
2040
2041
2042 SWIGINTERN int
2043 _wrap_netpgp_t_secring_set(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2044   netpgp_t *arg1 = (netpgp_t *) 0 ;
2045   void *arg2 = (void *) 0 ;
2046   void *argp1 = 0 ;
2047   int res1 = 0 ;
2048   int res2 ;
2049
2050   if (SWIG_GetArgs(interp, objc, objv,"oo:netpgp_t_secring_set self secring ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2051   res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2052   if (!SWIG_IsOK(res1)) {
2053     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_secring_set" "', argument " "1"" of type '" "netpgp_t *""'");
2054   }
2055   arg1 = (netpgp_t *)(argp1);
2056   res2 = SWIG_ConvertPtr(objv[2],SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
2057   if (!SWIG_IsOK(res2)) {
2058     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_t_secring_set" "', argument " "2"" of type '" "void *""'");
2059   }
2060   if (arg1) (arg1)->secring = arg2;
2061
2062
2063   return TCL_OK;
2064 fail:
2065   return TCL_ERROR;
2066 }
2067
2068
2069 SWIGINTERN int
2070 _wrap_netpgp_t_secring_get(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2071   netpgp_t *arg1 = (netpgp_t *) 0 ;
2072   void *result = 0 ;
2073   void *argp1 = 0 ;
2074   int res1 = 0 ;
2075
2076   if (SWIG_GetArgs(interp, objc, objv,"o:netpgp_t_secring_get self ",(void *)0) == TCL_ERROR) SWIG_fail;
2077   res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2078   if (!SWIG_IsOK(res1)) {
2079     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_secring_get" "', argument " "1"" of type '" "netpgp_t *""'");
2080   }
2081   arg1 = (netpgp_t *)(argp1);
2082   result = (void *) ((arg1)->secring);
2083   Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_void,0));
2084   return TCL_OK;
2085 fail:
2086   return TCL_ERROR;
2087 }
2088
2089
2090 SWIGINTERN int
2091 _wrap_netpgp_t_io_set(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2092   netpgp_t *arg1 = (netpgp_t *) 0 ;
2093   void *arg2 = (void *) 0 ;
2094   void *argp1 = 0 ;
2095   int res1 = 0 ;
2096   int res2 ;
2097
2098   if (SWIG_GetArgs(interp, objc, objv,"oo:netpgp_t_io_set self io ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2099   res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2100   if (!SWIG_IsOK(res1)) {
2101     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_io_set" "', argument " "1"" of type '" "netpgp_t *""'");
2102   }
2103   arg1 = (netpgp_t *)(argp1);
2104   res2 = SWIG_ConvertPtr(objv[2],SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
2105   if (!SWIG_IsOK(res2)) {
2106     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_t_io_set" "', argument " "2"" of type '" "void *""'");
2107   }
2108   if (arg1) (arg1)->io = arg2;
2109
2110
2111   return TCL_OK;
2112 fail:
2113   return TCL_ERROR;
2114 }
2115
2116
2117 SWIGINTERN int
2118 _wrap_netpgp_t_io_get(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2119   netpgp_t *arg1 = (netpgp_t *) 0 ;
2120   void *result = 0 ;
2121   void *argp1 = 0 ;
2122   int res1 = 0 ;
2123
2124   if (SWIG_GetArgs(interp, objc, objv,"o:netpgp_t_io_get self ",(void *)0) == TCL_ERROR) SWIG_fail;
2125   res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2126   if (!SWIG_IsOK(res1)) {
2127     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_io_get" "', argument " "1"" of type '" "netpgp_t *""'");
2128   }
2129   arg1 = (netpgp_t *)(argp1);
2130   result = (void *) ((arg1)->io);
2131   Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_void,0));
2132   return TCL_OK;
2133 fail:
2134   return TCL_ERROR;
2135 }
2136
2137
2138 SWIGINTERN int
2139 _wrap_netpgp_t_passfp_set(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2140   netpgp_t *arg1 = (netpgp_t *) 0 ;
2141   void *arg2 = (void *) 0 ;
2142   void *argp1 = 0 ;
2143   int res1 = 0 ;
2144   int res2 ;
2145
2146   if (SWIG_GetArgs(interp, objc, objv,"oo:netpgp_t_passfp_set self passfp ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2147   res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2148   if (!SWIG_IsOK(res1)) {
2149     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_passfp_set" "', argument " "1"" of type '" "netpgp_t *""'");
2150   }
2151   arg1 = (netpgp_t *)(argp1);
2152   res2 = SWIG_ConvertPtr(objv[2],SWIG_as_voidptrptr(&arg2), 0, SWIG_POINTER_DISOWN);
2153   if (!SWIG_IsOK(res2)) {
2154     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_t_passfp_set" "', argument " "2"" of type '" "void *""'");
2155   }
2156   if (arg1) (arg1)->passfp = arg2;
2157
2158
2159   return TCL_OK;
2160 fail:
2161   return TCL_ERROR;
2162 }
2163
2164
2165 SWIGINTERN int
2166 _wrap_netpgp_t_passfp_get(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2167   netpgp_t *arg1 = (netpgp_t *) 0 ;
2168   void *result = 0 ;
2169   void *argp1 = 0 ;
2170   int res1 = 0 ;
2171
2172   if (SWIG_GetArgs(interp, objc, objv,"o:netpgp_t_passfp_get self ",(void *)0) == TCL_ERROR) SWIG_fail;
2173   res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2174   if (!SWIG_IsOK(res1)) {
2175     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_t_passfp_get" "', argument " "1"" of type '" "netpgp_t *""'");
2176   }
2177   arg1 = (netpgp_t *)(argp1);
2178   result = (void *) ((arg1)->passfp);
2179   Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_void,0));
2180   return TCL_OK;
2181 fail:
2182   return TCL_ERROR;
2183 }
2184
2185
2186 SWIGINTERN int
2187 _wrap_new_netpgp_t(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2188   netpgp_t *result = 0 ;
2189
2190   if (SWIG_GetArgs(interp, objc, objv,":new_netpgp_t ") == TCL_ERROR) SWIG_fail;
2191   result = (netpgp_t *)(netpgp_t *) calloc(1, sizeof(netpgp_t));
2192   Tcl_SetObjResult(interp, SWIG_NewInstanceObj( SWIG_as_voidptr(result), SWIGTYPE_p_netpgp_t,0));
2193   return TCL_OK;
2194 fail:
2195   return TCL_ERROR;
2196 }
2197
2198
2199 SWIGINTERN int
2200 _wrap_delete_netpgp_t(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2201   netpgp_t *arg1 = (netpgp_t *) 0 ;
2202   void *argp1 = 0 ;
2203   int res1 = 0 ;
2204
2205   if (SWIG_GetArgs(interp, objc, objv,"o:delete_netpgp_t self ",(void *)0) == TCL_ERROR) SWIG_fail;
2206   res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_netpgp_t, SWIG_POINTER_DISOWN |  0 );
2207   if (!SWIG_IsOK(res1)) {
2208     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_netpgp_t" "', argument " "1"" of type '" "netpgp_t *""'");
2209   }
2210   arg1 = (netpgp_t *)(argp1);
2211   free((char *) arg1);
2212
2213
2214   return TCL_OK;
2215 fail:
2216   return TCL_ERROR;
2217 }
2218
2219
2220 SWIGINTERN void swig_delete_netpgp_t(void *obj) {
2221 netpgp_t *arg1 = (netpgp_t *) obj;
2222 free((char *) arg1);
2223 }
2224 static swig_method swig_netpgp_t_methods[] = {
2225     {0,0}
2226 };
2227 static swig_attribute swig_netpgp_t_attributes[] = {
2228     { "-c",_wrap_netpgp_t_c_get, _wrap_netpgp_t_c_set},
2229     { "-size",_wrap_netpgp_t_size_get, _wrap_netpgp_t_size_set},
2230     { "-name",_wrap_netpgp_t_name_get, _wrap_netpgp_t_name_set},
2231     { "-value",_wrap_netpgp_t_value_get, _wrap_netpgp_t_value_set},
2232     { "-pubring",_wrap_netpgp_t_pubring_get, _wrap_netpgp_t_pubring_set},
2233     { "-secring",_wrap_netpgp_t_secring_get, _wrap_netpgp_t_secring_set},
2234     { "-io",_wrap_netpgp_t_io_get, _wrap_netpgp_t_io_set},
2235     { "-passfp",_wrap_netpgp_t_passfp_get, _wrap_netpgp_t_passfp_set},
2236     {0,0,0}
2237 };
2238 static swig_class *swig_netpgp_t_bases[] = {0};
2239 static char *swig_netpgp_t_base_names[] = {0};
2240 static swig_class _wrap_class_netpgp_t = { "netpgp_t", &SWIGTYPE_p_netpgp_t,_wrap_new_netpgp_t, swig_delete_netpgp_t, swig_netpgp_t_methods, swig_netpgp_t_attributes, swig_netpgp_t_bases,swig_netpgp_t_base_names, &swig_module };
2241 SWIGINTERN int
2242 _wrap_netpgp_init(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2243   netpgp_t *arg1 = (netpgp_t *) 0 ;
2244   int result;
2245   void *argp1 = 0 ;
2246   int res1 = 0 ;
2247
2248   if (SWIG_GetArgs(interp, objc, objv,"o:netpgp_init netpgp_t * ",(void *)0) == TCL_ERROR) SWIG_fail;
2249   res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2250   if (!SWIG_IsOK(res1)) {
2251     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_init" "', argument " "1"" of type '" "netpgp_t *""'");
2252   }
2253   arg1 = (netpgp_t *)(argp1);
2254   result = (int)netpgp_init(arg1);
2255   Tcl_SetObjResult(interp,SWIG_From_int((int)(result)));
2256   return TCL_OK;
2257 fail:
2258   return TCL_ERROR;
2259 }
2260
2261
2262 SWIGINTERN int
2263 _wrap_netpgp_end(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2264   netpgp_t *arg1 = (netpgp_t *) 0 ;
2265   int result;
2266   void *argp1 = 0 ;
2267   int res1 = 0 ;
2268
2269   if (SWIG_GetArgs(interp, objc, objv,"o:netpgp_end netpgp_t * ",(void *)0) == TCL_ERROR) SWIG_fail;
2270   res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2271   if (!SWIG_IsOK(res1)) {
2272     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_end" "', argument " "1"" of type '" "netpgp_t *""'");
2273   }
2274   arg1 = (netpgp_t *)(argp1);
2275   result = (int)netpgp_end(arg1);
2276   Tcl_SetObjResult(interp,SWIG_From_int((int)(result)));
2277   return TCL_OK;
2278 fail:
2279   return TCL_ERROR;
2280 }
2281
2282
2283 SWIGINTERN int
2284 _wrap_netpgp_set_debug(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2285   char *arg1 = (char *) 0 ;
2286   int result;
2287   int res1 ;
2288   char *buf1 = 0 ;
2289   int alloc1 = 0 ;
2290
2291   if (SWIG_GetArgs(interp, objc, objv,"o:netpgp_set_debug char const * ",(void *)0) == TCL_ERROR) SWIG_fail;
2292   res1 = SWIG_AsCharPtrAndSize(objv[1], &buf1, NULL, &alloc1);
2293   if (!SWIG_IsOK(res1)) {
2294     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_set_debug" "', argument " "1"" of type '" "char const *""'");
2295   }
2296   arg1 = (char *)(buf1);
2297   result = (int)netpgp_set_debug((char const *)arg1);
2298   Tcl_SetObjResult(interp,SWIG_From_int((int)(result)));
2299   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2300   return TCL_OK;
2301 fail:
2302   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2303   return TCL_ERROR;
2304 }
2305
2306
2307 SWIGINTERN int
2308 _wrap_netpgp_get_debug(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2309   char *arg1 = (char *) 0 ;
2310   int result;
2311   int res1 ;
2312   char *buf1 = 0 ;
2313   int alloc1 = 0 ;
2314
2315   if (SWIG_GetArgs(interp, objc, objv,"o:netpgp_get_debug char const * ",(void *)0) == TCL_ERROR) SWIG_fail;
2316   res1 = SWIG_AsCharPtrAndSize(objv[1], &buf1, NULL, &alloc1);
2317   if (!SWIG_IsOK(res1)) {
2318     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_get_debug" "', argument " "1"" of type '" "char const *""'");
2319   }
2320   arg1 = (char *)(buf1);
2321   result = (int)netpgp_get_debug((char const *)arg1);
2322   Tcl_SetObjResult(interp,SWIG_From_int((int)(result)));
2323   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2324   return TCL_OK;
2325 fail:
2326   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2327   return TCL_ERROR;
2328 }
2329
2330
2331 SWIGINTERN int
2332 _wrap_netpgp_get_info(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2333   char *arg1 = (char *) 0 ;
2334   char *result = 0 ;
2335   int res1 ;
2336   char *buf1 = 0 ;
2337   int alloc1 = 0 ;
2338
2339   if (SWIG_GetArgs(interp, objc, objv,"o:netpgp_get_info char const * ",(void *)0) == TCL_ERROR) SWIG_fail;
2340   res1 = SWIG_AsCharPtrAndSize(objv[1], &buf1, NULL, &alloc1);
2341   if (!SWIG_IsOK(res1)) {
2342     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_get_info" "', argument " "1"" of type '" "char const *""'");
2343   }
2344   arg1 = (char *)(buf1);
2345   result = (char *)netpgp_get_info((char const *)arg1);
2346   Tcl_SetObjResult(interp,SWIG_FromCharPtr((const char *)result));
2347   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2348   return TCL_OK;
2349 fail:
2350   if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
2351   return TCL_ERROR;
2352 }
2353
2354
2355 SWIGINTERN int
2356 _wrap_netpgp_list_packets(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2357   netpgp_t *arg1 = (netpgp_t *) 0 ;
2358   char *arg2 = (char *) 0 ;
2359   int arg3 ;
2360   char *arg4 = (char *) 0 ;
2361   int result;
2362   void *argp1 = 0 ;
2363   int res1 = 0 ;
2364   int res2 ;
2365   char *buf2 = 0 ;
2366   int alloc2 = 0 ;
2367   int val3 ;
2368   int ecode3 = 0 ;
2369   int res4 ;
2370   char *buf4 = 0 ;
2371   int alloc4 = 0 ;
2372
2373   if (SWIG_GetArgs(interp, objc, objv,"oooo:netpgp_list_packets netpgp_t * char * int char * ",(void *)0,(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2374   res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2375   if (!SWIG_IsOK(res1)) {
2376     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_list_packets" "', argument " "1"" of type '" "netpgp_t *""'");
2377   }
2378   arg1 = (netpgp_t *)(argp1);
2379   res2 = SWIG_AsCharPtrAndSize(objv[2], &buf2, NULL, &alloc2);
2380   if (!SWIG_IsOK(res2)) {
2381     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_list_packets" "', argument " "2"" of type '" "char *""'");
2382   }
2383   arg2 = (char *)(buf2);
2384   ecode3 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[3], &val3);
2385   if (!SWIG_IsOK(ecode3)) {
2386     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "netpgp_list_packets" "', argument " "3"" of type '" "int""'");
2387   }
2388   arg3 = (int)(val3);
2389   res4 = SWIG_AsCharPtrAndSize(objv[4], &buf4, NULL, &alloc4);
2390   if (!SWIG_IsOK(res4)) {
2391     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "netpgp_list_packets" "', argument " "4"" of type '" "char *""'");
2392   }
2393   arg4 = (char *)(buf4);
2394   result = (int)netpgp_list_packets(arg1,arg2,arg3,arg4);
2395   Tcl_SetObjResult(interp,SWIG_From_int((int)(result)));
2396   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2397   if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
2398   return TCL_OK;
2399 fail:
2400   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2401   if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
2402   return TCL_ERROR;
2403 }
2404
2405
2406 SWIGINTERN int
2407 _wrap_netpgp_setvar(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2408   netpgp_t *arg1 = (netpgp_t *) 0 ;
2409   char *arg2 = (char *) 0 ;
2410   char *arg3 = (char *) 0 ;
2411   int result;
2412   void *argp1 = 0 ;
2413   int res1 = 0 ;
2414   int res2 ;
2415   char *buf2 = 0 ;
2416   int alloc2 = 0 ;
2417   int res3 ;
2418   char *buf3 = 0 ;
2419   int alloc3 = 0 ;
2420
2421   if (SWIG_GetArgs(interp, objc, objv,"ooo:netpgp_setvar netpgp_t * char const * char const * ",(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2422   res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2423   if (!SWIG_IsOK(res1)) {
2424     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_setvar" "', argument " "1"" of type '" "netpgp_t *""'");
2425   }
2426   arg1 = (netpgp_t *)(argp1);
2427   res2 = SWIG_AsCharPtrAndSize(objv[2], &buf2, NULL, &alloc2);
2428   if (!SWIG_IsOK(res2)) {
2429     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_setvar" "', argument " "2"" of type '" "char const *""'");
2430   }
2431   arg2 = (char *)(buf2);
2432   res3 = SWIG_AsCharPtrAndSize(objv[3], &buf3, NULL, &alloc3);
2433   if (!SWIG_IsOK(res3)) {
2434     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "netpgp_setvar" "', argument " "3"" of type '" "char const *""'");
2435   }
2436   arg3 = (char *)(buf3);
2437   result = (int)netpgp_setvar(arg1,(char const *)arg2,(char const *)arg3);
2438   Tcl_SetObjResult(interp,SWIG_From_int((int)(result)));
2439   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2440   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
2441   return TCL_OK;
2442 fail:
2443   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2444   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
2445   return TCL_ERROR;
2446 }
2447
2448
2449 SWIGINTERN int
2450 _wrap_netpgp_getvar(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2451   netpgp_t *arg1 = (netpgp_t *) 0 ;
2452   char *arg2 = (char *) 0 ;
2453   char *result = 0 ;
2454   void *argp1 = 0 ;
2455   int res1 = 0 ;
2456   int res2 ;
2457   char *buf2 = 0 ;
2458   int alloc2 = 0 ;
2459
2460   if (SWIG_GetArgs(interp, objc, objv,"oo:netpgp_getvar netpgp_t * char const * ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2461   res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2462   if (!SWIG_IsOK(res1)) {
2463     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_getvar" "', argument " "1"" of type '" "netpgp_t *""'");
2464   }
2465   arg1 = (netpgp_t *)(argp1);
2466   res2 = SWIG_AsCharPtrAndSize(objv[2], &buf2, NULL, &alloc2);
2467   if (!SWIG_IsOK(res2)) {
2468     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_getvar" "', argument " "2"" of type '" "char const *""'");
2469   }
2470   arg2 = (char *)(buf2);
2471   result = (char *)netpgp_getvar(arg1,(char const *)arg2);
2472   Tcl_SetObjResult(interp,SWIG_FromCharPtr((const char *)result));
2473   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2474   return TCL_OK;
2475 fail:
2476   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2477   return TCL_ERROR;
2478 }
2479
2480
2481 SWIGINTERN int
2482 _wrap_netpgp_list_keys(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2483   netpgp_t *arg1 = (netpgp_t *) 0 ;
2484   int result;
2485   void *argp1 = 0 ;
2486   int res1 = 0 ;
2487
2488   if (SWIG_GetArgs(interp, objc, objv,"o:netpgp_list_keys netpgp_t * ",(void *)0) == TCL_ERROR) SWIG_fail;
2489   res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2490   if (!SWIG_IsOK(res1)) {
2491     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_list_keys" "', argument " "1"" of type '" "netpgp_t *""'");
2492   }
2493   arg1 = (netpgp_t *)(argp1);
2494   result = (int)netpgp_list_keys(arg1);
2495   Tcl_SetObjResult(interp,SWIG_From_int((int)(result)));
2496   return TCL_OK;
2497 fail:
2498   return TCL_ERROR;
2499 }
2500
2501
2502 SWIGINTERN int
2503 _wrap_netpgp_list_sigs(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2504   netpgp_t *arg1 = (netpgp_t *) 0 ;
2505   char *arg2 = (char *) 0 ;
2506   int result;
2507   void *argp1 = 0 ;
2508   int res1 = 0 ;
2509   int res2 ;
2510   char *buf2 = 0 ;
2511   int alloc2 = 0 ;
2512
2513   if (SWIG_GetArgs(interp, objc, objv,"oo:netpgp_list_sigs netpgp_t * char const * ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2514   res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2515   if (!SWIG_IsOK(res1)) {
2516     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_list_sigs" "', argument " "1"" of type '" "netpgp_t *""'");
2517   }
2518   arg1 = (netpgp_t *)(argp1);
2519   res2 = SWIG_AsCharPtrAndSize(objv[2], &buf2, NULL, &alloc2);
2520   if (!SWIG_IsOK(res2)) {
2521     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_list_sigs" "', argument " "2"" of type '" "char const *""'");
2522   }
2523   arg2 = (char *)(buf2);
2524   result = (int)netpgp_list_sigs(arg1,(char const *)arg2);
2525   Tcl_SetObjResult(interp,SWIG_From_int((int)(result)));
2526   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2527   return TCL_OK;
2528 fail:
2529   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2530   return TCL_ERROR;
2531 }
2532
2533
2534 SWIGINTERN int
2535 _wrap_netpgp_find_key(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2536   netpgp_t *arg1 = (netpgp_t *) 0 ;
2537   char *arg2 = (char *) 0 ;
2538   int result;
2539   void *argp1 = 0 ;
2540   int res1 = 0 ;
2541   int res2 ;
2542   char *buf2 = 0 ;
2543   int alloc2 = 0 ;
2544
2545   if (SWIG_GetArgs(interp, objc, objv,"oo:netpgp_find_key netpgp_t * char * ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2546   res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2547   if (!SWIG_IsOK(res1)) {
2548     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_find_key" "', argument " "1"" of type '" "netpgp_t *""'");
2549   }
2550   arg1 = (netpgp_t *)(argp1);
2551   res2 = SWIG_AsCharPtrAndSize(objv[2], &buf2, NULL, &alloc2);
2552   if (!SWIG_IsOK(res2)) {
2553     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_find_key" "', argument " "2"" of type '" "char *""'");
2554   }
2555   arg2 = (char *)(buf2);
2556   result = (int)netpgp_find_key(arg1,arg2);
2557   Tcl_SetObjResult(interp,SWIG_From_int((int)(result)));
2558   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2559   return TCL_OK;
2560 fail:
2561   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2562   return TCL_ERROR;
2563 }
2564
2565
2566 SWIGINTERN int
2567 _wrap_netpgp_get_key(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2568   netpgp_t *arg1 = (netpgp_t *) 0 ;
2569   char *arg2 = (char *) 0 ;
2570   char *result = 0 ;
2571   void *argp1 = 0 ;
2572   int res1 = 0 ;
2573   int res2 ;
2574   char *buf2 = 0 ;
2575   int alloc2 = 0 ;
2576
2577   if (SWIG_GetArgs(interp, objc, objv,"oo:netpgp_get_key netpgp_t * char const * ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2578   res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2579   if (!SWIG_IsOK(res1)) {
2580     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_get_key" "', argument " "1"" of type '" "netpgp_t *""'");
2581   }
2582   arg1 = (netpgp_t *)(argp1);
2583   res2 = SWIG_AsCharPtrAndSize(objv[2], &buf2, NULL, &alloc2);
2584   if (!SWIG_IsOK(res2)) {
2585     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_get_key" "', argument " "2"" of type '" "char const *""'");
2586   }
2587   arg2 = (char *)(buf2);
2588   result = (char *)netpgp_get_key(arg1,(char const *)arg2);
2589   Tcl_SetObjResult(interp,SWIG_FromCharPtr((const char *)result));
2590   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2591   return TCL_OK;
2592 fail:
2593   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2594   return TCL_ERROR;
2595 }
2596
2597
2598 SWIGINTERN int
2599 _wrap_netpgp_export_key(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2600   netpgp_t *arg1 = (netpgp_t *) 0 ;
2601   char *arg2 = (char *) 0 ;
2602   int result;
2603   void *argp1 = 0 ;
2604   int res1 = 0 ;
2605   int res2 ;
2606   char *buf2 = 0 ;
2607   int alloc2 = 0 ;
2608
2609   if (SWIG_GetArgs(interp, objc, objv,"oo:netpgp_export_key netpgp_t * char * ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2610   res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2611   if (!SWIG_IsOK(res1)) {
2612     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_export_key" "', argument " "1"" of type '" "netpgp_t *""'");
2613   }
2614   arg1 = (netpgp_t *)(argp1);
2615   res2 = SWIG_AsCharPtrAndSize(objv[2], &buf2, NULL, &alloc2);
2616   if (!SWIG_IsOK(res2)) {
2617     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_export_key" "', argument " "2"" of type '" "char *""'");
2618   }
2619   arg2 = (char *)(buf2);
2620   result = (int)netpgp_export_key(arg1,arg2);
2621   Tcl_SetObjResult(interp,SWIG_From_int((int)(result)));
2622   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2623   return TCL_OK;
2624 fail:
2625   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2626   return TCL_ERROR;
2627 }
2628
2629
2630 SWIGINTERN int
2631 _wrap_netpgp_import_key(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2632   netpgp_t *arg1 = (netpgp_t *) 0 ;
2633   char *arg2 = (char *) 0 ;
2634   int result;
2635   void *argp1 = 0 ;
2636   int res1 = 0 ;
2637   int res2 ;
2638   char *buf2 = 0 ;
2639   int alloc2 = 0 ;
2640
2641   if (SWIG_GetArgs(interp, objc, objv,"oo:netpgp_import_key netpgp_t * char * ",(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2642   res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2643   if (!SWIG_IsOK(res1)) {
2644     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_import_key" "', argument " "1"" of type '" "netpgp_t *""'");
2645   }
2646   arg1 = (netpgp_t *)(argp1);
2647   res2 = SWIG_AsCharPtrAndSize(objv[2], &buf2, NULL, &alloc2);
2648   if (!SWIG_IsOK(res2)) {
2649     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_import_key" "', argument " "2"" of type '" "char *""'");
2650   }
2651   arg2 = (char *)(buf2);
2652   result = (int)netpgp_import_key(arg1,arg2);
2653   Tcl_SetObjResult(interp,SWIG_From_int((int)(result)));
2654   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2655   return TCL_OK;
2656 fail:
2657   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2658   return TCL_ERROR;
2659 }
2660
2661
2662 SWIGINTERN int
2663 _wrap_netpgp_generate_key(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2664   netpgp_t *arg1 = (netpgp_t *) 0 ;
2665   char *arg2 = (char *) 0 ;
2666   int arg3 ;
2667   int result;
2668   void *argp1 = 0 ;
2669   int res1 = 0 ;
2670   int res2 ;
2671   char *buf2 = 0 ;
2672   int alloc2 = 0 ;
2673   int val3 ;
2674   int ecode3 = 0 ;
2675
2676   if (SWIG_GetArgs(interp, objc, objv,"ooo:netpgp_generate_key netpgp_t * char * int ",(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2677   res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2678   if (!SWIG_IsOK(res1)) {
2679     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_generate_key" "', argument " "1"" of type '" "netpgp_t *""'");
2680   }
2681   arg1 = (netpgp_t *)(argp1);
2682   res2 = SWIG_AsCharPtrAndSize(objv[2], &buf2, NULL, &alloc2);
2683   if (!SWIG_IsOK(res2)) {
2684     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_generate_key" "', argument " "2"" of type '" "char *""'");
2685   }
2686   arg2 = (char *)(buf2);
2687   ecode3 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[3], &val3);
2688   if (!SWIG_IsOK(ecode3)) {
2689     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "netpgp_generate_key" "', argument " "3"" of type '" "int""'");
2690   }
2691   arg3 = (int)(val3);
2692   result = (int)netpgp_generate_key(arg1,arg2,arg3);
2693   Tcl_SetObjResult(interp,SWIG_From_int((int)(result)));
2694   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2695   return TCL_OK;
2696 fail:
2697   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2698   return TCL_ERROR;
2699 }
2700
2701
2702 SWIGINTERN int
2703 _wrap_netpgp_encrypt_file(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2704   netpgp_t *arg1 = (netpgp_t *) 0 ;
2705   char *arg2 = (char *) 0 ;
2706   char *arg3 = (char *) 0 ;
2707   char *arg4 = (char *) 0 ;
2708   int arg5 ;
2709   int result;
2710   void *argp1 = 0 ;
2711   int res1 = 0 ;
2712   int res2 ;
2713   char *buf2 = 0 ;
2714   int alloc2 = 0 ;
2715   int res3 ;
2716   char *buf3 = 0 ;
2717   int alloc3 = 0 ;
2718   int res4 ;
2719   char *buf4 = 0 ;
2720   int alloc4 = 0 ;
2721   int val5 ;
2722   int ecode5 = 0 ;
2723
2724   if (SWIG_GetArgs(interp, objc, objv,"ooooo:netpgp_encrypt_file netpgp_t * char const * char const * char * int ",(void *)0,(void *)0,(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2725   res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2726   if (!SWIG_IsOK(res1)) {
2727     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_encrypt_file" "', argument " "1"" of type '" "netpgp_t *""'");
2728   }
2729   arg1 = (netpgp_t *)(argp1);
2730   res2 = SWIG_AsCharPtrAndSize(objv[2], &buf2, NULL, &alloc2);
2731   if (!SWIG_IsOK(res2)) {
2732     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_encrypt_file" "', argument " "2"" of type '" "char const *""'");
2733   }
2734   arg2 = (char *)(buf2);
2735   res3 = SWIG_AsCharPtrAndSize(objv[3], &buf3, NULL, &alloc3);
2736   if (!SWIG_IsOK(res3)) {
2737     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "netpgp_encrypt_file" "', argument " "3"" of type '" "char const *""'");
2738   }
2739   arg3 = (char *)(buf3);
2740   res4 = SWIG_AsCharPtrAndSize(objv[4], &buf4, NULL, &alloc4);
2741   if (!SWIG_IsOK(res4)) {
2742     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "netpgp_encrypt_file" "', argument " "4"" of type '" "char *""'");
2743   }
2744   arg4 = (char *)(buf4);
2745   ecode5 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[5], &val5);
2746   if (!SWIG_IsOK(ecode5)) {
2747     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "netpgp_encrypt_file" "', argument " "5"" of type '" "int""'");
2748   }
2749   arg5 = (int)(val5);
2750   result = (int)netpgp_encrypt_file(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5);
2751   Tcl_SetObjResult(interp,SWIG_From_int((int)(result)));
2752   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2753   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
2754   if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
2755   return TCL_OK;
2756 fail:
2757   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2758   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
2759   if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
2760   return TCL_ERROR;
2761 }
2762
2763
2764 SWIGINTERN int
2765 _wrap_netpgp_decrypt_file(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2766   netpgp_t *arg1 = (netpgp_t *) 0 ;
2767   char *arg2 = (char *) 0 ;
2768   char *arg3 = (char *) 0 ;
2769   int arg4 ;
2770   int result;
2771   void *argp1 = 0 ;
2772   int res1 = 0 ;
2773   int res2 ;
2774   char *buf2 = 0 ;
2775   int alloc2 = 0 ;
2776   int res3 ;
2777   char *buf3 = 0 ;
2778   int alloc3 = 0 ;
2779   int val4 ;
2780   int ecode4 = 0 ;
2781
2782   if (SWIG_GetArgs(interp, objc, objv,"oooo:netpgp_decrypt_file netpgp_t * char const * char * int ",(void *)0,(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2783   res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2784   if (!SWIG_IsOK(res1)) {
2785     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_decrypt_file" "', argument " "1"" of type '" "netpgp_t *""'");
2786   }
2787   arg1 = (netpgp_t *)(argp1);
2788   res2 = SWIG_AsCharPtrAndSize(objv[2], &buf2, NULL, &alloc2);
2789   if (!SWIG_IsOK(res2)) {
2790     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_decrypt_file" "', argument " "2"" of type '" "char const *""'");
2791   }
2792   arg2 = (char *)(buf2);
2793   res3 = SWIG_AsCharPtrAndSize(objv[3], &buf3, NULL, &alloc3);
2794   if (!SWIG_IsOK(res3)) {
2795     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "netpgp_decrypt_file" "', argument " "3"" of type '" "char *""'");
2796   }
2797   arg3 = (char *)(buf3);
2798   ecode4 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[4], &val4);
2799   if (!SWIG_IsOK(ecode4)) {
2800     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "netpgp_decrypt_file" "', argument " "4"" of type '" "int""'");
2801   }
2802   arg4 = (int)(val4);
2803   result = (int)netpgp_decrypt_file(arg1,(char const *)arg2,arg3,arg4);
2804   Tcl_SetObjResult(interp,SWIG_From_int((int)(result)));
2805   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2806   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
2807   return TCL_OK;
2808 fail:
2809   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2810   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
2811   return TCL_ERROR;
2812 }
2813
2814
2815 SWIGINTERN int
2816 _wrap_netpgp_sign_file(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2817   netpgp_t *arg1 = (netpgp_t *) 0 ;
2818   char *arg2 = (char *) 0 ;
2819   char *arg3 = (char *) 0 ;
2820   char *arg4 = (char *) 0 ;
2821   int arg5 ;
2822   int arg6 ;
2823   int arg7 ;
2824   int result;
2825   void *argp1 = 0 ;
2826   int res1 = 0 ;
2827   int res2 ;
2828   char *buf2 = 0 ;
2829   int alloc2 = 0 ;
2830   int res3 ;
2831   char *buf3 = 0 ;
2832   int alloc3 = 0 ;
2833   int res4 ;
2834   char *buf4 = 0 ;
2835   int alloc4 = 0 ;
2836   int val5 ;
2837   int ecode5 = 0 ;
2838   int val6 ;
2839   int ecode6 = 0 ;
2840   int val7 ;
2841   int ecode7 = 0 ;
2842
2843   if (SWIG_GetArgs(interp, objc, objv,"ooooooo:netpgp_sign_file netpgp_t * char const * char const * char * int int int ",(void *)0,(void *)0,(void *)0,(void *)0,(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2844   res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2845   if (!SWIG_IsOK(res1)) {
2846     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_sign_file" "', argument " "1"" of type '" "netpgp_t *""'");
2847   }
2848   arg1 = (netpgp_t *)(argp1);
2849   res2 = SWIG_AsCharPtrAndSize(objv[2], &buf2, NULL, &alloc2);
2850   if (!SWIG_IsOK(res2)) {
2851     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_sign_file" "', argument " "2"" of type '" "char const *""'");
2852   }
2853   arg2 = (char *)(buf2);
2854   res3 = SWIG_AsCharPtrAndSize(objv[3], &buf3, NULL, &alloc3);
2855   if (!SWIG_IsOK(res3)) {
2856     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "netpgp_sign_file" "', argument " "3"" of type '" "char const *""'");
2857   }
2858   arg3 = (char *)(buf3);
2859   res4 = SWIG_AsCharPtrAndSize(objv[4], &buf4, NULL, &alloc4);
2860   if (!SWIG_IsOK(res4)) {
2861     SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "netpgp_sign_file" "', argument " "4"" of type '" "char *""'");
2862   }
2863   arg4 = (char *)(buf4);
2864   ecode5 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[5], &val5);
2865   if (!SWIG_IsOK(ecode5)) {
2866     SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "netpgp_sign_file" "', argument " "5"" of type '" "int""'");
2867   }
2868   arg5 = (int)(val5);
2869   ecode6 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[6], &val6);
2870   if (!SWIG_IsOK(ecode6)) {
2871     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "netpgp_sign_file" "', argument " "6"" of type '" "int""'");
2872   }
2873   arg6 = (int)(val6);
2874   ecode7 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[7], &val7);
2875   if (!SWIG_IsOK(ecode7)) {
2876     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "netpgp_sign_file" "', argument " "7"" of type '" "int""'");
2877   }
2878   arg7 = (int)(val7);
2879   result = (int)netpgp_sign_file(arg1,(char const *)arg2,(char const *)arg3,arg4,arg5,arg6,arg7);
2880   Tcl_SetObjResult(interp,SWIG_From_int((int)(result)));
2881   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2882   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
2883   if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
2884   return TCL_OK;
2885 fail:
2886   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2887   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
2888   if (alloc4 == SWIG_NEWOBJ) free((char*)buf4);
2889   return TCL_ERROR;
2890 }
2891
2892
2893 SWIGINTERN int
2894 _wrap_netpgp_verify_file(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2895   netpgp_t *arg1 = (netpgp_t *) 0 ;
2896   char *arg2 = (char *) 0 ;
2897   char *arg3 = (char *) 0 ;
2898   int arg4 ;
2899   int result;
2900   void *argp1 = 0 ;
2901   int res1 = 0 ;
2902   int res2 ;
2903   char *buf2 = 0 ;
2904   int alloc2 = 0 ;
2905   int res3 ;
2906   char *buf3 = 0 ;
2907   int alloc3 = 0 ;
2908   int val4 ;
2909   int ecode4 = 0 ;
2910
2911   if (SWIG_GetArgs(interp, objc, objv,"oooo:netpgp_verify_file netpgp_t * char const * char const * int ",(void *)0,(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2912   res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2913   if (!SWIG_IsOK(res1)) {
2914     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_verify_file" "', argument " "1"" of type '" "netpgp_t *""'");
2915   }
2916   arg1 = (netpgp_t *)(argp1);
2917   res2 = SWIG_AsCharPtrAndSize(objv[2], &buf2, NULL, &alloc2);
2918   if (!SWIG_IsOK(res2)) {
2919     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_verify_file" "', argument " "2"" of type '" "char const *""'");
2920   }
2921   arg2 = (char *)(buf2);
2922   res3 = SWIG_AsCharPtrAndSize(objv[3], &buf3, NULL, &alloc3);
2923   if (!SWIG_IsOK(res3)) {
2924     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "netpgp_verify_file" "', argument " "3"" of type '" "char const *""'");
2925   }
2926   arg3 = (char *)(buf3);
2927   ecode4 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[4], &val4);
2928   if (!SWIG_IsOK(ecode4)) {
2929     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "netpgp_verify_file" "', argument " "4"" of type '" "int""'");
2930   }
2931   arg4 = (int)(val4);
2932   result = (int)netpgp_verify_file(arg1,(char const *)arg2,(char const *)arg3,arg4);
2933   Tcl_SetObjResult(interp,SWIG_From_int((int)(result)));
2934   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2935   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
2936   return TCL_OK;
2937 fail:
2938   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
2939   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
2940   return TCL_ERROR;
2941 }
2942
2943
2944 SWIGINTERN int
2945 _wrap_netpgp_sign_memory(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
2946   netpgp_t *arg1 = (netpgp_t *) 0 ;
2947   char *arg2 = (char *) 0 ;
2948   char *arg3 = (char *) 0 ;
2949   size_t arg4 ;
2950   char *arg5 = (char *) 0 ;
2951   size_t arg6 ;
2952   unsigned int arg7 ;
2953   unsigned int arg8 ;
2954   int result;
2955   void *argp1 = 0 ;
2956   int res1 = 0 ;
2957   int res2 ;
2958   char *buf2 = 0 ;
2959   int alloc2 = 0 ;
2960   int res3 ;
2961   char *buf3 = 0 ;
2962   int alloc3 = 0 ;
2963   size_t val4 ;
2964   int ecode4 = 0 ;
2965   int res5 ;
2966   char *buf5 = 0 ;
2967   int alloc5 = 0 ;
2968   size_t val6 ;
2969   int ecode6 = 0 ;
2970   unsigned int val7 ;
2971   int ecode7 = 0 ;
2972   unsigned int val8 ;
2973   int ecode8 = 0 ;
2974
2975   if (SWIG_GetArgs(interp, objc, objv,"oooooooo:netpgp_sign_memory netpgp_t * char const * char * size_t char * size_t unsigned int const unsigned int const ",(void *)0,(void *)0,(void *)0,(void *)0,(void *)0,(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
2976   res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
2977   if (!SWIG_IsOK(res1)) {
2978     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_sign_memory" "', argument " "1"" of type '" "netpgp_t *""'");
2979   }
2980   arg1 = (netpgp_t *)(argp1);
2981   res2 = SWIG_AsCharPtrAndSize(objv[2], &buf2, NULL, &alloc2);
2982   if (!SWIG_IsOK(res2)) {
2983     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_sign_memory" "', argument " "2"" of type '" "char const *""'");
2984   }
2985   arg2 = (char *)(buf2);
2986   res3 = SWIG_AsCharPtrAndSize(objv[3], &buf3, NULL, &alloc3);
2987   if (!SWIG_IsOK(res3)) {
2988     SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "netpgp_sign_memory" "', argument " "3"" of type '" "char *""'");
2989   }
2990   arg3 = (char *)(buf3);
2991   ecode4 = SWIG_AsVal_size_t SWIG_TCL_CALL_ARGS_2(objv[4], &val4);
2992   if (!SWIG_IsOK(ecode4)) {
2993     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "netpgp_sign_memory" "', argument " "4"" of type '" "size_t""'");
2994   }
2995   arg4 = (size_t)(val4);
2996   res5 = SWIG_AsCharPtrAndSize(objv[5], &buf5, NULL, &alloc5);
2997   if (!SWIG_IsOK(res5)) {
2998     SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "netpgp_sign_memory" "', argument " "5"" of type '" "char *""'");
2999   }
3000   arg5 = (char *)(buf5);
3001   ecode6 = SWIG_AsVal_size_t SWIG_TCL_CALL_ARGS_2(objv[6], &val6);
3002   if (!SWIG_IsOK(ecode6)) {
3003     SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "netpgp_sign_memory" "', argument " "6"" of type '" "size_t""'");
3004   }
3005   arg6 = (size_t)(val6);
3006   ecode7 = SWIG_AsVal_unsigned_SS_int SWIG_TCL_CALL_ARGS_2(objv[7], &val7);
3007   if (!SWIG_IsOK(ecode7)) {
3008     SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "netpgp_sign_memory" "', argument " "7"" of type '" "unsigned int""'");
3009   }
3010   arg7 = (unsigned int)(val7);
3011   ecode8 = SWIG_AsVal_unsigned_SS_int SWIG_TCL_CALL_ARGS_2(objv[8], &val8);
3012   if (!SWIG_IsOK(ecode8)) {
3013     SWIG_exception_fail(SWIG_ArgError(ecode8), "in method '" "netpgp_sign_memory" "', argument " "8"" of type '" "unsigned int""'");
3014   }
3015   arg8 = (unsigned int)(val8);
3016   result = (int)netpgp_sign_memory(arg1,(char const *)arg2,arg3,arg4,arg5,arg6,arg7,arg8);
3017   Tcl_SetObjResult(interp,SWIG_From_int((int)(result)));
3018   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3019   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
3020   if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
3021   return TCL_OK;
3022 fail:
3023   if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
3024   if (alloc3 == SWIG_NEWOBJ) free((char*)buf3);
3025   if (alloc5 == SWIG_NEWOBJ) free((char*)buf5);
3026   return TCL_ERROR;
3027 }
3028
3029
3030 SWIGINTERN int
3031 _wrap_netpgp_verify_memory(ClientData clientData SWIGUNUSED, Tcl_Interp *interp, int objc, Tcl_Obj *CONST objv[]) {
3032   netpgp_t *arg1 = (netpgp_t *) 0 ;
3033   void *arg2 = (void *) 0 ;
3034   size_t arg3 ;
3035   int arg4 ;
3036   int result;
3037   void *argp1 = 0 ;
3038   int res1 = 0 ;
3039   int res2 ;
3040   size_t val3 ;
3041   int ecode3 = 0 ;
3042   int val4 ;
3043   int ecode4 = 0 ;
3044
3045   if (SWIG_GetArgs(interp, objc, objv,"oooo:netpgp_verify_memory netpgp_t * void const * size_t const int const ",(void *)0,(void *)0,(void *)0,(void *)0) == TCL_ERROR) SWIG_fail;
3046   res1 = SWIG_ConvertPtr(objv[1], &argp1,SWIGTYPE_p_netpgp_t, 0 |  0 );
3047   if (!SWIG_IsOK(res1)) {
3048     SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "netpgp_verify_memory" "', argument " "1"" of type '" "netpgp_t *""'");
3049   }
3050   arg1 = (netpgp_t *)(argp1);
3051   res2 = SWIG_ConvertPtr(objv[2],SWIG_as_voidptrptr(&arg2), 0, 0);
3052   if (!SWIG_IsOK(res2)) {
3053     SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "netpgp_verify_memory" "', argument " "2"" of type '" "void const *""'");
3054   }
3055   ecode3 = SWIG_AsVal_size_t SWIG_TCL_CALL_ARGS_2(objv[3], &val3);
3056   if (!SWIG_IsOK(ecode3)) {
3057     SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "netpgp_verify_memory" "', argument " "3"" of type '" "size_t""'");
3058   }
3059   arg3 = (size_t)(val3);
3060   ecode4 = SWIG_AsVal_int SWIG_TCL_CALL_ARGS_2(objv[4], &val4);
3061   if (!SWIG_IsOK(ecode4)) {
3062     SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "netpgp_verify_memory" "', argument " "4"" of type '" "int""'");
3063   }
3064   arg4 = (int)(val4);
3065   result = (int)netpgp_verify_memory(arg1,(void const *)arg2,arg3,arg4);
3066   Tcl_SetObjResult(interp,SWIG_From_int((int)(result)));
3067   return TCL_OK;
3068 fail:
3069   return TCL_ERROR;
3070 }
3071
3072
3073
3074 static swig_command_info swig_commands[] = {
3075     { SWIG_prefix "netpgp_t_c_set", (swig_wrapper_func) _wrap_netpgp_t_c_set, NULL},
3076     { SWIG_prefix "netpgp_t_c_get", (swig_wrapper_func) _wrap_netpgp_t_c_get, NULL},
3077     { SWIG_prefix "netpgp_t_size_set", (swig_wrapper_func) _wrap_netpgp_t_size_set, NULL},
3078     { SWIG_prefix "netpgp_t_size_get", (swig_wrapper_func) _wrap_netpgp_t_size_get, NULL},
3079     { SWIG_prefix "netpgp_t_name_set", (swig_wrapper_func) _wrap_netpgp_t_name_set, NULL},
3080     { SWIG_prefix "netpgp_t_name_get", (swig_wrapper_func) _wrap_netpgp_t_name_get, NULL},
3081     { SWIG_prefix "netpgp_t_value_set", (swig_wrapper_func) _wrap_netpgp_t_value_set, NULL},
3082     { SWIG_prefix "netpgp_t_value_get", (swig_wrapper_func) _wrap_netpgp_t_value_get, NULL},
3083     { SWIG_prefix "netpgp_t_pubring_set", (swig_wrapper_func) _wrap_netpgp_t_pubring_set, NULL},
3084     { SWIG_prefix "netpgp_t_pubring_get", (swig_wrapper_func) _wrap_netpgp_t_pubring_get, NULL},
3085     { SWIG_prefix "netpgp_t_secring_set", (swig_wrapper_func) _wrap_netpgp_t_secring_set, NULL},
3086     { SWIG_prefix "netpgp_t_secring_get", (swig_wrapper_func) _wrap_netpgp_t_secring_get, NULL},
3087     { SWIG_prefix "netpgp_t_io_set", (swig_wrapper_func) _wrap_netpgp_t_io_set, NULL},
3088     { SWIG_prefix "netpgp_t_io_get", (swig_wrapper_func) _wrap_netpgp_t_io_get, NULL},
3089     { SWIG_prefix "netpgp_t_passfp_set", (swig_wrapper_func) _wrap_netpgp_t_passfp_set, NULL},
3090     { SWIG_prefix "netpgp_t_passfp_get", (swig_wrapper_func) _wrap_netpgp_t_passfp_get, NULL},
3091     { SWIG_prefix "new_netpgp_t", (swig_wrapper_func) _wrap_new_netpgp_t, NULL},
3092     { SWIG_prefix "delete_netpgp_t", (swig_wrapper_func) _wrap_delete_netpgp_t, NULL},
3093     { SWIG_prefix "netpgp_t", (swig_wrapper_func) SWIG_ObjectConstructor, (ClientData)&_wrap_class_netpgp_t},
3094     { SWIG_prefix "netpgp_init", (swig_wrapper_func) _wrap_netpgp_init, NULL},
3095     { SWIG_prefix "netpgp_end", (swig_wrapper_func) _wrap_netpgp_end, NULL},
3096     { SWIG_prefix "netpgp_set_debug", (swig_wrapper_func) _wrap_netpgp_set_debug, NULL},
3097     { SWIG_prefix "netpgp_get_debug", (swig_wrapper_func) _wrap_netpgp_get_debug, NULL},
3098     { SWIG_prefix "netpgp_get_info", (swig_wrapper_func) _wrap_netpgp_get_info, NULL},
3099     { SWIG_prefix "netpgp_list_packets", (swig_wrapper_func) _wrap_netpgp_list_packets, NULL},
3100     { SWIG_prefix "netpgp_setvar", (swig_wrapper_func) _wrap_netpgp_setvar, NULL},
3101     { SWIG_prefix "netpgp_getvar", (swig_wrapper_func) _wrap_netpgp_getvar, NULL},
3102     { SWIG_prefix "netpgp_list_keys", (swig_wrapper_func) _wrap_netpgp_list_keys, NULL},
3103     { SWIG_prefix "netpgp_list_sigs", (swig_wrapper_func) _wrap_netpgp_list_sigs, NULL},
3104     { SWIG_prefix "netpgp_find_key", (swig_wrapper_func) _wrap_netpgp_find_key, NULL},
3105     { SWIG_prefix "netpgp_get_key", (swig_wrapper_func) _wrap_netpgp_get_key, NULL},
3106     { SWIG_prefix "netpgp_export_key", (swig_wrapper_func) _wrap_netpgp_export_key, NULL},
3107     { SWIG_prefix "netpgp_import_key", (swig_wrapper_func) _wrap_netpgp_import_key, NULL},
3108     { SWIG_prefix "netpgp_generate_key", (swig_wrapper_func) _wrap_netpgp_generate_key, NULL},
3109     { SWIG_prefix "netpgp_encrypt_file", (swig_wrapper_func) _wrap_netpgp_encrypt_file, NULL},
3110     { SWIG_prefix "netpgp_decrypt_file", (swig_wrapper_func) _wrap_netpgp_decrypt_file, NULL},
3111     { SWIG_prefix "netpgp_sign_file", (swig_wrapper_func) _wrap_netpgp_sign_file, NULL},
3112     { SWIG_prefix "netpgp_verify_file", (swig_wrapper_func) _wrap_netpgp_verify_file, NULL},
3113     { SWIG_prefix "netpgp_sign_memory", (swig_wrapper_func) _wrap_netpgp_sign_memory, NULL},
3114     { SWIG_prefix "netpgp_verify_memory", (swig_wrapper_func) _wrap_netpgp_verify_memory, NULL},
3115     {0, 0, 0}
3116 };
3117
3118 static swig_var_info swig_variables[] = {
3119     {0,0,0,0}
3120 };
3121
3122 static swig_const_info swig_constants[] = {
3123     {0,0,0,0,0,0}
3124 };
3125
3126 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
3127
3128 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
3129 static swig_type_info _swigt__p_netpgp_t = {"_p_netpgp_t", "struct netpgp_t *|netpgp_t *", 0, 0, (void*)&_wrap_class_netpgp_t, 0};
3130 static swig_type_info _swigt__p_p_char = {"_p_p_char", "char **", 0, 0, (void*)0, 0};
3131 static swig_type_info _swigt__p_void = {"_p_void", "void *", 0, 0, (void*)0, 0};
3132
3133 static swig_type_info *swig_type_initial[] = {
3134   &_swigt__p_char,
3135   &_swigt__p_netpgp_t,
3136   &_swigt__p_p_char,
3137   &_swigt__p_void,
3138 };
3139
3140 static swig_cast_info _swigc__p_char[] = {  {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
3141 static swig_cast_info _swigc__p_netpgp_t[] = {  {&_swigt__p_netpgp_t, 0, 0, 0},{0, 0, 0, 0}};
3142 static swig_cast_info _swigc__p_p_char[] = {  {&_swigt__p_p_char, 0, 0, 0},{0, 0, 0, 0}};
3143 static swig_cast_info _swigc__p_void[] = {  {&_swigt__p_void, 0, 0, 0},{0, 0, 0, 0}};
3144
3145 static swig_cast_info *swig_cast_initial[] = {
3146   _swigc__p_char,
3147   _swigc__p_netpgp_t,
3148   _swigc__p_p_char,
3149   _swigc__p_void,
3150 };
3151
3152
3153 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
3154
3155 #ifdef __cplusplus
3156 }
3157 #endif
3158 /* -----------------------------------------------------------------------------
3159  * Type initialization:
3160  * This problem is tough by the requirement that no dynamic
3161  * memory is used. Also, since swig_type_info structures store pointers to
3162  * swig_cast_info structures and swig_cast_info structures store pointers back
3163  * to swig_type_info structures, we need some lookup code at initialization.
3164  * The idea is that swig generates all the structures that are needed.
3165  * The runtime then collects these partially filled structures.
3166  * The SWIG_InitializeModule function takes these initial arrays out of
3167  * swig_module, and does all the lookup, filling in the swig_module.types
3168  * array with the correct data and linking the correct swig_cast_info
3169  * structures together.
3170  *
3171  * The generated swig_type_info structures are assigned staticly to an initial
3172  * array. We just loop through that array, and handle each type individually.
3173  * First we lookup if this type has been already loaded, and if so, use the
3174  * loaded structure instead of the generated one. Then we have to fill in the
3175  * cast linked list. The cast data is initially stored in something like a
3176  * two-dimensional array. Each row corresponds to a type (there are the same
3177  * number of rows as there are in the swig_type_initial array). Each entry in
3178  * a column is one of the swig_cast_info structures for that type.
3179  * The cast_initial array is actually an array of arrays, because each row has
3180  * a variable number of columns. So to actually build the cast linked list,
3181  * we find the array of casts associated with the type, and loop through it
3182  * adding the casts to the list. The one last trick we need to do is making
3183  * sure the type pointer in the swig_cast_info struct is correct.
3184  *
3185  * First off, we lookup the cast->type name to see if it is already loaded.
3186  * There are three cases to handle:
3187  *  1) If the cast->type has already been loaded AND the type we are adding
3188  *     casting info to has not been loaded (it is in this module), THEN we
3189  *     replace the cast->type pointer with the type pointer that has already
3190  *     been loaded.
3191  *  2) If BOTH types (the one we are adding casting info to, and the
3192  *     cast->type) are loaded, THEN the cast info has already been loaded by
3193  *     the previous module so we just ignore it.
3194  *  3) Finally, if cast->type has not already been loaded, then we add that
3195  *     swig_cast_info to the linked list (because the cast->type) pointer will
3196  *     be correct.
3197  * ----------------------------------------------------------------------------- */
3198
3199 #ifdef __cplusplus
3200 extern "C" {
3201 #if 0
3202 } /* c-mode */
3203 #endif
3204 #endif
3205
3206 #if 0
3207 #define SWIGRUNTIME_DEBUG
3208 #endif
3209
3210
3211 SWIGRUNTIME void
3212 SWIG_InitializeModule(void *clientdata) {
3213   size_t i;
3214   swig_module_info *module_head, *iter;
3215   int found;
3216
3217   clientdata = clientdata;
3218
3219   /* check to see if the circular list has been setup, if not, set it up */
3220   if (swig_module.next==0) {
3221     /* Initialize the swig_module */
3222     swig_module.type_initial = swig_type_initial;
3223     swig_module.cast_initial = swig_cast_initial;
3224     swig_module.next = &swig_module;
3225   }
3226
3227   /* Try and load any already created modules */
3228   module_head = SWIG_GetModule(clientdata);
3229   if (!module_head) {
3230     /* This is the first module loaded for this interpreter */
3231     /* so set the swig module into the interpreter */
3232     SWIG_SetModule(clientdata, &swig_module);
3233     module_head = &swig_module;
3234   } else {
3235     /* the interpreter has loaded a SWIG module, but has it loaded this one? */
3236     found=0;
3237     iter=module_head;
3238     do {
3239       if (iter==&swig_module) {
3240         found=1;
3241         break;
3242       }
3243       iter=iter->next;
3244     } while (iter!= module_head);
3245
3246     /* if the is found in the list, then all is done and we may leave */
3247     if (found) return;
3248     /* otherwise we must add out module into the list */
3249     swig_module.next = module_head->next;
3250     module_head->next = &swig_module;
3251   }
3252
3253   /* Now work on filling in swig_module.types */
3254 #ifdef SWIGRUNTIME_DEBUG
3255   printf("SWIG_InitializeModule: size %d\n", swig_module.size);
3256 #endif
3257   for (i = 0; i < swig_module.size; ++i) {
3258     swig_type_info *type = 0;
3259     swig_type_info *ret;
3260     swig_cast_info *cast;
3261
3262 #ifdef SWIGRUNTIME_DEBUG
3263     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
3264 #endif
3265
3266     /* if there is another module already loaded */
3267     if (swig_module.next != &swig_module) {
3268       type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
3269     }
3270     if (type) {
3271       /* Overwrite clientdata field */
3272 #ifdef SWIGRUNTIME_DEBUG
3273       printf("SWIG_InitializeModule: found type %s\n", type->name);
3274 #endif
3275       if (swig_module.type_initial[i]->clientdata) {
3276         type->clientdata = swig_module.type_initial[i]->clientdata;
3277 #ifdef SWIGRUNTIME_DEBUG
3278         printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
3279 #endif
3280       }
3281     } else {
3282       type = swig_module.type_initial[i];
3283     }
3284
3285     /* Insert casting types */
3286     cast = swig_module.cast_initial[i];
3287     while (cast->type) {
3288       /* Don't need to add information already in the list */
3289       ret = 0;
3290 #ifdef SWIGRUNTIME_DEBUG
3291       printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
3292 #endif
3293       if (swig_module.next != &swig_module) {
3294         ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
3295 #ifdef SWIGRUNTIME_DEBUG
3296         if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
3297 #endif
3298       }
3299       if (ret) {
3300         if (type == swig_module.type_initial[i]) {
3301 #ifdef SWIGRUNTIME_DEBUG
3302           printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
3303 #endif
3304           cast->type = ret;
3305           ret = 0;
3306         } else {
3307           /* Check for casting already in the list */
3308           swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
3309 #ifdef SWIGRUNTIME_DEBUG
3310           if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
3311 #endif
3312           if (!ocast) ret = 0;
3313         }
3314       }
3315
3316       if (!ret) {
3317 #ifdef SWIGRUNTIME_DEBUG
3318         printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
3319 #endif
3320         if (type->cast) {
3321           type->cast->prev = cast;
3322           cast->next = type->cast;
3323         }
3324         type->cast = cast;
3325       }
3326       cast++;
3327     }
3328     /* Set entry in modules->types array equal to the type */
3329     swig_module.types[i] = type;
3330   }
3331   swig_module.types[i] = 0;
3332
3333 #ifdef SWIGRUNTIME_DEBUG
3334   printf("**** SWIG_InitializeModule: Cast List ******\n");
3335   for (i = 0; i < swig_module.size; ++i) {
3336     int j = 0;
3337     swig_cast_info *cast = swig_module.cast_initial[i];
3338     printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
3339     while (cast->type) {
3340       printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
3341       cast++;
3342       ++j;
3343     }
3344     printf("---- Total casts: %d\n",j);
3345   }
3346   printf("**** SWIG_InitializeModule: Cast List ******\n");
3347 #endif
3348 }
3349
3350 /* This function will propagate the clientdata field of type to
3351 * any new swig_type_info structures that have been added into the list
3352 * of equivalent types.  It is like calling
3353 * SWIG_TypeClientData(type, clientdata) a second time.
3354 */
3355 SWIGRUNTIME void
3356 SWIG_PropagateClientData(void) {
3357   size_t i;
3358   swig_cast_info *equiv;
3359   static int init_run = 0;
3360
3361   if (init_run) return;
3362   init_run = 1;
3363
3364   for (i = 0; i < swig_module.size; i++) {
3365     if (swig_module.types[i]->clientdata) {
3366       equiv = swig_module.types[i]->cast;
3367       while (equiv) {
3368         if (!equiv->converter) {
3369           if (equiv->type && !equiv->type->clientdata)
3370           SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
3371         }
3372         equiv = equiv->next;
3373       }
3374     }
3375   }
3376 }
3377
3378 #ifdef __cplusplus
3379 #if 0
3380 {
3381   /* c-mode */
3382 #endif
3383 }
3384 #endif
3385
3386
3387 #ifdef __cplusplus
3388 extern "C" {
3389 #endif
3390
3391   /* -----------------------------------------------------------------------------
3392    * constants/methods manipulation
3393    * ----------------------------------------------------------------------------- */
3394
3395   /* Install Constants */
3396
3397   SWIGINTERN void
3398   SWIG_Tcl_InstallConstants(Tcl_Interp *interp, swig_const_info constants[]) {
3399     int i;
3400     Tcl_Obj *obj;
3401
3402     if (!swigconstTableinit) {
3403       Tcl_InitHashTable(&swigconstTable, TCL_STRING_KEYS);
3404       swigconstTableinit = 1;
3405     }
3406     for (i = 0; constants[i].type; i++) {
3407       switch(constants[i].type) {
3408       case SWIG_TCL_POINTER:
3409         obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
3410         break;
3411       case SWIG_TCL_BINARY:
3412         obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
3413         break;
3414       default:
3415         obj = 0;
3416         break;
3417       }
3418       if (obj) {
3419         SWIG_Tcl_SetConstantObj(interp, constants[i].name, obj);
3420       }
3421     }
3422   }
3423
3424 #ifdef __cplusplus
3425 }
3426 #endif
3427
3428 /* -----------------------------------------------------------------------------*
3429  *  Partial Init method
3430  * -----------------------------------------------------------------------------*/
3431
3432 SWIGEXPORT int SWIG_init(Tcl_Interp *interp) {
3433   int i;
3434   if (interp == 0) return TCL_ERROR;
3435 #ifdef USE_TCL_STUBS
3436   if (Tcl_InitStubs(interp, (char*)"8.1", 0) == NULL) {
3437     return TCL_ERROR;
3438   }
3439 #endif
3440   Tcl_PkgProvide(interp, (char*)SWIG_name, (char*)SWIG_version);
3441
3442 #ifdef SWIG_namespace
3443   Tcl_Eval(interp, "namespace eval " SWIG_namespace " { }");
3444 #endif
3445
3446   SWIG_InitializeModule((void *) interp);
3447   SWIG_PropagateClientData();
3448
3449   for (i = 0; swig_commands[i].name; i++) {
3450     Tcl_CreateObjCommand(interp, (char *) swig_commands[i].name, (swig_wrapper_func) swig_commands[i].wrapper,
3451       swig_commands[i].clientdata, NULL);
3452   }
3453   for (i = 0; swig_variables[i].name; i++) {
3454     Tcl_SetVar(interp, (char *) swig_variables[i].name, (char *) "", TCL_GLOBAL_ONLY);
3455     Tcl_TraceVar(interp, (char *) swig_variables[i].name, TCL_TRACE_READS | TCL_GLOBAL_ONLY,
3456       (Tcl_VarTraceProc *) swig_variables[i].get, (ClientData) swig_variables[i].addr);
3457     Tcl_TraceVar(interp, (char *) swig_variables[i].name, TCL_TRACE_WRITES | TCL_GLOBAL_ONLY,
3458       (Tcl_VarTraceProc *) swig_variables[i].set, (ClientData) swig_variables[i].addr);
3459   }
3460
3461   SWIG_Tcl_InstallConstants(interp, swig_constants);
3462
3463
3464   return TCL_OK;
3465 }
3466 SWIGEXPORT int Netpgptcl_SafeInit(Tcl_Interp *interp) {
3467   return SWIG_init(interp);
3468 }
3469