00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011 #define SWIGPERL
00012 #define SWIG_CASTRANK_MODE
00013
00014
00015
00016
00017
00018
00019 #ifndef SWIGTEMPLATEDISAMBIGUATOR
00020 # if defined(__SUNPRO_CC) && (__SUNPRO_CC <= 0x560)
00021 # define SWIGTEMPLATEDISAMBIGUATOR template
00022 # elif defined(__HP_aCC)
00023
00024
00025 # define SWIGTEMPLATEDISAMBIGUATOR template
00026 # else
00027 # define SWIGTEMPLATEDISAMBIGUATOR
00028 # endif
00029 #endif
00030
00031
00032 #ifndef SWIGINLINE
00033 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
00034 # define SWIGINLINE inline
00035 # else
00036 # define SWIGINLINE
00037 # endif
00038 #endif
00039
00040
00041 #ifndef SWIGUNUSED
00042 # if defined(__GNUC__)
00043 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
00044 # define SWIGUNUSED __attribute__ ((__unused__))
00045 # else
00046 # define SWIGUNUSED
00047 # endif
00048 # elif defined(__ICC)
00049 # define SWIGUNUSED __attribute__ ((__unused__))
00050 # else
00051 # define SWIGUNUSED
00052 # endif
00053 #endif
00054
00055 #ifndef SWIG_MSC_UNSUPPRESS_4505
00056 # if defined(_MSC_VER)
00057 # pragma warning(disable : 4505)
00058 # endif
00059 #endif
00060
00061 #ifndef SWIGUNUSEDPARM
00062 # ifdef __cplusplus
00063 # define SWIGUNUSEDPARM(p)
00064 # else
00065 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
00066 # endif
00067 #endif
00068
00069
00070 #ifndef SWIGINTERN
00071 # define SWIGINTERN static SWIGUNUSED
00072 #endif
00073
00074
00075 #ifndef SWIGINTERNINLINE
00076 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
00077 #endif
00078
00079
00080 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
00081 # ifndef GCC_HASCLASSVISIBILITY
00082 # define GCC_HASCLASSVISIBILITY
00083 # endif
00084 #endif
00085
00086 #ifndef SWIGEXPORT
00087 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
00088 # if defined(STATIC_LINKED)
00089 # define SWIGEXPORT
00090 # else
00091 # define SWIGEXPORT __declspec(dllexport)
00092 # endif
00093 # else
00094 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
00095 # define SWIGEXPORT __attribute__ ((visibility("default")))
00096 # else
00097 # define SWIGEXPORT
00098 # endif
00099 # endif
00100 #endif
00101
00102
00103 #ifndef SWIGSTDCALL
00104 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
00105 # define SWIGSTDCALL __stdcall
00106 # else
00107 # define SWIGSTDCALL
00108 # endif
00109 #endif
00110
00111
00112 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_CRT_SECURE_NO_DEPRECATE)
00113 # define _CRT_SECURE_NO_DEPRECATE
00114 #endif
00115
00116
00117 #if !defined(SWIG_NO_SCL_SECURE_NO_DEPRECATE) && defined(_MSC_VER) && !defined(_SCL_SECURE_NO_DEPRECATE)
00118 # define _SCL_SECURE_NO_DEPRECATE
00119 #endif
00120
00121
00122
00123
00124
00125
00126
00127
00128
00129
00130
00131 #define SWIG_RUNTIME_VERSION "4"
00132
00133
00134 #ifdef SWIG_TYPE_TABLE
00135 # define SWIG_QUOTE_STRING(x) #x
00136 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
00137 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
00138 #else
00139 # define SWIG_TYPE_TABLE_NAME
00140 #endif
00141
00142
00143
00144
00145
00146
00147
00148
00149
00150
00151 #ifndef SWIGRUNTIME
00152 # define SWIGRUNTIME SWIGINTERN
00153 #endif
00154
00155 #ifndef SWIGRUNTIMEINLINE
00156 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
00157 #endif
00158
00159
00160 #ifndef SWIG_BUFFER_SIZE
00161 # define SWIG_BUFFER_SIZE 1024
00162 #endif
00163
00164
00165 #define SWIG_POINTER_DISOWN 0x1
00166 #define SWIG_CAST_NEW_MEMORY 0x2
00167
00168
00169 #define SWIG_POINTER_OWN 0x1
00170
00171
00172
00173
00174
00175
00176
00177
00178
00179
00180
00181
00182
00183
00184
00185
00186
00187
00188
00189
00190
00191
00192
00193
00194
00195
00196
00197
00198
00199
00200
00201
00202
00203
00204
00205
00206
00207
00208
00209
00210
00211
00212
00213
00214
00215
00216
00217
00218
00219
00220
00221
00222
00223
00224
00225
00226
00227
00228
00229
00230
00231
00232
00233
00234
00235
00236
00237
00238
00239
00240
00241
00242
00243
00244
00245
00246
00247
00248
00249
00250
00251
00252 #define SWIG_OK (0)
00253 #define SWIG_ERROR (-1)
00254 #define SWIG_IsOK(r) (r >= 0)
00255 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
00256
00257
00258 #define SWIG_CASTRANKLIMIT (1 << 8)
00259
00260 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
00261
00262 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
00263
00264 #define SWIG_BADOBJ (SWIG_ERROR)
00265 #define SWIG_OLDOBJ (SWIG_OK)
00266 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
00267 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
00268
00269 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
00270 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
00271 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
00272 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
00273 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
00274 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
00275
00276
00277
00278 #if defined(SWIG_CASTRANK_MODE)
00279 # ifndef SWIG_TypeRank
00280 # define SWIG_TypeRank unsigned long
00281 # endif
00282 # ifndef SWIG_MAXCASTRANK
00283 # define SWIG_MAXCASTRANK (2)
00284 # endif
00285 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
00286 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
00287 SWIGINTERNINLINE int SWIG_AddCast(int r) {
00288 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
00289 }
00290 SWIGINTERNINLINE int SWIG_CheckState(int r) {
00291 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
00292 }
00293 #else
00294 # define SWIG_AddCast
00295 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
00296 #endif
00297
00298
00299
00300
00301 #include <string.h>
00302
00303 #ifdef __cplusplus
00304 extern "C" {
00305 #endif
00306
00307 typedef void *(*swig_converter_func)(void *, int *);
00308 typedef struct swig_type_info *(*swig_dycast_func)(void **);
00309
00310
00311 typedef struct swig_type_info {
00312 const char *name;
00313 const char *str;
00314 swig_dycast_func dcast;
00315 struct swig_cast_info *cast;
00316 void *clientdata;
00317 int owndata;
00318 } swig_type_info;
00319
00320
00321 typedef struct swig_cast_info {
00322 swig_type_info *type;
00323 swig_converter_func converter;
00324 struct swig_cast_info *next;
00325 struct swig_cast_info *prev;
00326 } swig_cast_info;
00327
00328
00329
00330
00331 typedef struct swig_module_info {
00332 swig_type_info **types;
00333 size_t size;
00334 struct swig_module_info *next;
00335 swig_type_info **type_initial;
00336 swig_cast_info **cast_initial;
00337 void *clientdata;
00338 } swig_module_info;
00339
00340
00341
00342
00343
00344
00345
00346
00347 SWIGRUNTIME int
00348 SWIG_TypeNameComp(const char *f1, const char *l1,
00349 const char *f2, const char *l2) {
00350 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
00351 while ((*f1 == ' ') && (f1 != l1)) ++f1;
00352 while ((*f2 == ' ') && (f2 != l2)) ++f2;
00353 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
00354 }
00355 return (int)((l1 - f1) - (l2 - f2));
00356 }
00357
00358
00359
00360
00361
00362 SWIGRUNTIME int
00363 SWIG_TypeEquiv(const char *nb, const char *tb) {
00364 int equiv = 0;
00365 const char* te = tb + strlen(tb);
00366 const char* ne = nb;
00367 while (!equiv && *ne) {
00368 for (nb = ne; *ne; ++ne) {
00369 if (*ne == '|') break;
00370 }
00371 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
00372 if (*ne) ++ne;
00373 }
00374 return equiv;
00375 }
00376
00377
00378
00379
00380
00381 SWIGRUNTIME int
00382 SWIG_TypeCompare(const char *nb, const char *tb) {
00383 int equiv = 0;
00384 const char* te = tb + strlen(tb);
00385 const char* ne = nb;
00386 while (!equiv && *ne) {
00387 for (nb = ne; *ne; ++ne) {
00388 if (*ne == '|') break;
00389 }
00390 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
00391 if (*ne) ++ne;
00392 }
00393 return equiv;
00394 }
00395
00396
00397
00398 #define SWIG_TypeCheck_Template(comparison, ty) \
00399 if (ty) { \
00400 swig_cast_info *iter = ty->cast; \
00401 while (iter) { \
00402 if (comparison) { \
00403 if (iter == ty->cast) return iter; \
00404 \
00405 iter->prev->next = iter->next; \
00406 if (iter->next) \
00407 iter->next->prev = iter->prev; \
00408 iter->next = ty->cast; \
00409 iter->prev = 0; \
00410 if (ty->cast) ty->cast->prev = iter; \
00411 ty->cast = iter; \
00412 return iter; \
00413 } \
00414 iter = iter->next; \
00415 } \
00416 } \
00417 return 0
00418
00419
00420
00421
00422 SWIGRUNTIME swig_cast_info *
00423 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
00424 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
00425 }
00426
00427
00428 SWIGRUNTIME swig_cast_info *
00429 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
00430 SWIG_TypeCheck_Template(iter->type == from, into);
00431 }
00432
00433
00434
00435
00436 SWIGRUNTIMEINLINE void *
00437 SWIG_TypeCast(swig_cast_info *ty, void *ptr, int *newmemory) {
00438 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr, newmemory);
00439 }
00440
00441
00442
00443
00444 SWIGRUNTIME swig_type_info *
00445 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
00446 swig_type_info *lastty = ty;
00447 if (!ty || !ty->dcast) return ty;
00448 while (ty && (ty->dcast)) {
00449 ty = (*ty->dcast)(ptr);
00450 if (ty) lastty = ty;
00451 }
00452 return lastty;
00453 }
00454
00455
00456
00457
00458 SWIGRUNTIMEINLINE const char *
00459 SWIG_TypeName(const swig_type_info *ty) {
00460 return ty->name;
00461 }
00462
00463
00464
00465
00466
00467 SWIGRUNTIME const char *
00468 SWIG_TypePrettyName(const swig_type_info *type) {
00469
00470
00471
00472
00473 if (!type) return NULL;
00474 if (type->str != NULL) {
00475 const char *last_name = type->str;
00476 const char *s;
00477 for (s = type->str; *s; s++)
00478 if (*s == '|') last_name = s+1;
00479 return last_name;
00480 }
00481 else
00482 return type->name;
00483 }
00484
00485
00486
00487
00488 SWIGRUNTIME void
00489 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
00490 swig_cast_info *cast = ti->cast;
00491
00492 ti->clientdata = clientdata;
00493
00494 while (cast) {
00495 if (!cast->converter) {
00496 swig_type_info *tc = cast->type;
00497 if (!tc->clientdata) {
00498 SWIG_TypeClientData(tc, clientdata);
00499 }
00500 }
00501 cast = cast->next;
00502 }
00503 }
00504 SWIGRUNTIME void
00505 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
00506 SWIG_TypeClientData(ti, clientdata);
00507 ti->owndata = 1;
00508 }
00509
00510
00511
00512
00513
00514
00515
00516
00517
00518 SWIGRUNTIME swig_type_info *
00519 SWIG_MangledTypeQueryModule(swig_module_info *start,
00520 swig_module_info *end,
00521 const char *name) {
00522 swig_module_info *iter = start;
00523 do {
00524 if (iter->size) {
00525 register size_t l = 0;
00526 register size_t r = iter->size - 1;
00527 do {
00528
00529 register size_t i = (l + r) >> 1;
00530 const char *iname = iter->types[i]->name;
00531 if (iname) {
00532 register int compare = strcmp(name, iname);
00533 if (compare == 0) {
00534 return iter->types[i];
00535 } else if (compare < 0) {
00536 if (i) {
00537 r = i - 1;
00538 } else {
00539 break;
00540 }
00541 } else if (compare > 0) {
00542 l = i + 1;
00543 }
00544 } else {
00545 break;
00546 }
00547 } while (l <= r);
00548 }
00549 iter = iter->next;
00550 } while (iter != end);
00551 return 0;
00552 }
00553
00554
00555
00556
00557
00558
00559
00560
00561
00562
00563 SWIGRUNTIME swig_type_info *
00564 SWIG_TypeQueryModule(swig_module_info *start,
00565 swig_module_info *end,
00566 const char *name) {
00567
00568 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
00569 if (ret) {
00570 return ret;
00571 } else {
00572
00573
00574 swig_module_info *iter = start;
00575 do {
00576 register size_t i = 0;
00577 for (; i < iter->size; ++i) {
00578 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
00579 return iter->types[i];
00580 }
00581 iter = iter->next;
00582 } while (iter != end);
00583 }
00584
00585
00586 return 0;
00587 }
00588
00589
00590
00591
00592 SWIGRUNTIME char *
00593 SWIG_PackData(char *c, void *ptr, size_t sz) {
00594 static const char hex[17] = "0123456789abcdef";
00595 register const unsigned char *u = (unsigned char *) ptr;
00596 register const unsigned char *eu = u + sz;
00597 for (; u != eu; ++u) {
00598 register unsigned char uu = *u;
00599 *(c++) = hex[(uu & 0xf0) >> 4];
00600 *(c++) = hex[uu & 0xf];
00601 }
00602 return c;
00603 }
00604
00605
00606
00607
00608 SWIGRUNTIME const char *
00609 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
00610 register unsigned char *u = (unsigned char *) ptr;
00611 register const unsigned char *eu = u + sz;
00612 for (; u != eu; ++u) {
00613 register char d = *(c++);
00614 register unsigned char uu;
00615 if ((d >= '0') && (d <= '9'))
00616 uu = ((d - '0') << 4);
00617 else if ((d >= 'a') && (d <= 'f'))
00618 uu = ((d - ('a'-10)) << 4);
00619 else
00620 return (char *) 0;
00621 d = *(c++);
00622 if ((d >= '0') && (d <= '9'))
00623 uu |= (d - '0');
00624 else if ((d >= 'a') && (d <= 'f'))
00625 uu |= (d - ('a'-10));
00626 else
00627 return (char *) 0;
00628 *u = uu;
00629 }
00630 return c;
00631 }
00632
00633
00634
00635
00636 SWIGRUNTIME char *
00637 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
00638 char *r = buff;
00639 if ((2*sizeof(void *) + 2) > bsz) return 0;
00640 *(r++) = '_';
00641 r = SWIG_PackData(r,&ptr,sizeof(void *));
00642 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
00643 strcpy(r,name);
00644 return buff;
00645 }
00646
00647 SWIGRUNTIME const char *
00648 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
00649 if (*c != '_') {
00650 if (strcmp(c,"NULL") == 0) {
00651 *ptr = (void *) 0;
00652 return name;
00653 } else {
00654 return 0;
00655 }
00656 }
00657 return SWIG_UnpackData(++c,ptr,sizeof(void *));
00658 }
00659
00660 SWIGRUNTIME char *
00661 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
00662 char *r = buff;
00663 size_t lname = (name ? strlen(name) : 0);
00664 if ((2*sz + 2 + lname) > bsz) return 0;
00665 *(r++) = '_';
00666 r = SWIG_PackData(r,ptr,sz);
00667 if (lname) {
00668 strncpy(r,name,lname+1);
00669 } else {
00670 *r = 0;
00671 }
00672 return buff;
00673 }
00674
00675 SWIGRUNTIME const char *
00676 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
00677 if (*c != '_') {
00678 if (strcmp(c,"NULL") == 0) {
00679 memset(ptr,0,sz);
00680 return name;
00681 } else {
00682 return 0;
00683 }
00684 }
00685 return SWIG_UnpackData(++c,ptr,sz);
00686 }
00687
00688 #ifdef __cplusplus
00689 }
00690 #endif
00691
00692
00693 #define SWIG_UnknownError -1
00694 #define SWIG_IOError -2
00695 #define SWIG_RuntimeError -3
00696 #define SWIG_IndexError -4
00697 #define SWIG_TypeError -5
00698 #define SWIG_DivisionByZero -6
00699 #define SWIG_OverflowError -7
00700 #define SWIG_SyntaxError -8
00701 #define SWIG_ValueError -9
00702 #define SWIG_SystemError -10
00703 #define SWIG_AttributeError -11
00704 #define SWIG_MemoryError -12
00705 #define SWIG_NullReferenceError -13
00706
00707
00708
00709 #ifdef __cplusplus
00710
00711 #include <math.h>
00712 #include <stdlib.h>
00713 extern "C" {
00714 #endif
00715 #include "EXTERN.h"
00716 #include "perl.h"
00717 #include "XSUB.h"
00718
00719
00720
00721
00722 #ifndef PERL_REVISION
00723 # if !defined(__PATCHLEVEL_H_INCLUDED__) && !(defined(PATCHLEVEL) && defined(SUBVERSION))
00724 # define PERL_PATCHLEVEL_H_IMPLICIT
00725 # include <patchlevel.h>
00726 # endif
00727 # if !(defined(PERL_VERSION) || (defined(SUBVERSION) && defined(PATCHLEVEL)))
00728 # include <could_not_find_Perl_patchlevel.h>
00729 # endif
00730 # ifndef PERL_REVISION
00731 # define PERL_REVISION (5)
00732 # define PERL_VERSION PATCHLEVEL
00733 # define PERL_SUBVERSION SUBVERSION
00734 # endif
00735 #endif
00736
00737 #if defined(WIN32) && defined(PERL_OBJECT) && !defined(PerlIO_exportFILE)
00738 #define PerlIO_exportFILE(fh,fl) (FILE*)(fh)
00739 #endif
00740
00741 #ifndef SvIOK_UV
00742 # define SvIOK_UV(sv) (SvIOK(sv) && (SvUVX(sv) == SvIVX(sv)))
00743 #endif
00744
00745 #ifndef SvUOK
00746 # define SvUOK(sv) SvIOK_UV(sv)
00747 #endif
00748
00749 #if ((PERL_VERSION < 4) || ((PERL_VERSION == 4) && (PERL_SUBVERSION <= 5)))
00750 # define PL_sv_undef sv_undef
00751 # define PL_na na
00752 # define PL_errgv errgv
00753 # define PL_sv_no sv_no
00754 # define PL_sv_yes sv_yes
00755 # define PL_markstack_ptr markstack_ptr
00756 #endif
00757
00758 #ifndef IVSIZE
00759 # ifdef LONGSIZE
00760 # define IVSIZE LONGSIZE
00761 # else
00762 # define IVSIZE 4
00763 # endif
00764 #endif
00765
00766 #ifndef INT2PTR
00767 # if (IVSIZE == PTRSIZE) && (UVSIZE == PTRSIZE)
00768 # define PTRV UV
00769 # define INT2PTR(any,d) (any)(d)
00770 # else
00771 # if PTRSIZE == LONGSIZE
00772 # define PTRV unsigned long
00773 # else
00774 # define PTRV unsigned
00775 # endif
00776 # define INT2PTR(any,d) (any)(PTRV)(d)
00777 # endif
00778
00779 # define NUM2PTR(any,d) (any)(PTRV)(d)
00780 # define PTR2IV(p) INT2PTR(IV,p)
00781 # define PTR2UV(p) INT2PTR(UV,p)
00782 # define PTR2NV(p) NUM2PTR(NV,p)
00783
00784 # if PTRSIZE == LONGSIZE
00785 # define PTR2ul(p) (unsigned long)(p)
00786 # else
00787 # define PTR2ul(p) INT2PTR(unsigned long,p)
00788 # endif
00789 #endif
00790
00791 #ifndef SvPV_nolen
00792 # define SvPV_nolen(x) SvPV(x,PL_na)
00793 #endif
00794
00795 #ifndef get_sv
00796 # define get_sv perl_get_sv
00797 #endif
00798
00799 #ifndef ERRSV
00800 # define ERRSV get_sv("@",FALSE)
#endif
#ifndef pTHX_
#define pTHX_
#endif
#include <string.h>
#ifdef __cplusplus
}
#endif
/* -----------------------------------------------------------------------------
* error manipulation
* ----------------------------------------------------------------------------- */
SWIGINTERN const char*
SWIG_Perl_ErrorType(int code) {
const char* type = 0;
switch(code) {
case SWIG_MemoryError:
type = "MemoryError";
00801 break;
00802 case SWIG_IOError:
00803 type = "IOError";
00804 break;
00805 case SWIG_RuntimeError:
00806 type = "RuntimeError";
00807 break;
00808 case SWIG_IndexError:
00809 type = "IndexError";
00810 break;
00811 case SWIG_TypeError:
00812 type = "TypeError";
00813 break;
00814 case SWIG_DivisionByZero:
00815 type = "ZeroDivisionError";
00816 break;
00817 case SWIG_OverflowError:
00818 type = "OverflowError";
00819 break;
00820 case SWIG_SyntaxError:
00821 type = "SyntaxError";
00822 break;
00823 case SWIG_ValueError:
00824 type = "ValueError";
00825 break;
00826 case SWIG_SystemError:
00827 type = "SystemError";
00828 break;
00829 case SWIG_AttributeError:
00830 type = "AttributeError";
00831 break;
00832 default:
00833 type = "RuntimeError";
00834 }
00835 return type;
00836 }
00837
00838
00839
00840
00841
00842
00843
00844
00845
00846
00847
00848
00849 #ifdef PERL_OBJECT
00850 #define SWIG_PERL_OBJECT_DECL CPerlObj *SWIGUNUSEDPARM(pPerl),
00851 #define SWIG_PERL_OBJECT_CALL pPerl,
00852 #else
00853 #define SWIG_PERL_OBJECT_DECL
00854 #define SWIG_PERL_OBJECT_CALL
00855 #endif
00856
00857
00858
00859
00860 #define SWIG_ConvertPtr(obj, pp, type, flags) SWIG_Perl_ConvertPtr(SWIG_PERL_OBJECT_CALL obj, pp, type, flags)
00861 #define SWIG_NewPointerObj(p, type, flags) SWIG_Perl_NewPointerObj(SWIG_PERL_OBJECT_CALL p, type, flags)
00862
00863
00864 #define SWIG_ConvertPacked(obj, p, s, type) SWIG_Perl_ConvertPacked(SWIG_PERL_OBJECT_CALL obj, p, s, type)
00865 #define SWIG_NewPackedObj(p, s, type) SWIG_Perl_NewPackedObj(SWIG_PERL_OBJECT_CALL p, s, type)
00866
00867
00868 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
00869 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
00870
00871
00872 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_ConvertPtr(obj, pptr, type, 0)
00873 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_NewPointerObj(ptr, type, 0)
00874
00875
00876 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_ConvertPacked(obj, ptr, sz, ty)
00877 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_NewPackedObj(ptr, sz, type)
00878
00879
00880
00881
00882 #define SWIG_GetModule(clientdata) SWIG_Perl_GetModule()
00883 #define SWIG_SetModule(clientdata, pointer) SWIG_Perl_SetModule(pointer)
00884
00885
00886
00887
00888 #define SWIG_ErrorType(code) SWIG_Perl_ErrorType(code)
00889 #define SWIG_Error(code, msg) sv_setpvf(GvSV(PL_errgv),"%s %s\n", SWIG_ErrorType(code), msg)
00890 #define SWIG_fail goto fail
00891
00892
00893
00894 #define SWIG_MakePtr(sv, ptr, type, flags) SWIG_Perl_MakePtr(SWIG_PERL_OBJECT_CALL sv, ptr, type, flags)
00895 #define SWIG_MakePackedObj(sv, p, s, type) SWIG_Perl_MakePackedObj(SWIG_PERL_OBJECT_CALL sv, p, s, type)
00896 #define SWIG_SetError(str) SWIG_Error(SWIG_RuntimeError, str)
00897
00898
00899 #define SWIG_PERL_DECL_ARGS_1(arg1) (SWIG_PERL_OBJECT_DECL arg1)
00900 #define SWIG_PERL_CALL_ARGS_1(arg1) (SWIG_PERL_OBJECT_CALL arg1)
00901 #define SWIG_PERL_DECL_ARGS_2(arg1, arg2) (SWIG_PERL_OBJECT_DECL arg1, arg2)
00902 #define SWIG_PERL_CALL_ARGS_2(arg1, arg2) (SWIG_PERL_OBJECT_CALL arg1, arg2)
00903
00904
00905
00906
00907
00908
00909 #define SWIG_POINTER_EXCEPTION 0
00910
00911 #ifdef __cplusplus
00912 extern "C" {
00913 #endif
00914
00915 #define SWIG_OWNER SWIG_POINTER_OWN
00916 #define SWIG_SHADOW SWIG_OWNER << 1
00917
00918 #define SWIG_MAYBE_PERL_OBJECT SWIG_PERL_OBJECT_DECL
00919
00920
00921
00922
00923 #ifndef XSPROTO
00924 # define XSPROTO(name) void name(pTHX_ CV* cv)
00925 #endif
00926
00927
00928 #ifdef PERL_OBJECT
00929 # define SWIG_CALLXS(_name) _name(cv,pPerl)
00930 #else
00931 # ifndef MULTIPLICITY
00932 # define SWIG_CALLXS(_name) _name(cv)
00933 # else
00934 # define SWIG_CALLXS(_name) _name(PERL_GET_THX, cv)
00935 # endif
00936 #endif
00937
00938 #ifdef PERL_OBJECT
00939 #define MAGIC_PPERL CPerlObj *pPerl = (CPerlObj *) this;
00940
00941 #ifdef __cplusplus
00942 extern "C" {
00943 #endif
00944 typedef int (CPerlObj::*SwigMagicFunc)(SV *, MAGIC *);
00945 #ifdef __cplusplus
00946 }
00947 #endif
00948
00949 #define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
00950 #define SWIGCLASS_STATIC
00951
00952 #else
00953
00954 #define MAGIC_PPERL
00955 #define SWIGCLASS_STATIC static SWIGUNUSED
00956
00957 #ifndef MULTIPLICITY
00958 #define SWIG_MAGIC(a,b) (SV *a, MAGIC *b)
00959
00960 #ifdef __cplusplus
00961 extern "C" {
00962 #endif
00963 typedef int (*SwigMagicFunc)(SV *, MAGIC *);
00964 #ifdef __cplusplus
00965 }
00966 #endif
00967
00968 #else
00969
00970 #define SWIG_MAGIC(a,b) (struct interpreter *interp, SV *a, MAGIC *b)
00971
00972 #ifdef __cplusplus
00973 extern "C" {
00974 #endif
00975 typedef int (*SwigMagicFunc)(struct interpreter *, SV *, MAGIC *);
00976 #ifdef __cplusplus
00977 }
00978 #endif
00979
00980 #endif
00981 #endif
00982
00983
00984 #if (PERL_VERSION < 8)
00985 # ifdef PERL_OBJECT
00986 # define SWIG_croak_null() SWIG_Perl_croak_null(pPerl)
00987 static void SWIG_Perl_croak_null(CPerlObj *pPerl)
00988 # else
00989 static void SWIG_croak_null()
00990 # endif
00991 {
00992 SV *err=ERRSV;
00993 # if (PERL_VERSION < 6)
00994 croak("%_", err);
00995 # else
00996 if (SvOK(err) && !SvROK(err)) croak("%_", err);
00997 croak(Nullch);
00998 # endif
00999 }
01000 #else
01001 # define SWIG_croak_null() croak(Nullch)
01002 #endif
01003
01004
01005
01006
01007
01008
01009
01010
01011
01012
01013
01014
01015
01016
01017
01018
01019
01020 #ifndef SWIG_PERL_NO_STRICT_STR2NUM
01021 # ifndef SWIG_PERL_STRICT_STR2NUM
01022 # define SWIG_PERL_STRICT_STR2NUM
01023 # endif
01024 #endif
01025 #ifdef SWIG_PERL_STRICT_STR2NUM
01026
01027 #define SWIG_Str2NumCast(x) SWIG_AddCast(x)
01028 #else
01029
01030 #define SWIG_Str2NumCast(x) x
01031 #endif
01032
01033
01034
01035 #include <stdlib.h>
01036
01037 SWIGRUNTIME const char *
01038 SWIG_Perl_TypeProxyName(const swig_type_info *type) {
01039 if (!type) return NULL;
01040 if (type->clientdata != NULL) {
01041 return (const char*) type->clientdata;
01042 }
01043 else {
01044 return type->name;
01045 }
01046 }
01047
01048 SWIGRUNTIME swig_cast_info *
01049 SWIG_TypeProxyCheck(const char *c, swig_type_info *ty) {
01050 SWIG_TypeCheck_Template(( (!iter->type->clientdata && (strcmp(iter->type->name, c) == 0))
01051 || (iter->type->clientdata && (strcmp((char*)iter->type->clientdata, c) == 0))), ty);
01052 }
01053
01054
01055
01056
01057 SWIGRUNTIME int
01058 SWIG_Perl_ConvertPtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void **ptr, swig_type_info *_t, int flags) {
01059 swig_cast_info *tc;
01060 void *voidptr = (void *)0;
01061 SV *tsv = 0;
01062
01063 if (SvGMAGICAL(sv))
01064 mg_get(sv);
01065
01066
01067 if (sv_isobject(sv)) {
01068 IV tmp = 0;
01069 tsv = (SV*) SvRV(sv);
01070 if ((SvTYPE(tsv) == SVt_PVHV)) {
01071 MAGIC *mg;
01072 if (SvMAGICAL(tsv)) {
01073 mg = mg_find(tsv,'P');
01074 if (mg) {
01075 sv = mg->mg_obj;
01076 if (sv_isobject(sv)) {
01077 tsv = (SV*)SvRV(sv);
01078 tmp = SvIV(tsv);
01079 }
01080 }
01081 } else {
01082 return SWIG_ERROR;
01083 }
01084 } else {
01085 tmp = SvIV(tsv);
01086 }
01087 voidptr = INT2PTR(void *,tmp);
01088 } else if (! SvOK(sv)) {
01089 *(ptr) = (void *) 0;
01090 return SWIG_OK;
01091 } else if (SvTYPE(sv) == SVt_RV) {
01092 if (!SvROK(sv)) {
01093 *(ptr) = (void *) 0;
01094 return SWIG_OK;
01095 } else {
01096 return SWIG_ERROR;
01097 }
01098 } else {
01099 return SWIG_ERROR;
01100 }
01101 if (_t) {
01102
01103 char *_c = HvNAME(SvSTASH(SvRV(sv)));
01104 tc = SWIG_TypeProxyCheck(_c,_t);
01105 if (!tc) {
01106 return SWIG_ERROR;
01107 }
01108 {
01109 int newmemory = 0;
01110 *ptr = SWIG_TypeCast(tc,voidptr,&newmemory);
01111 assert(!newmemory);
01112 }
01113 } else {
01114 *ptr = voidptr;
01115 }
01116
01117
01118
01119
01120 if (tsv && (flags & SWIG_POINTER_DISOWN)) {
01121
01122
01123
01124 SV *obj = sv;
01125 HV *stash = SvSTASH(SvRV(obj));
01126 GV *gv = *(GV**) hv_fetch(stash, "OWNER", 5, TRUE);
01127 if (isGV(gv)) {
01128 HV *hv = GvHVn(gv);
01129
01130
01131
01132
01133 if (hv_exists_ent(hv, obj, 0)) {
01134 hv_delete_ent(hv, obj, 0, 0);
01135 }
01136 }
01137 }
01138 return SWIG_OK;
01139 }
01140
01141 SWIGRUNTIME void
01142 SWIG_Perl_MakePtr(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, swig_type_info *t, int flags) {
01143 if (ptr && (flags & SWIG_SHADOW)) {
01144 SV *self;
01145 SV *obj=newSV(0);
01146 HV *hash=newHV();
01147 HV *stash;
01148 sv_setref_pv(obj, (char *) SWIG_Perl_TypeProxyName(t), ptr);
01149 stash=SvSTASH(SvRV(obj));
01150 if (flags & SWIG_POINTER_OWN) {
01151 HV *hv;
01152 GV *gv=*(GV**)hv_fetch(stash, "OWNER", 5, TRUE);
01153 if (!isGV(gv))
01154 gv_init(gv, stash, "OWNER", 5, FALSE);
01155 hv=GvHVn(gv);
01156 hv_store_ent(hv, obj, newSViv(1), 0);
01157 }
01158 sv_magic((SV *)hash, (SV *)obj, 'P', Nullch, 0);
01159 SvREFCNT_dec(obj);
01160 self=newRV_noinc((SV *)hash);
01161 sv_setsv(sv, self);
01162 SvREFCNT_dec((SV *)self);
01163 sv_bless(sv, stash);
01164 }
01165 else {
01166 sv_setref_pv(sv, (char *) SWIG_Perl_TypeProxyName(t), ptr);
01167 }
01168 }
01169
01170 SWIGRUNTIMEINLINE SV *
01171 SWIG_Perl_NewPointerObj(SWIG_MAYBE_PERL_OBJECT void *ptr, swig_type_info *t, int flags) {
01172 SV *result = sv_newmortal();
01173 SWIG_MakePtr(result, ptr, t, flags);
01174 return result;
01175 }
01176
01177 SWIGRUNTIME void
01178 SWIG_Perl_MakePackedObj(SWIG_MAYBE_PERL_OBJECT SV *sv, void *ptr, int sz, swig_type_info *type) {
01179 char result[1024];
01180 char *r = result;
01181 if ((2*sz + 1 + strlen(SWIG_Perl_TypeProxyName(type))) > 1000) return;
01182 *(r++) = '_';
01183 r = SWIG_PackData(r,ptr,sz);
01184 strcpy(r,SWIG_Perl_TypeProxyName(type));
01185 sv_setpv(sv, result);
01186 }
01187
01188 SWIGRUNTIME SV *
01189 SWIG_Perl_NewPackedObj(SWIG_MAYBE_PERL_OBJECT void *ptr, int sz, swig_type_info *type) {
01190 SV *result = sv_newmortal();
01191 SWIG_Perl_MakePackedObj(result, ptr, sz, type);
01192 return result;
01193 }
01194
01195
01196 SWIGRUNTIME int
01197 SWIG_Perl_ConvertPacked(SWIG_MAYBE_PERL_OBJECT SV *obj, void *ptr, int sz, swig_type_info *ty) {
01198 swig_cast_info *tc;
01199 const char *c = 0;
01200
01201 if ((!obj) || (!SvOK(obj))) return SWIG_ERROR;
01202 c = SvPV_nolen(obj);
01203
01204 if (*c != '_') return SWIG_ERROR;
01205 c++;
01206 c = SWIG_UnpackData(c,ptr,sz);
01207 if (ty) {
01208 tc = SWIG_TypeCheck(c,ty);
01209 if (!tc) return SWIG_ERROR;
01210 }
01211 return SWIG_OK;
01212 }
01213
01214
01215
01216 #define SWIG_croak(x) { SWIG_Error(SWIG_RuntimeError, x); SWIG_fail; }
01217
01218
01219 typedef XSPROTO(SwigPerlWrapper);
01220 typedef SwigPerlWrapper *SwigPerlWrapperPtr;
01221
01222
01223 typedef struct {
01224 const char *name;
01225 SwigPerlWrapperPtr wrapper;
01226 } swig_command_info;
01227
01228
01229
01230 #define SWIG_INT 1
01231 #define SWIG_FLOAT 2
01232 #define SWIG_STRING 3
01233 #define SWIG_POINTER 4
01234 #define SWIG_BINARY 5
01235
01236
01237 typedef struct swig_constant_info {
01238 int type;
01239 const char *name;
01240 long lvalue;
01241 double dvalue;
01242 void *pvalue;
01243 swig_type_info **ptype;
01244 } swig_constant_info;
01245
01246
01247
01248 typedef struct {
01249 const char *name;
01250 SwigMagicFunc set;
01251 SwigMagicFunc get;
01252 swig_type_info **type;
01253 } swig_variable_info;
01254
01255
01256 #ifndef PERL_OBJECT
01257 #define swig_create_magic(s,a,b,c) _swig_create_magic(s,a,b,c)
01258 #ifndef MULTIPLICITY
01259 SWIGRUNTIME void _swig_create_magic(SV *sv, char *name, int (*set)(SV *, MAGIC *), int (*get)(SV *,MAGIC *))
01260 #else
01261 SWIGRUNTIME void _swig_create_magic(SV *sv, char *name, int (*set)(struct interpreter*, SV *, MAGIC *), int (*get)(struct interpreter*, SV *,MAGIC *))
01262 #endif
01263 #else
01264 # define swig_create_magic(s,a,b,c) _swig_create_magic(pPerl,s,a,b,c)
01265 SWIGRUNTIME void _swig_create_magic(CPerlObj *pPerl, SV *sv, const char *name, int (CPerlObj::*set)(SV *, MAGIC *), int (CPerlObj::*get)(SV *, MAGIC *))
01266 #endif
01267 {
01268 MAGIC *mg;
01269 sv_magic(sv,sv,'U',(char *) name,strlen(name));
01270 mg = mg_find(sv,'U');
01271 mg->mg_virtual = (MGVTBL *) malloc(sizeof(MGVTBL));
01272 mg->mg_virtual->svt_get = (SwigMagicFunc) get;
01273 mg->mg_virtual->svt_set = (SwigMagicFunc) set;
01274 mg->mg_virtual->svt_len = 0;
01275 mg->mg_virtual->svt_clear = 0;
01276 mg->mg_virtual->svt_free = 0;
01277 }
01278
01279
01280 SWIGRUNTIME swig_module_info *
01281 SWIG_Perl_GetModule(void) {
01282 static void *type_pointer = (void *)0;
01283 SV *pointer;
01284
01285
01286 if (!type_pointer) {
01287 pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, FALSE | GV_ADDMULTI);
01288 if (pointer && SvOK(pointer)) {
01289 type_pointer = INT2PTR(swig_type_info **, SvIV(pointer));
01290 }
01291 }
01292
01293 return (swig_module_info *) type_pointer;
01294 }
01295
01296 SWIGRUNTIME void
01297 SWIG_Perl_SetModule(swig_module_info *module) {
01298 SV *pointer;
01299
01300
01301 pointer = get_sv("swig_runtime_data::type_pointer" SWIG_RUNTIME_VERSION SWIG_TYPE_TABLE_NAME, TRUE | GV_ADDMULTI);
01302 sv_setiv(pointer, PTR2IV(module));
01303 }
01304
01305 #ifdef __cplusplus
01306 }
01307 #endif
01308
01309
01310
01311
01312 #ifdef do_open
01313 #undef do_open
01314 #endif
01315 #ifdef do_close
01316 #undef do_close
01317 #endif
01318 #ifdef scalar
01319 #undef scalar
01320 #endif
01321 #ifdef list
01322 #undef list
01323 #endif
01324 #ifdef apply
01325 #undef apply
01326 #endif
01327 #ifdef convert
01328 #undef convert
01329 #endif
01330 #ifdef Error
01331 #undef Error
01332 #endif
01333 #ifdef form
01334 #undef form
01335 #endif
01336 #ifdef vform
01337 #undef vform
01338 #endif
01339 #ifdef LABEL
01340 #undef LABEL
01341 #endif
01342 #ifdef METHOD
01343 #undef METHOD
01344 #endif
01345 #ifdef Move
01346 #undef Move
01347 #endif
01348 #ifdef yylex
01349 #undef yylex
01350 #endif
01351 #ifdef yyparse
01352 #undef yyparse
01353 #endif
01354 #ifdef yyerror
01355 #undef yyerror
01356 #endif
01357 #ifdef invert
01358 #undef invert
01359 #endif
01360 #ifdef ref
01361 #undef ref
01362 #endif
01363 #ifdef read
01364 #undef read
01365 #endif
01366 #ifdef write
01367 #undef write
01368 #endif
01369 #ifdef eof
01370 #undef eof
01371 #endif
01372 #ifdef bool
01373 #undef bool
01374 #endif
01375 #ifdef close
01376 #undef close
01377 #endif
01378 #ifdef rewind
01379 #undef rewind
01380 #endif
01381 #ifdef free
01382 #undef free
01383 #endif
01384 #ifdef malloc
01385 #undef malloc
01386 #endif
01387 #ifdef calloc
01388 #undef calloc
01389 #endif
01390 #ifdef Stat
01391 #undef Stat
01392 #endif
01393 #ifdef check
01394 #undef check
01395 #endif
01396 #ifdef seekdir
01397 #undef seekdir
01398 #endif
01399 #ifdef open
01400 #undef open
01401 #endif
01402
01403
01404
01405 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
01406
01407 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
01408
01409
01410
01411
01412
01413 #define SWIGTYPE_p_char swig_types[0]
01414 #define SWIGTYPE_p_long swig_types[1]
01415 #define SWIGTYPE_p_long_long swig_types[2]
01416 static swig_type_info *swig_types[4];
01417 static swig_module_info swig_module = {swig_types, 3, 0, 0, 0, 0};
01418 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
01419 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
01420
01421
01422
01423 #define SWIG_init boot_XrdClientAdmin
01424
01425 #define SWIG_name "XrdClientAdminc::boot_XrdClientAdmin"
01426 #define SWIG_prefix "XrdClientAdminc::"
01427
01428 #define SWIGVERSION 0x010336
01429 #define SWIG_VERSION SWIGVERSION
01430
01431
01432 #define SWIG_as_voidptr(a) (void *)((const void *)(a))
01433 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),(void**)(a))
01434
01435
01436 #ifdef __cplusplus
01437 extern "C"
01438 #endif
01439 #ifndef PERL_OBJECT
01440 #ifndef MULTIPLICITY
01441 SWIGEXPORT void SWIG_init (CV* cv);
01442 #else
01443 SWIGEXPORT void SWIG_init (pTHXo_ CV* cv);
01444 #endif
01445 #else
01446 SWIGEXPORT void SWIG_init (CV *cv, CPerlObj *);
01447 #endif
01448
01449
01450 #include "XrdClient/XrdClientAdmin_c.hh"
01451
01452
01453 SWIGINTERN swig_type_info*
01454 SWIG_pchar_descriptor(void)
01455 {
01456 static int init = 0;
01457 static swig_type_info* info = 0;
01458 if (!init) {
01459 info = SWIG_TypeQuery("_p_char");
01460 init = 1;
01461 }
01462 return info;
01463 }
01464
01465
01466 SWIGINTERN int
01467 SWIG_AsCharPtrAndSize(SV *obj, char** cptr, size_t* psize, int *alloc)
01468 {
01469 if (SvPOK(obj)) {
01470 STRLEN len = 0;
01471 char *cstr = SvPV(obj, len);
01472 size_t size = len + 1;
01473 if (cptr) {
01474 if (alloc) {
01475 if (*alloc == SWIG_NEWOBJ) {
01476 *cptr = (char *)memcpy((char *)malloc((size)*sizeof(char)), cstr, sizeof(char)*(size));
01477 } else {
01478 *cptr = cstr;
01479 *alloc = SWIG_OLDOBJ;
01480 }
01481 }
01482 }
01483 if (psize) *psize = size;
01484 return SWIG_OK;
01485 } else {
01486 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
01487 if (pchar_descriptor) {
01488 char* vptr = 0;
01489 if (SWIG_ConvertPtr(obj, (void**)&vptr, pchar_descriptor, 0) == SWIG_OK) {
01490 if (cptr) *cptr = vptr;
01491 if (psize) *psize = vptr ? (strlen(vptr) + 1) : 0;
01492 if (alloc) *alloc = SWIG_OLDOBJ;
01493 return SWIG_OK;
01494 }
01495 }
01496 }
01497 return SWIG_TypeError;
01498 }
01499
01500
01501
01502
01503
01504 SWIGINTERNINLINE SV *
01505 SWIG_From_bool SWIG_PERL_DECL_ARGS_1(bool value)
01506 {
01507 SV *obj = sv_newmortal();
01508 if (value) {
01509 sv_setsv(obj, &PL_sv_yes);
01510 } else {
01511 sv_setsv(obj, &PL_sv_no);
01512 }
01513 return obj;
01514 }
01515
01516
01517 SWIGINTERNINLINE SV *
01518 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
01519 {
01520 SV *obj = sv_newmortal();
01521 if (carray) {
01522 sv_setpvn(obj, carray, size);
01523 } else {
01524 sv_setsv(obj, &PL_sv_undef);
01525 }
01526 return obj;
01527 }
01528
01529
01530 SWIGINTERNINLINE SV *
01531 SWIG_FromCharPtr(const char *cptr)
01532 {
01533 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
01534 }
01535
01536
01537 #include <limits.h>
01538 #if !defined(SWIG_NO_LLONG_MAX)
01539 # if !defined(LLONG_MAX) && defined(__GNUC__) && defined (__LONG_LONG_MAX__)
01540 # define LLONG_MAX __LONG_LONG_MAX__
01541 # define LLONG_MIN (-LLONG_MAX - 1LL)
01542 # define ULLONG_MAX (LLONG_MAX * 2ULL + 1ULL)
01543 # endif
01544 #endif
01545
01546
01547 SWIGINTERN int
01548 SWIG_AsVal_double SWIG_PERL_DECL_ARGS_2(SV *obj, double *val)
01549 {
01550 if (SvNIOK(obj)) {
01551 if (val) *val = SvNV(obj);
01552 return SWIG_OK;
01553 } else if (SvIOK(obj)) {
01554 if (val) *val = (double) SvIV(obj);
01555 return SWIG_AddCast(SWIG_OK);
01556 } else {
01557 const char *nptr = SvPV_nolen(obj);
01558 if (nptr) {
01559 char *endptr;
01560 double v = strtod(nptr, &endptr);
01561 if (errno == ERANGE) {
01562 errno = 0;
01563 return SWIG_OverflowError;
01564 } else {
01565 if (*endptr == '\0') {
01566 if (val) *val = v;
01567 return SWIG_Str2NumCast(SWIG_OK);
01568 }
01569 }
01570 }
01571 }
01572 return SWIG_TypeError;
01573 }
01574
01575
01576 #include <float.h>
01577
01578
01579 #include <math.h>
01580
01581
01582 SWIGINTERNINLINE int
01583 SWIG_CanCastAsInteger(double *d, double min, double max) {
01584 double x = *d;
01585 if ((min <= x && x <= max)) {
01586 double fx = floor(x);
01587 double cx = ceil(x);
01588 double rd = ((x - fx) < 0.5) ? fx : cx;
01589 if ((errno == EDOM) || (errno == ERANGE)) {
01590 errno = 0;
01591 } else {
01592 double summ, reps, diff;
01593 if (rd < x) {
01594 diff = x - rd;
01595 } else if (rd > x) {
01596 diff = rd - x;
01597 } else {
01598 return 1;
01599 }
01600 summ = rd + x;
01601 reps = diff/summ;
01602 if (reps < 8*DBL_EPSILON) {
01603 *d = rd;
01604 return 1;
01605 }
01606 }
01607 }
01608 return 0;
01609 }
01610
01611
01612 SWIGINTERN int
01613 SWIG_AsVal_long SWIG_PERL_DECL_ARGS_2(SV *obj, long* val)
01614 {
01615 if (SvIOK(obj)) {
01616 if (val) *val = SvIV(obj);
01617 return SWIG_OK;
01618 } else {
01619 int dispatch = 0;
01620 const char *nptr = SvPV_nolen(obj);
01621 if (nptr) {
01622 char *endptr;
01623 long v;
01624 errno = 0;
01625 v = strtol(nptr, &endptr,0);
01626 if (errno == ERANGE) {
01627 errno = 0;
01628 return SWIG_OverflowError;
01629 } else {
01630 if (*endptr == '\0') {
01631 if (val) *val = v;
01632 return SWIG_Str2NumCast(SWIG_OK);
01633 }
01634 }
01635 }
01636 if (!dispatch) {
01637 double d;
01638 int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
01639 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, LONG_MIN, LONG_MAX)) {
01640 if (val) *val = (long)(d);
01641 return res;
01642 }
01643 }
01644 }
01645 return SWIG_TypeError;
01646 }
01647
01648
01649 SWIGINTERN int
01650 SWIG_AsVal_int SWIG_PERL_DECL_ARGS_2(SV * obj, int *val)
01651 {
01652 long v;
01653 int res = SWIG_AsVal_long SWIG_PERL_CALL_ARGS_2(obj, &v);
01654 if (SWIG_IsOK(res)) {
01655 if ((v < INT_MIN || v > INT_MAX)) {
01656 return SWIG_OverflowError;
01657 } else {
01658 if (val) *val = (int)(v);
01659 }
01660 }
01661 return res;
01662 }
01663
01664
01665 SWIGINTERN int
01666 SWIG_AsVal_unsigned_SS_long SWIG_PERL_DECL_ARGS_2(SV *obj, unsigned long *val)
01667 {
01668 if (SvUOK(obj)) {
01669 if (val) *val = SvUV(obj);
01670 return SWIG_OK;
01671 } else if (SvIOK(obj)) {
01672 long v = SvIV(obj);
01673 if (v >= 0) {
01674 if (val) *val = v;
01675 return SWIG_OK;
01676 } else {
01677 return SWIG_OverflowError;
01678 }
01679 } else {
01680 int dispatch = 0;
01681 const char *nptr = SvPV_nolen(obj);
01682 if (nptr) {
01683 char *endptr;
01684 unsigned long v;
01685 errno = 0;
01686 v = strtoul(nptr, &endptr,0);
01687 if (errno == ERANGE) {
01688 errno = 0;
01689 return SWIG_OverflowError;
01690 } else {
01691 if (*endptr == '\0') {
01692 if (val) *val = v;
01693 return SWIG_Str2NumCast(SWIG_OK);
01694 }
01695 }
01696 }
01697 if (!dispatch) {
01698 double d;
01699 int res = SWIG_AddCast(SWIG_AsVal_double SWIG_PERL_CALL_ARGS_2(obj,&d));
01700 if (SWIG_IsOK(res) && SWIG_CanCastAsInteger(&d, 0, ULONG_MAX)) {
01701 if (val) *val = (unsigned long)(d);
01702 return res;
01703 }
01704 }
01705 }
01706 return SWIG_TypeError;
01707 }
01708
01709
01710 SWIGINTERN int
01711 SWIG_AsVal_unsigned_SS_char SWIG_PERL_DECL_ARGS_2(SV * obj, unsigned char *val)
01712 {
01713 unsigned long v;
01714 int res = SWIG_AsVal_unsigned_SS_long SWIG_PERL_CALL_ARGS_2(obj, &v);
01715 if (SWIG_IsOK(res)) {
01716 if ((v > UCHAR_MAX)) {
01717 return SWIG_OverflowError;
01718 } else {
01719 if (val) *val = (unsigned char)(v);
01720 }
01721 }
01722 return res;
01723 }
01724
01725
01726 SWIGINTERNINLINE SV *
01727 SWIG_From_long SWIG_PERL_DECL_ARGS_1(long value)
01728 {
01729 SV *obj = sv_newmortal();
01730 sv_setiv(obj, (IV) value);
01731 return obj;
01732 }
01733
01734
01735 #include <stdio.h>
01736 #if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
01737 # ifndef snprintf
01738 # define snprintf _snprintf
01739 # endif
01740 #endif
01741
01742
01743 SWIGINTERNINLINE SV *
01744 SWIG_From_long_SS_long SWIG_PERL_DECL_ARGS_1(long long value)
01745 {
01746 if (((long long) LONG_MIN <= value) && (value <= (long long) LONG_MAX)) {
01747 return SWIG_From_long SWIG_PERL_CALL_ARGS_1((long)(value));
01748 } else {
01749 char temp[256];
01750 SV *obj = sv_newmortal();
01751 sprintf(temp, "%lld", value);
01752 sv_setpv(obj, temp);
01753 return obj;
01754 }
01755 }
01756
01757 #ifdef __cplusplus
01758 extern "C" {
01759 #endif
01760
01761 #ifdef PERL_OBJECT
01762 #define MAGIC_CLASS _wrap_XrdClientAdmin_var::
01763 class _wrap_XrdClientAdmin_var : public CPerlObj {
01764 public:
01765 #else
01766 #define MAGIC_CLASS
01767 #endif
01768 SWIGCLASS_STATIC int swig_magic_readonly(pTHX_ SV *SWIGUNUSEDPARM(sv), MAGIC *SWIGUNUSEDPARM(mg)) {
01769 MAGIC_PPERL
01770 croak("Value is read-only.");
01771 return 0;
01772 }
01773
01774
01775 #ifdef PERL_OBJECT
01776 };
01777 #endif
01778
01779 #ifdef __cplusplus
01780 }
01781 #endif
01782
01783 #ifdef __cplusplus
01784 extern "C" {
01785 #endif
01786 XS(_wrap_XrdInitialize) {
01787 {
01788 char *arg1 = (char *) 0 ;
01789 char *arg2 = (char *) 0 ;
01790 int res1 ;
01791 char *buf1 = 0 ;
01792 int alloc1 = 0 ;
01793 int res2 ;
01794 char *buf2 = 0 ;
01795 int alloc2 = 0 ;
01796 int argvi = 0;
01797 bool result;
01798 dXSARGS;
01799
01800 if ((items < 2) || (items > 2)) {
01801 SWIG_croak("Usage: XrdInitialize(url,EnvValues);");
01802 }
01803 res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
01804 if (!SWIG_IsOK(res1)) {
01805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XrdInitialize" "', argument " "1"" of type '" "char const *""'");
01806 }
01807 arg1 = (char *)(buf1);
01808 res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
01809 if (!SWIG_IsOK(res2)) {
01810 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XrdInitialize" "', argument " "2"" of type '" "char const *""'");
01811 }
01812 arg2 = (char *)(buf2);
01813 result = (bool)XrdInitialize((char const *)arg1,(char const *)arg2);
01814 ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1((bool)(result)); argvi++ ;
01815 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
01816 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
01817 XSRETURN(argvi);
01818 fail:
01819 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
01820 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
01821 SWIG_croak_null();
01822 }
01823 }
01824
01825
01826 XS(_wrap_XrdTerminate) {
01827 {
01828 int argvi = 0;
01829 bool result;
01830 dXSARGS;
01831
01832 if ((items < 0) || (items > 0)) {
01833 SWIG_croak("Usage: XrdTerminate();");
01834 }
01835 result = (bool)XrdTerminate();
01836 ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1((bool)(result)); argvi++ ;
01837 XSRETURN(argvi);
01838 fail:
01839 SWIG_croak_null();
01840 }
01841 }
01842
01843
01844 XS(_wrap_XrdSysStatX) {
01845 {
01846 char *arg1 = (char *) 0 ;
01847 int res1 ;
01848 char *buf1 = 0 ;
01849 int alloc1 = 0 ;
01850 int argvi = 0;
01851 char *result = 0 ;
01852 dXSARGS;
01853
01854 if ((items < 1) || (items > 1)) {
01855 SWIG_croak("Usage: XrdSysStatX(paths_list);");
01856 }
01857 res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
01858 if (!SWIG_IsOK(res1)) {
01859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XrdSysStatX" "', argument " "1"" of type '" "char const *""'");
01860 }
01861 arg1 = (char *)(buf1);
01862 result = (char *)XrdSysStatX((char const *)arg1);
01863 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
01864 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
01865 XSRETURN(argvi);
01866 fail:
01867 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
01868 SWIG_croak_null();
01869 }
01870 }
01871
01872
01873 XS(_wrap_XrdExistFiles) {
01874 {
01875 char *arg1 = (char *) 0 ;
01876 int res1 ;
01877 char *buf1 = 0 ;
01878 int alloc1 = 0 ;
01879 int argvi = 0;
01880 char *result = 0 ;
01881 dXSARGS;
01882
01883 if ((items < 1) || (items > 1)) {
01884 SWIG_croak("Usage: XrdExistFiles(filepaths);");
01885 }
01886 res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
01887 if (!SWIG_IsOK(res1)) {
01888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XrdExistFiles" "', argument " "1"" of type '" "char const *""'");
01889 }
01890 arg1 = (char *)(buf1);
01891 result = (char *)XrdExistFiles((char const *)arg1);
01892 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
01893 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
01894 XSRETURN(argvi);
01895 fail:
01896 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
01897 SWIG_croak_null();
01898 }
01899 }
01900
01901
01902 XS(_wrap_XrdExistDirs) {
01903 {
01904 char *arg1 = (char *) 0 ;
01905 int res1 ;
01906 char *buf1 = 0 ;
01907 int alloc1 = 0 ;
01908 int argvi = 0;
01909 char *result = 0 ;
01910 dXSARGS;
01911
01912 if ((items < 1) || (items > 1)) {
01913 SWIG_croak("Usage: XrdExistDirs(filepaths);");
01914 }
01915 res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
01916 if (!SWIG_IsOK(res1)) {
01917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XrdExistDirs" "', argument " "1"" of type '" "char const *""'");
01918 }
01919 arg1 = (char *)(buf1);
01920 result = (char *)XrdExistDirs((char const *)arg1);
01921 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
01922 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
01923 XSRETURN(argvi);
01924 fail:
01925 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
01926 SWIG_croak_null();
01927 }
01928 }
01929
01930
01931 XS(_wrap_XrdIsFileOnline) {
01932 {
01933 char *arg1 = (char *) 0 ;
01934 int res1 ;
01935 char *buf1 = 0 ;
01936 int alloc1 = 0 ;
01937 int argvi = 0;
01938 char *result = 0 ;
01939 dXSARGS;
01940
01941 if ((items < 1) || (items > 1)) {
01942 SWIG_croak("Usage: XrdIsFileOnline(filepaths);");
01943 }
01944 res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
01945 if (!SWIG_IsOK(res1)) {
01946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XrdIsFileOnline" "', argument " "1"" of type '" "char const *""'");
01947 }
01948 arg1 = (char *)(buf1);
01949 result = (char *)XrdIsFileOnline((char const *)arg1);
01950 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
01951 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
01952 XSRETURN(argvi);
01953 fail:
01954 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
01955 SWIG_croak_null();
01956 }
01957 }
01958
01959
01960 XS(_wrap_XrdMv) {
01961 {
01962 char *arg1 = (char *) 0 ;
01963 char *arg2 = (char *) 0 ;
01964 int res1 ;
01965 char *buf1 = 0 ;
01966 int alloc1 = 0 ;
01967 int res2 ;
01968 char *buf2 = 0 ;
01969 int alloc2 = 0 ;
01970 int argvi = 0;
01971 bool result;
01972 dXSARGS;
01973
01974 if ((items < 2) || (items > 2)) {
01975 SWIG_croak("Usage: XrdMv(fileSrc,fileDest);");
01976 }
01977 res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
01978 if (!SWIG_IsOK(res1)) {
01979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XrdMv" "', argument " "1"" of type '" "char const *""'");
01980 }
01981 arg1 = (char *)(buf1);
01982 res2 = SWIG_AsCharPtrAndSize(ST(1), &buf2, NULL, &alloc2);
01983 if (!SWIG_IsOK(res2)) {
01984 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "XrdMv" "', argument " "2"" of type '" "char const *""'");
01985 }
01986 arg2 = (char *)(buf2);
01987 result = (bool)XrdMv((char const *)arg1,(char const *)arg2);
01988 ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1((bool)(result)); argvi++ ;
01989 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
01990 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
01991 XSRETURN(argvi);
01992 fail:
01993 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
01994 if (alloc2 == SWIG_NEWOBJ) free((char*)buf2);
01995 SWIG_croak_null();
01996 }
01997 }
01998
01999
02000 XS(_wrap_XrdMkdir) {
02001 {
02002 char *arg1 = (char *) 0 ;
02003 int arg2 ;
02004 int arg3 ;
02005 int arg4 ;
02006 int res1 ;
02007 char *buf1 = 0 ;
02008 int alloc1 = 0 ;
02009 int val2 ;
02010 int ecode2 = 0 ;
02011 int val3 ;
02012 int ecode3 = 0 ;
02013 int val4 ;
02014 int ecode4 = 0 ;
02015 int argvi = 0;
02016 bool result;
02017 dXSARGS;
02018
02019 if ((items < 4) || (items > 4)) {
02020 SWIG_croak("Usage: XrdMkdir(dir,user,group,other);");
02021 }
02022 res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
02023 if (!SWIG_IsOK(res1)) {
02024 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XrdMkdir" "', argument " "1"" of type '" "char const *""'");
02025 }
02026 arg1 = (char *)(buf1);
02027 ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
02028 if (!SWIG_IsOK(ecode2)) {
02029 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XrdMkdir" "', argument " "2"" of type '" "int""'");
02030 }
02031 arg2 = (int)(val2);
02032 ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
02033 if (!SWIG_IsOK(ecode3)) {
02034 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XrdMkdir" "', argument " "3"" of type '" "int""'");
02035 }
02036 arg3 = (int)(val3);
02037 ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
02038 if (!SWIG_IsOK(ecode4)) {
02039 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XrdMkdir" "', argument " "4"" of type '" "int""'");
02040 }
02041 arg4 = (int)(val4);
02042 result = (bool)XrdMkdir((char const *)arg1,arg2,arg3,arg4);
02043 ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1((bool)(result)); argvi++ ;
02044 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
02045
02046
02047
02048 XSRETURN(argvi);
02049 fail:
02050 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
02051
02052
02053
02054 SWIG_croak_null();
02055 }
02056 }
02057
02058
02059 XS(_wrap_XrdChmod) {
02060 {
02061 char *arg1 = (char *) 0 ;
02062 int arg2 ;
02063 int arg3 ;
02064 int arg4 ;
02065 int res1 ;
02066 char *buf1 = 0 ;
02067 int alloc1 = 0 ;
02068 int val2 ;
02069 int ecode2 = 0 ;
02070 int val3 ;
02071 int ecode3 = 0 ;
02072 int val4 ;
02073 int ecode4 = 0 ;
02074 int argvi = 0;
02075 bool result;
02076 dXSARGS;
02077
02078 if ((items < 4) || (items > 4)) {
02079 SWIG_croak("Usage: XrdChmod(file,user,group,other);");
02080 }
02081 res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
02082 if (!SWIG_IsOK(res1)) {
02083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XrdChmod" "', argument " "1"" of type '" "char const *""'");
02084 }
02085 arg1 = (char *)(buf1);
02086 ecode2 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
02087 if (!SWIG_IsOK(ecode2)) {
02088 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XrdChmod" "', argument " "2"" of type '" "int""'");
02089 }
02090 arg2 = (int)(val2);
02091 ecode3 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
02092 if (!SWIG_IsOK(ecode3)) {
02093 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XrdChmod" "', argument " "3"" of type '" "int""'");
02094 }
02095 arg3 = (int)(val3);
02096 ecode4 = SWIG_AsVal_int SWIG_PERL_CALL_ARGS_2(ST(3), &val4);
02097 if (!SWIG_IsOK(ecode4)) {
02098 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "XrdChmod" "', argument " "4"" of type '" "int""'");
02099 }
02100 arg4 = (int)(val4);
02101 result = (bool)XrdChmod((char const *)arg1,arg2,arg3,arg4);
02102 ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1((bool)(result)); argvi++ ;
02103 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
02104
02105
02106
02107 XSRETURN(argvi);
02108 fail:
02109 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
02110
02111
02112
02113 SWIG_croak_null();
02114 }
02115 }
02116
02117
02118 XS(_wrap_XrdRm) {
02119 {
02120 char *arg1 = (char *) 0 ;
02121 int res1 ;
02122 char *buf1 = 0 ;
02123 int alloc1 = 0 ;
02124 int argvi = 0;
02125 bool result;
02126 dXSARGS;
02127
02128 if ((items < 1) || (items > 1)) {
02129 SWIG_croak("Usage: XrdRm(file);");
02130 }
02131 res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
02132 if (!SWIG_IsOK(res1)) {
02133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XrdRm" "', argument " "1"" of type '" "char const *""'");
02134 }
02135 arg1 = (char *)(buf1);
02136 result = (bool)XrdRm((char const *)arg1);
02137 ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1((bool)(result)); argvi++ ;
02138 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
02139 XSRETURN(argvi);
02140 fail:
02141 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
02142 SWIG_croak_null();
02143 }
02144 }
02145
02146
02147 XS(_wrap_XrdRmdir) {
02148 {
02149 char *arg1 = (char *) 0 ;
02150 int res1 ;
02151 char *buf1 = 0 ;
02152 int alloc1 = 0 ;
02153 int argvi = 0;
02154 bool result;
02155 dXSARGS;
02156
02157 if ((items < 1) || (items > 1)) {
02158 SWIG_croak("Usage: XrdRmdir(path);");
02159 }
02160 res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
02161 if (!SWIG_IsOK(res1)) {
02162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XrdRmdir" "', argument " "1"" of type '" "char const *""'");
02163 }
02164 arg1 = (char *)(buf1);
02165 result = (bool)XrdRmdir((char const *)arg1);
02166 ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1((bool)(result)); argvi++ ;
02167 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
02168 XSRETURN(argvi);
02169 fail:
02170 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
02171 SWIG_croak_null();
02172 }
02173 }
02174
02175
02176 XS(_wrap_XrdPrepare) {
02177 {
02178 char *arg1 = (char *) 0 ;
02179 unsigned char arg2 ;
02180 unsigned char arg3 ;
02181 int res1 ;
02182 char *buf1 = 0 ;
02183 int alloc1 = 0 ;
02184 unsigned char val2 ;
02185 int ecode2 = 0 ;
02186 unsigned char val3 ;
02187 int ecode3 = 0 ;
02188 int argvi = 0;
02189 bool result;
02190 dXSARGS;
02191
02192 if ((items < 3) || (items > 3)) {
02193 SWIG_croak("Usage: XrdPrepare(filepaths,opts,prty);");
02194 }
02195 res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
02196 if (!SWIG_IsOK(res1)) {
02197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XrdPrepare" "', argument " "1"" of type '" "char const *""'");
02198 }
02199 arg1 = (char *)(buf1);
02200 ecode2 = SWIG_AsVal_unsigned_SS_char SWIG_PERL_CALL_ARGS_2(ST(1), &val2);
02201 if (!SWIG_IsOK(ecode2)) {
02202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "XrdPrepare" "', argument " "2"" of type '" "unsigned char""'");
02203 }
02204 arg2 = (unsigned char)(val2);
02205 ecode3 = SWIG_AsVal_unsigned_SS_char SWIG_PERL_CALL_ARGS_2(ST(2), &val3);
02206 if (!SWIG_IsOK(ecode3)) {
02207 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "XrdPrepare" "', argument " "3"" of type '" "unsigned char""'");
02208 }
02209 arg3 = (unsigned char)(val3);
02210 result = (bool)XrdPrepare((char const *)arg1,arg2,arg3);
02211 ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1((bool)(result)); argvi++ ;
02212 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
02213
02214
02215 XSRETURN(argvi);
02216 fail:
02217 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
02218
02219
02220 SWIG_croak_null();
02221 }
02222 }
02223
02224
02225 XS(_wrap_XrdDirList) {
02226 {
02227 char *arg1 = (char *) 0 ;
02228 int res1 ;
02229 char *buf1 = 0 ;
02230 int alloc1 = 0 ;
02231 int argvi = 0;
02232 char *result = 0 ;
02233 dXSARGS;
02234
02235 if ((items < 1) || (items > 1)) {
02236 SWIG_croak("Usage: XrdDirList(dir);");
02237 }
02238 res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
02239 if (!SWIG_IsOK(res1)) {
02240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XrdDirList" "', argument " "1"" of type '" "char const *""'");
02241 }
02242 arg1 = (char *)(buf1);
02243 result = (char *)XrdDirList((char const *)arg1);
02244 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
02245 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
02246 XSRETURN(argvi);
02247 fail:
02248 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
02249 SWIG_croak_null();
02250 }
02251 }
02252
02253
02254 XS(_wrap_XrdGetChecksum) {
02255 {
02256 char *arg1 = (char *) 0 ;
02257 int res1 ;
02258 char *buf1 = 0 ;
02259 int alloc1 = 0 ;
02260 int argvi = 0;
02261 char *result = 0 ;
02262 dXSARGS;
02263
02264 if ((items < 1) || (items > 1)) {
02265 SWIG_croak("Usage: XrdGetChecksum(path);");
02266 }
02267 res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
02268 if (!SWIG_IsOK(res1)) {
02269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XrdGetChecksum" "', argument " "1"" of type '" "char const *""'");
02270 }
02271 arg1 = (char *)(buf1);
02272 result = (char *)XrdGetChecksum((char const *)arg1);
02273 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
02274 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
02275 XSRETURN(argvi);
02276 fail:
02277 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
02278 SWIG_croak_null();
02279 }
02280 }
02281
02282
02283 XS(_wrap_XrdGetCurrentHost) {
02284 {
02285 int argvi = 0;
02286 char *result = 0 ;
02287 dXSARGS;
02288
02289 if ((items < 0) || (items > 0)) {
02290 SWIG_croak("Usage: XrdGetCurrentHost();");
02291 }
02292 result = (char *)XrdGetCurrentHost();
02293 ST(argvi) = SWIG_FromCharPtr((const char *)result); argvi++ ;
02294 XSRETURN(argvi);
02295 fail:
02296 SWIG_croak_null();
02297 }
02298 }
02299
02300
02301 XS(_wrap_XrdStat) {
02302 {
02303 char *arg1 = (char *) 0 ;
02304 long *arg2 = (long *) 0 ;
02305 long long *arg3 = (long long *) 0 ;
02306 long *arg4 = (long *) 0 ;
02307 long *arg5 = (long *) 0 ;
02308 int res1 ;
02309 char *buf1 = 0 ;
02310 int alloc1 = 0 ;
02311 long temp2 ;
02312 int res2 = SWIG_TMPOBJ ;
02313 long long temp3 ;
02314 int res3 = SWIG_TMPOBJ ;
02315 long temp4 ;
02316 int res4 = SWIG_TMPOBJ ;
02317 long temp5 ;
02318 int res5 = SWIG_TMPOBJ ;
02319 int argvi = 0;
02320 bool result;
02321 dXSARGS;
02322
02323 arg2 = &temp2;
02324 arg3 = &temp3;
02325 arg4 = &temp4;
02326 arg5 = &temp5;
02327 if ((items < 1) || (items > 1)) {
02328 SWIG_croak("Usage: XrdStat(fname);");
02329 }
02330 res1 = SWIG_AsCharPtrAndSize(ST(0), &buf1, NULL, &alloc1);
02331 if (!SWIG_IsOK(res1)) {
02332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "XrdStat" "', argument " "1"" of type '" "char const *""'");
02333 }
02334 arg1 = (char *)(buf1);
02335 result = (bool)XrdStat((char const *)arg1,arg2,arg3,arg4,arg5);
02336 ST(argvi) = SWIG_From_bool SWIG_PERL_CALL_ARGS_1((bool)(result)); argvi++ ;
02337 if (SWIG_IsTmpObj(res2)) {
02338 if (argvi >= items) EXTEND(sp,1); ST(argvi) = SWIG_From_long SWIG_PERL_CALL_ARGS_1((*arg2)); argvi++ ;
02339 } else {
02340 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0) : 0;
02341 if (argvi >= items) EXTEND(sp,1); ST(argvi) = SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags); argvi++ ;
02342 }
02343 if (SWIG_IsTmpObj(res3)) {
02344 if (argvi >= items) EXTEND(sp,1); ST(argvi) = SWIG_From_long_SS_long SWIG_PERL_CALL_ARGS_1((*arg3)); argvi++ ;
02345 } else {
02346 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0) : 0;
02347 if (argvi >= items) EXTEND(sp,1); ST(argvi) = SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long_long, new_flags); argvi++ ;
02348 }
02349 if (SWIG_IsTmpObj(res4)) {
02350 if (argvi >= items) EXTEND(sp,1); ST(argvi) = SWIG_From_long SWIG_PERL_CALL_ARGS_1((*arg4)); argvi++ ;
02351 } else {
02352 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0) : 0;
02353 if (argvi >= items) EXTEND(sp,1); ST(argvi) = SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_long, new_flags); argvi++ ;
02354 }
02355 if (SWIG_IsTmpObj(res5)) {
02356 if (argvi >= items) EXTEND(sp,1); ST(argvi) = SWIG_From_long SWIG_PERL_CALL_ARGS_1((*arg5)); argvi++ ;
02357 } else {
02358 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0) : 0;
02359 if (argvi >= items) EXTEND(sp,1); ST(argvi) = SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_long, new_flags); argvi++ ;
02360 }
02361 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
02362
02363
02364
02365
02366 XSRETURN(argvi);
02367 fail:
02368 if (alloc1 == SWIG_NEWOBJ) free((char*)buf1);
02369
02370
02371
02372
02373 SWIG_croak_null();
02374 }
02375 }
02376
02377
02378
02379
02380
02381 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
02382 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
02383 static swig_type_info _swigt__p_long_long = {"_p_long_long", "long long *", 0, 0, (void*)0, 0};
02384
02385 static swig_type_info *swig_type_initial[] = {
02386 &_swigt__p_char,
02387 &_swigt__p_long,
02388 &_swigt__p_long_long,
02389 };
02390
02391 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
02392 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
02393 static swig_cast_info _swigc__p_long_long[] = { {&_swigt__p_long_long, 0, 0, 0},{0, 0, 0, 0}};
02394
02395 static swig_cast_info *swig_cast_initial[] = {
02396 _swigc__p_char,
02397 _swigc__p_long,
02398 _swigc__p_long_long,
02399 };
02400
02401
02402
02403
02404 static swig_constant_info swig_constants[] = {
02405 {0,0,0,0,0,0}
02406 };
02407 #ifdef __cplusplus
02408 }
02409 #endif
02410 static swig_variable_info swig_variables[] = {
02411 {0,0,0,0}
02412 };
02413 static swig_command_info swig_commands[] = {
02414 {"XrdClientAdminc::XrdInitialize", _wrap_XrdInitialize},
02415 {"XrdClientAdminc::XrdTerminate", _wrap_XrdTerminate},
02416 {"XrdClientAdminc::XrdSysStatX", _wrap_XrdSysStatX},
02417 {"XrdClientAdminc::XrdExistFiles", _wrap_XrdExistFiles},
02418 {"XrdClientAdminc::XrdExistDirs", _wrap_XrdExistDirs},
02419 {"XrdClientAdminc::XrdIsFileOnline", _wrap_XrdIsFileOnline},
02420 {"XrdClientAdminc::XrdMv", _wrap_XrdMv},
02421 {"XrdClientAdminc::XrdMkdir", _wrap_XrdMkdir},
02422 {"XrdClientAdminc::XrdChmod", _wrap_XrdChmod},
02423 {"XrdClientAdminc::XrdRm", _wrap_XrdRm},
02424 {"XrdClientAdminc::XrdRmdir", _wrap_XrdRmdir},
02425 {"XrdClientAdminc::XrdPrepare", _wrap_XrdPrepare},
02426 {"XrdClientAdminc::XrdDirList", _wrap_XrdDirList},
02427 {"XrdClientAdminc::XrdGetChecksum", _wrap_XrdGetChecksum},
02428 {"XrdClientAdminc::XrdGetCurrentHost", _wrap_XrdGetCurrentHost},
02429 {"XrdClientAdminc::XrdStat", _wrap_XrdStat},
02430 {0,0}
02431 };
02432
02433
02434
02435
02436
02437
02438
02439
02440
02441
02442
02443
02444
02445
02446
02447
02448
02449
02450
02451
02452
02453
02454
02455
02456
02457
02458
02459
02460
02461
02462
02463
02464
02465
02466
02467
02468
02469
02470
02471
02472
02473 #ifdef __cplusplus
02474 extern "C" {
02475 #if 0
02476 }
02477 #endif
02478 #endif
02479
02480 #if 0
02481 #define SWIGRUNTIME_DEBUG
02482 #endif
02483
02484
02485 SWIGRUNTIME void
02486 SWIG_InitializeModule(void *clientdata) {
02487 size_t i;
02488 swig_module_info *module_head, *iter;
02489 int found, init;
02490
02491 clientdata = clientdata;
02492
02493
02494 if (swig_module.next==0) {
02495
02496 swig_module.type_initial = swig_type_initial;
02497 swig_module.cast_initial = swig_cast_initial;
02498 swig_module.next = &swig_module;
02499 init = 1;
02500 } else {
02501 init = 0;
02502 }
02503
02504
02505 module_head = SWIG_GetModule(clientdata);
02506 if (!module_head) {
02507
02508
02509 SWIG_SetModule(clientdata, &swig_module);
02510 module_head = &swig_module;
02511 } else {
02512
02513 found=0;
02514 iter=module_head;
02515 do {
02516 if (iter==&swig_module) {
02517 found=1;
02518 break;
02519 }
02520 iter=iter->next;
02521 } while (iter!= module_head);
02522
02523
02524 if (found) return;
02525
02526 swig_module.next = module_head->next;
02527 module_head->next = &swig_module;
02528 }
02529
02530
02531
02532
02533
02534 if (init == 0) return;
02535
02536
02537 #ifdef SWIGRUNTIME_DEBUG
02538 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
02539 #endif
02540 for (i = 0; i < swig_module.size; ++i) {
02541 swig_type_info *type = 0;
02542 swig_type_info *ret;
02543 swig_cast_info *cast;
02544
02545 #ifdef SWIGRUNTIME_DEBUG
02546 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
02547 #endif
02548
02549
02550 if (swig_module.next != &swig_module) {
02551 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
02552 }
02553 if (type) {
02554
02555 #ifdef SWIGRUNTIME_DEBUG
02556 printf("SWIG_InitializeModule: found type %s\n", type->name);
02557 #endif
02558 if (swig_module.type_initial[i]->clientdata) {
02559 type->clientdata = swig_module.type_initial[i]->clientdata;
02560 #ifdef SWIGRUNTIME_DEBUG
02561 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
02562 #endif
02563 }
02564 } else {
02565 type = swig_module.type_initial[i];
02566 }
02567
02568
02569 cast = swig_module.cast_initial[i];
02570 while (cast->type) {
02571
02572 ret = 0;
02573 #ifdef SWIGRUNTIME_DEBUG
02574 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
02575 #endif
02576 if (swig_module.next != &swig_module) {
02577 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
02578 #ifdef SWIGRUNTIME_DEBUG
02579 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
02580 #endif
02581 }
02582 if (ret) {
02583 if (type == swig_module.type_initial[i]) {
02584 #ifdef SWIGRUNTIME_DEBUG
02585 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
02586 #endif
02587 cast->type = ret;
02588 ret = 0;
02589 } else {
02590
02591 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
02592 #ifdef SWIGRUNTIME_DEBUG
02593 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
02594 #endif
02595 if (!ocast) ret = 0;
02596 }
02597 }
02598
02599 if (!ret) {
02600 #ifdef SWIGRUNTIME_DEBUG
02601 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
02602 #endif
02603 if (type->cast) {
02604 type->cast->prev = cast;
02605 cast->next = type->cast;
02606 }
02607 type->cast = cast;
02608 }
02609 cast++;
02610 }
02611
02612 swig_module.types[i] = type;
02613 }
02614 swig_module.types[i] = 0;
02615
02616 #ifdef SWIGRUNTIME_DEBUG
02617 printf("**** SWIG_InitializeModule: Cast List ******\n");
02618 for (i = 0; i < swig_module.size; ++i) {
02619 int j = 0;
02620 swig_cast_info *cast = swig_module.cast_initial[i];
02621 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
02622 while (cast->type) {
02623 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
02624 cast++;
02625 ++j;
02626 }
02627 printf("---- Total casts: %d\n",j);
02628 }
02629 printf("**** SWIG_InitializeModule: Cast List ******\n");
02630 #endif
02631 }
02632
02633
02634
02635
02636
02637
02638 SWIGRUNTIME void
02639 SWIG_PropagateClientData(void) {
02640 size_t i;
02641 swig_cast_info *equiv;
02642 static int init_run = 0;
02643
02644 if (init_run) return;
02645 init_run = 1;
02646
02647 for (i = 0; i < swig_module.size; i++) {
02648 if (swig_module.types[i]->clientdata) {
02649 equiv = swig_module.types[i]->cast;
02650 while (equiv) {
02651 if (!equiv->converter) {
02652 if (equiv->type && !equiv->type->clientdata)
02653 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
02654 }
02655 equiv = equiv->next;
02656 }
02657 }
02658 }
02659 }
02660
02661 #ifdef __cplusplus
02662 #if 0
02663 {
02664
02665 #endif
02666 }
02667 #endif
02668
02669
02670
02671 #ifdef __cplusplus
02672 extern "C"
02673 #endif
02674
02675 XS(SWIG_init) {
02676 dXSARGS;
02677 int i;
02678
02679 SWIG_InitializeModule(0);
02680
02681
02682 for (i = 0; swig_commands[i].name; i++) {
02683 newXS((char*) swig_commands[i].name,swig_commands[i].wrapper, (char*)__FILE__);
02684 }
02685
02686
02687 for (i = 0; swig_variables[i].name; i++) {
02688 SV *sv;
02689 sv = get_sv((char*) swig_variables[i].name, TRUE | 0x2 | GV_ADDMULTI);
02690 if (swig_variables[i].type) {
02691 SWIG_MakePtr(sv,(void *)1, *swig_variables[i].type,0);
02692 } else {
02693 sv_setiv(sv,(IV) 0);
02694 }
02695 swig_create_magic(sv, (char *) swig_variables[i].name, swig_variables[i].set, swig_variables[i].get);
02696 }
02697
02698
02699 for (i = 0; swig_constants[i].type; i++) {
02700 SV *sv;
02701 sv = get_sv((char*)swig_constants[i].name, TRUE | 0x2 | GV_ADDMULTI);
02702 switch(swig_constants[i].type) {
02703 case SWIG_INT:
02704 sv_setiv(sv, (IV) swig_constants[i].lvalue);
02705 break;
02706 case SWIG_FLOAT:
02707 sv_setnv(sv, (double) swig_constants[i].dvalue);
02708 break;
02709 case SWIG_STRING:
02710 sv_setpv(sv, (char *) swig_constants[i].pvalue);
02711 break;
02712 case SWIG_POINTER:
02713 SWIG_MakePtr(sv, swig_constants[i].pvalue, *(swig_constants[i].ptype),0);
02714 break;
02715 case SWIG_BINARY:
02716 SWIG_MakePackedObj(sv, swig_constants[i].pvalue, swig_constants[i].lvalue, *(swig_constants[i].ptype));
02717 break;
02718 default:
02719 break;
02720 }
02721 SvREADONLY_on(sv);
02722 }
02723
02724 ST(0) = &PL_sv_yes;
02725 XSRETURN(1);
02726 }
02727
02728 