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