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 3470
Indexes created Thu Jun 11 00:25:07 UTC 2026