src/Net-ICal-Libical/netical_wrap.c

   1 /*
   2  * FILE : netical_wrap.c
   3  *
   4  * This file was automatically generated by :
   5  * Simplified Wrapper and Interface Generator (SWIG)
   6  * Version 1.1 (Patch 5)
   7  *
   8  * Portions Copyright (c) 1995-1998
   9  * The University of Utah and The Regents of the University of California.
  10  * Permission is granted to distribute this file in any manner provided
  11  * this notice remains intact.
  12  *
  13  * Do not make changes to this file--changes will be lost!
  14  *
  15  */
  16
  17
  18 #define SWIGCODE
  19 /* Implementation : PERL 5 */
  20
  21 #define SWIGPERL
  22 #define SWIGPERL5
  23 #ifdef __cplusplus
  24 #include <math.h>
  25 #include <stdlib.h>
  26 extern "C" {
  27 #endif
  28 #include "EXTERN.h"
  29 #include "perl.h"
  30 #include "XSUB.h"
  31 #undef free
  32 #undef malloc
  33 #include <string.h>
  34 #ifdef __cplusplus
  35 }
  36 #endif
  37 /* Definitions for compiling Perl extensions on a variety of machines */
  38
  39 #if defined(WIN32) || defined(__WIN32__)
  40 #   if defined(_MSC_VER)
  41 #       define SWIGEXPORT(a,b) __declspec(dllexport) a b
  42 #   else
  43 #       if defined(__BORLANDC__)
  44 #           define SWIGEXPORT(a,b) a _export b
  45 #       else
  46 #           define SWIGEXPORT(a,b) a b
  47 #       endif
  48 #   endif
  49 #else
  50 #   define SWIGEXPORT(a,b) a b
  51 #endif
  52
  53 #ifdef PERL_OBJECT
  54 #define MAGIC_PPERL  CPerl *pPerl = (CPerl *) this;
  55 #define MAGIC_CAST   (int (CPerl::*)(SV *, MAGIC *))
  56 #define SWIGCLASS_STATIC
  57 #else
  58 #define MAGIC_PPERL
  59 #define MAGIC_CAST
  60 #define SWIGCLASS_STATIC static
  61 #endif
  62
  63
  64 /*****************************************************************************
  65  * $Header: /tmp/freeassociation-cvsbackup/libical/src/Net-ICal-Libical/netical_wrap.c,v 1.6 2001-04-02 18:17:40 ebusboom Exp $
  66  *
  67  * perl5ptr.swg
  68  *
  69  * This file contains supporting code for the SWIG run-time type checking
  70  * mechanism.  The following functions are available :
  71  *
  72  * SWIG_RegisterMapping(char *origtype, char *newtype, void *(*cast)(void *));
  73  *
  74  *      Registers a new type-mapping with the type-checker.  origtype is the
  75  *      original datatype and newtype is an equivalent type.  cast is optional
  76  *      pointer to a function to cast pointer values between types (this
  77  *      is only used to cast pointers from derived classes to base classes in C++)
  78  *
  79  * SWIG_MakePtr(char *buffer, void *ptr, char *typestring);
  80  *
  81  *      Makes a pointer string from a pointer and typestring.  The result is returned
  82  *      in buffer.
  83  *
  84  * char * SWIG_GetPtr(SV *obj, void **ptr, char *type)
  85  *
  86  *      Gets a pointer value from a Perl5 scalar value.  If there is a
  87  *      type-mismatch, returns a character string to the received type.
  88  *      On success, returns NULL.
  89  *
  90  *
  91  * You can remap these functions by making a file called "swigptr.swg" in
  92  * your the same directory as the interface file you are wrapping.
  93  *
  94  * These functions are normally declared static, but this file can be
  95  * can be used in a multi-module environment by redefining the symbol
  96  * SWIGSTATIC.
  97  *
  98  * $Log: not supported by cvs2svn $
  99  * Revision 1.1  1996/12/26 22:17:29  beazley
 100  * Initial revision
 101  *
 102  *****************************************************************************/
 103
 104 #include <stdlib.h>
 105
 106 #ifdef SWIG_GLOBAL
 107 #ifdef __cplusplus
 108 #define SWIGSTATIC extern "C"
 109 #else
 110 #define SWIGSTATIC
 111 #endif
 112 #endif
 113
 114 #ifndef SWIGSTATIC
 115 #define SWIGSTATIC static
 116 #endif
 117
 118 /* These are internal variables.   Should be static */
 119
 120 typedef struct SwigPtrType {
 121   char               *name;
 122   int                 len;
 123   void               *(*cast)(void *);
 124   struct SwigPtrType *next;
 125 } SwigPtrType;
 126
 127 /* Pointer cache structure */
 128
 129 typedef struct {
 130   int                 stat;               /* Status (valid) bit             */
 131   SwigPtrType        *tp;                 /* Pointer to type structure      */
 132   char                name[256];          /* Given datatype name            */
 133   char                mapped[256];        /* Equivalent name                */
 134 } SwigCacheType;
 135
 136 static int SwigPtrMax  = 64;           /* Max entries that can be currently held */
 137 static int SwigPtrN    = 0;            /* Current number of entries              */
 138 static int SwigPtrSort = 0;            /* Status flag indicating sort            */
 139 static SwigPtrType *SwigPtrTable = 0;  /* Table containing pointer equivalences  */
 140 static int SwigStart[256];             /* Table containing starting positions    */
 141
 142 /* Cached values */
 143
 144 #define SWIG_CACHESIZE  8
 145 #define SWIG_CACHEMASK  0x7
 146 static SwigCacheType SwigCache[SWIG_CACHESIZE];
 147 static int SwigCacheIndex = 0;
 148 static int SwigLastCache = 0;
 149
 150 /* Sort comparison function */
 151 static int swigsort(const void *data1, const void *data2) {
 152         SwigPtrType *d1 = (SwigPtrType *) data1;
 153         SwigPtrType *d2 = (SwigPtrType *) data2;
 154         return strcmp(d1->name,d2->name);
 155 }
 156
 157 /* Binary Search function */
 158 static int swigcmp(const void *key, const void *data) {
 159   char *k = (char *) key;
 160   SwigPtrType *d = (SwigPtrType *) data;
 161   return strncmp(k,d->name,d->len);
 162 }
 163
 164 /* Register a new datatype with the type-checker */
 165
 166 #ifndef PERL_OBJECT
 167 SWIGSTATIC
 168 void SWIG_RegisterMapping(char *origtype, char *newtype, void *(*cast)(void *)) {
 169 #else
 170 SWIGSTATIC
 171 #define SWIG_RegisterMapping(a,b,c) _SWIG_RegisterMapping(pPerl, a,b,c)
 172 void _SWIG_RegisterMapping(CPerl *pPerl, char *origtype, char *newtype, void *(*cast)(void *)) {
 173 #endif
 174
 175   int i;
 176   SwigPtrType *t = 0, *t1;
 177
 178   if (!SwigPtrTable) {
 179     SwigPtrTable = (SwigPtrType *) malloc(SwigPtrMax*sizeof(SwigPtrType));
 180     SwigPtrN = 0;
 181   }
 182   if (SwigPtrN >= SwigPtrMax) {
 183     SwigPtrMax = 2*SwigPtrMax;
 184     SwigPtrTable = (SwigPtrType *) realloc(SwigPtrTable,SwigPtrMax*sizeof(SwigPtrType));
 185   }
 186   for (i = 0; i < SwigPtrN; i++)
 187     if (strcmp(SwigPtrTable[i].name,origtype) == 0) {
 188       t = &SwigPtrTable[i];
 189       break;
 190     }
 191   if (!t) {
 192     t = &SwigPtrTable[SwigPtrN];
 193     t->name = origtype;
 194     t->len = strlen(t->name);
 195     t->cast = 0;
 196     t->next = 0;
 197     SwigPtrN++;
 198   }
 199   while (t->next) {
 200     if (strcmp(t->name,newtype) == 0) {
 201       if (cast) t->cast = cast;
 202       return;
 203     }
 204     t = t->next;
 205   }
 206   t1 = (SwigPtrType *) malloc(sizeof(SwigPtrType));
 207   t1->name = newtype;
 208   t1->len = strlen(t1->name);
 209   t1->cast = cast;
 210   t1->next = 0;
 211   t->next = t1;
 212   SwigPtrSort = 0;
 213 }
 214
 215 /* Make a pointer value string */
 216
 217 SWIGSTATIC
 218 void SWIG_MakePtr(char *_c, const void *_ptr, char *type) {
 219   static char _hex[16] =
 220   {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
 221    'a', 'b', 'c', 'd', 'e', 'f'};
 222   unsigned long _p, _s;
 223   char _result[20], *_r;    /* Note : a 64-bit hex number = 16 digits */
 224   _r = _result;
 225   _p = (unsigned long) _ptr;
 226   if (_p > 0) {
 227     while (_p > 0) {
 228       _s = _p & 0xf;
 229       *(_r++) = _hex[_s];
 230       _p = _p >> 4;
 231     }
 232     *_r = '_';
 233     while (_r >= _result)
 234       *(_c++) = *(_r--);
 235   } else {
 236     strcpy (_c, "NULL");
 237   }
 238   if (_ptr)
 239     strcpy (_c, type);
 240 }
 241
 242 /* Define for backwards compatibility */
 243
 244 #define _swig_make_hex   SWIG_MakePtr
 245
 246 /* Function for getting a pointer value */
 247
 248 #ifndef PERL_OBJECT
 249 SWIGSTATIC
 250 char *SWIG_GetPtr(SV *sv, void **ptr, char *_t)
 251 #else
 252 SWIGSTATIC
 253 #define SWIG_GetPtr(a,b,c) _SWIG_GetPtr(pPerl,a,b,c)
 254 char *_SWIG_GetPtr(CPerl *pPerl, SV *sv, void **ptr, char *_t)
 255 #endif
 256 {
 257   char temp_type[256];
 258   char *name,*_c;
 259   int  len,i,start,end;
 260   IV   tmp;
 261   SwigPtrType *sp,*tp;
 262   SwigCacheType *cache;
 263
 264   /* If magical, apply more magic */
 265
 266   if (SvGMAGICAL(sv))
 267     mg_get(sv);
 268
 269   /* Check to see if this is an object */
 270   if (sv_isobject(sv)) {
 271     SV *tsv = (SV*) SvRV(sv);
 272     if ((SvTYPE(tsv) == SVt_PVHV)) {
 273       MAGIC *mg;
 274       if (SvMAGICAL(tsv)) {
 275         mg = mg_find(tsv,'P');
 276         if (mg) {
 277           SV *rsv = mg->mg_obj;
 278           if (sv_isobject(rsv)) {
 279             tmp = SvIV((SV*)SvRV(rsv));
 280           }
 281         }
 282       } else {
 283         return "Not a valid pointer value";
 284       }
 285     } else {
 286       tmp = SvIV((SV*)SvRV(sv));
 287     }
 288     if (!_t) {
 289       *(ptr) = (void *) tmp;
 290       return (char *) 0;
 291     }
 292   } else if (sv == &sv_undef) {            /* Check for undef */
 293     *(ptr) = (void *) 0;
 294     return (char *) 0;
 295   } else if (SvTYPE(sv) == SVt_RV) {       /* Check for NULL pointer */
 296     *(ptr) = (void *) 0;
 297     if (!SvROK(sv))
 298       return (char *) 0;
 299     else
 300       return "Not a valid pointer value";
 301   } else {                                 /* Don't know what it is */
 302       *(ptr) = (void *) 0;
 303       return "Not a valid pointer value";
 304   }
 305   if (_t) {
 306     /* Now see if the types match */
 307
 308     if (!sv_isa(sv,_t)) {
 309       _c = HvNAME(SvSTASH(SvRV(sv)));
 310       if (!SwigPtrSort) {
 311         qsort((void *) SwigPtrTable, SwigPtrN, sizeof(SwigPtrType), swigsort);
 312         for (i = 0; i < 256; i++) {
 313           SwigStart[i] = SwigPtrN;
 314         }
 315         for (i = SwigPtrN-1; i >= 0; i--) {
 316           SwigStart[SwigPtrTable[i].name[0]] = i;
 317         }
 318         for (i = 255; i >= 1; i--) {
 319           if (SwigStart[i-1] > SwigStart[i])
 320             SwigStart[i-1] = SwigStart[i];
 321         }
 322         SwigPtrSort = 1;
 323         for (i = 0; i < SWIG_CACHESIZE; i++)
 324           SwigCache[i].stat = 0;
 325       }
 326       /* First check cache for matches.  Uses last cache value as starting point */
 327       cache = &SwigCache[SwigLastCache];
 328       for (i = 0; i < SWIG_CACHESIZE; i++) {
 329         if (cache->stat) {
 330           if (strcmp(_t,cache->name) == 0) {
 331             if (strcmp(_c,cache->mapped) == 0) {
 332               cache->stat++;
 333               *ptr = (void *) tmp;
 334               if (cache->tp->cast) *ptr = (*(cache->tp->cast))(*ptr);
 335               return (char *) 0;
 336             }
 337           }
 338         }
 339         SwigLastCache = (SwigLastCache+1) & SWIG_CACHEMASK;
 340         if (!SwigLastCache) cache = SwigCache;
 341         else cache++;
 342       }
 343
 344       start = SwigStart[_t[0]];
 345       end = SwigStart[_t[0]+1];
 346       sp = &SwigPtrTable[start];
 347       while (start < end) {
 348         if (swigcmp(_t,sp) == 0) break;
 349         sp++;
 350         start++;
 351       }
 352       if (start >= end) sp = 0;
 353       if (sp) {
 354         while (swigcmp(_t,sp) == 0) {
 355           name = sp->name;
 356           len = sp->len;
 357           tp = sp->next;
 358           while(tp) {
 359             if (tp->len >= 255) {
 360               return _c;
 361             }
 362             strcpy(temp_type,tp->name);
 363             strncat(temp_type,_t+len,255-tp->len);
 364             if (sv_isa(sv,temp_type)) {
 365               /* Get pointer value */
 366               *ptr = (void *) tmp;
 367               if (tp->cast) *ptr = (*(tp->cast))(*ptr);
 368
 369               strcpy(SwigCache[SwigCacheIndex].mapped,_c);
 370               strcpy(SwigCache[SwigCacheIndex].name,_t);
 371               SwigCache[SwigCacheIndex].stat = 1;
 372               SwigCache[SwigCacheIndex].tp = tp;
 373               SwigCacheIndex = SwigCacheIndex & SWIG_CACHEMASK;
 374               return (char *) 0;
 375             }
 376             tp = tp->next;
 377           }
 378           /* Hmmm. Didn't find it this time */
 379           sp++;
 380         }
 381       }
 382       /* Didn't find any sort of match for this data.
 383          Get the pointer value and return the received type */
 384       *ptr = (void *) tmp;
 385       return _c;
 386     } else {
 387       /* Found a match on the first try.  Return pointer value */
 388       *ptr = (void *) tmp;
 389       return (char *) 0;
 390     }
 391   }
 392   *ptr = (void *) tmp;
 393   return (char *) 0;
 394 }
 395
 396 /* Compatibility mode */
 397
 398 #define _swig_get_hex  SWIG_GetPtr
 399 /* Magic variable code */
 400 #ifndef PERL_OBJECT
 401 #define swig_create_magic(s,a,b,c) _swig_create_magic(s,a,b,c)
 402 static void _swig_create_magic(SV *sv, char *name, int (*set)(SV *, MAGIC *), int (*get)(SV *,MAGIC *)) {
 403 #else
 404 #define swig_create_magic(s,a,b,c) _swig_create_magic(pPerl,s,a,b,c)
 405 static void _swig_create_magic(CPerl *pPerl, SV *sv, char *name, int (CPerl::*set)(SV *, MAGIC *), int (CPerl::*get)(SV *, MAGIC *)) {
 406 #endif
 407   MAGIC *mg;
 408   sv_magic(sv,sv,'U',name,strlen(name));
 409   mg = mg_find(sv,'U');
 410   mg->mg_virtual = (MGVTBL *) malloc(sizeof(MGVTBL));
 411   mg->mg_virtual->svt_get = get;
 412   mg->mg_virtual->svt_set = set;
 413   mg->mg_virtual->svt_len = 0;
 414   mg->mg_virtual->svt_clear = 0;
 415   mg->mg_virtual->svt_free = 0;
 416 }
 417
 418 #define SWIG_init    boot_Net__ICal__Libical
 419
 420 #define SWIG_name   "Net::ICal::Libical::boot_Net__ICal__Libical"
 421 #define SWIG_varinit "Net::ICal::Libical::var_Net__ICal__Libical_init();"
 422 #ifdef __cplusplus
 423 extern "C"
 424 #endif
 425 #ifndef PERL_OBJECT
 426 SWIGEXPORT(void,boot_Net__ICal__Libical)(CV* cv);
 427 #else
 428 SWIGEXPORT(void,boot_Net__ICal__Libical)(CPerl *, CV *cv);
 429 #endif
 430
 431 #include "ical.h"
 432
 433 #include <sys/types.h> /* for size_t */
 434 #include <time.h>
 435
 436 #ifndef PERL_OBJECT
 437 #define swig_setiv(a,b) _swig_setiv(a,b)
 438 static void _swig_setiv(char *name, long value) {
 439 #else
 440 #define swig_setiv(a,b) _swig_setiv(pPerl,a,b)
 441 static void _swig_setiv(CPerl *pPerl, char *name, long value) {
 442 #endif
 443      SV *sv;
 444      sv = perl_get_sv(name,TRUE | 0x2);
 445      sv_setiv(sv, (IV) value);
 446      SvREADONLY_on(sv);
 447 }
 448
 449 #ifndef PERL_OBJECT
 450 #define swig_setpv(a,b) _swig_setpv(a,b)
 451 static void _swig_setpv(char *name, char *value) {
 452 #else
 453 #define swig_setpv(a,b) _swig_setpv(pPerl,a,b)
 454 static void _swig_setpv(CPerl *pPerl, char *name, char *value) {
 455 #endif
 456      SV *sv;
 457      sv = perl_get_sv(name,TRUE | 0x2);
 458      sv_setpv(sv, value);
 459      SvREADONLY_on(sv);
 460 }
 461
 462 #ifdef PERL_OBJECT
 463 #define MAGIC_CLASS _wrap_Net__ICal__Libical_var::
 464 class _wrap_Net__ICal__Libical_var : public CPerl {
 465 public:
 466 #else
 467 #define MAGIC_CLASS
 468 #endif
 469 SWIGCLASS_STATIC int swig_magic_readonly(SV *sv, MAGIC *mg) {
 470     MAGIC_PPERL
 471     sv = sv; mg = mg;
 472     croak("Value is read-only.");
 473     return 0;
 474 }
 475
 476
 477 #ifdef PERL_OBJECT
 478 };
 479 #endif
 480
 481 XS(_wrap_icalparser_parse_string) {
 482
 483     icalcomponent * _result;
 484     char * _arg0;
 485     int argvi = 0;
 486     dXSARGS ;
 487
 488     cv = cv;
 489     if ((items < 1) || (items > 1))
 490         croak("Usage: icalparser_parse_string(str);");
 491     _arg0 = (char *) SvPV(ST(0),na);
 492     _result = (icalcomponent *)icalparser_parse_string(_arg0);
 493     ST(argvi) = sv_newmortal();
 494     sv_setref_pv(ST(argvi++),"icalcomponentPtr", (void *) _result);
 495     XSRETURN(argvi);
 496 }
 497
 498 XS(_wrap_icalcomponent_new) {
 499
 500     icalcomponent * _result;
 501     icalcomponent_kind * _arg0;
 502     int argvi = 0;
 503     dXSARGS ;
 504
 505     cv = cv;
 506     if ((items < 1) || (items > 1))
 507         croak("Usage: icalcomponent_new(kind);");
 508     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"icalcomponent_kindPtr")) {
 509         croak("Type error in argument 1 of icalcomponent_new. Expected icalcomponent_kindPtr.");
 510         XSRETURN(1);
 511     }
 512     _result = (icalcomponent *)icalcomponent_new(*_arg0);
 513     ST(argvi) = sv_newmortal();
 514     sv_setref_pv(ST(argvi++),"icalcomponentPtr", (void *) _result);
 515     XSRETURN(argvi);
 516 }
 517
 518 XS(_wrap_icalcomponent_new_clone) {
 519
 520     icalcomponent * _result;
 521     icalcomponent * _arg0;
 522     int argvi = 0;
 523     dXSARGS ;
 524
 525     cv = cv;
 526     if ((items < 1) || (items > 1))
 527         croak("Usage: icalcomponent_new_clone(component);");
 528     if (SWIG_GetPtr(ST(0),(void **) &_arg0,(char *) 0 )) {
 529         croak("Type error in argument 1 of icalcomponent_new_clone. Expected icalcomponentPtr.");
 530         XSRETURN(1);
 531     }
 532     _result = (icalcomponent *)icalcomponent_new_clone(_arg0);
 533     ST(argvi) = sv_newmortal();
 534     sv_setref_pv(ST(argvi++),"icalcomponentPtr", (void *) _result);
 535     XSRETURN(argvi);
 536 }
 537
 538 XS(_wrap_icalcomponent_new_from_string) {
 539
 540     icalcomponent * _result;
 541     char * _arg0;
 542     int argvi = 0;
 543     dXSARGS ;
 544
 545     cv = cv;
 546     if ((items < 1) || (items > 1))
 547         croak("Usage: icalcomponent_new_from_string(str);");
 548     _arg0 = (char *) SvPV(ST(0),na);
 549     _result = (icalcomponent *)icalcomponent_new_from_string(_arg0);
 550     ST(argvi) = sv_newmortal();
 551     sv_setref_pv(ST(argvi++),"icalcomponentPtr", (void *) _result);
 552     XSRETURN(argvi);
 553 }
 554
 555 XS(_wrap_icalcomponent_as_ical_string) {
 556
 557     char * _result;
 558     icalcomponent * _arg0;
 559     int argvi = 0;
 560     dXSARGS ;
 561
 562     cv = cv;
 563     if ((items < 1) || (items > 1))
 564         croak("Usage: icalcomponent_as_ical_string(component);");
 565     if (SWIG_GetPtr(ST(0),(void **) &_arg0,(char *) 0 )) {
 566         croak("Type error in argument 1 of icalcomponent_as_ical_string. Expected icalcomponentPtr.");
 567         XSRETURN(1);
 568     }
 569     _result = (char *)icalcomponent_as_ical_string(_arg0);
 570     ST(argvi) = sv_newmortal();
 571     sv_setpv((SV*)ST(argvi++),(char *) _result);
 572     XSRETURN(argvi);
 573 }
 574
 575 XS(_wrap_icalcomponent_free) {
 576
 577     icalcomponent * _arg0;
 578     int argvi = 0;
 579     dXSARGS ;
 580
 581     cv = cv;
 582     if ((items < 1) || (items > 1))
 583         croak("Usage: icalcomponent_free(component);");
 584     if (SWIG_GetPtr(ST(0),(void **) &_arg0,(char *) 0 )) {
 585         croak("Type error in argument 1 of icalcomponent_free. Expected icalcomponentPtr.");
 586         XSRETURN(1);
 587     }
 588     icalcomponent_free(_arg0);
 589     XSRETURN(argvi);
 590 }
 591
 592 XS(_wrap_icalcomponent_count_errors) {
 593
 594     int  _result;
 595     icalcomponent * _arg0;
 596     int argvi = 0;
 597     dXSARGS ;
 598
 599     cv = cv;
 600     if ((items < 1) || (items > 1))
 601         croak("Usage: icalcomponent_count_errors(component);");
 602     if (SWIG_GetPtr(ST(0),(void **) &_arg0,(char *) 0 )) {
 603         croak("Type error in argument 1 of icalcomponent_count_errors. Expected icalcomponentPtr.");
 604         XSRETURN(1);
 605     }
 606     _result = (int )icalcomponent_count_errors(_arg0);
 607     ST(argvi) = sv_newmortal();
 608     sv_setiv(ST(argvi++),(IV) _result);
 609     XSRETURN(argvi);
 610 }
 611
 612 XS(_wrap_icalcomponent_strip_errors) {
 613
 614     icalcomponent * _arg0;
 615     int argvi = 0;
 616     dXSARGS ;
 617
 618     cv = cv;
 619     if ((items < 1) || (items > 1))
 620         croak("Usage: icalcomponent_strip_errors(component);");
 621     if (SWIG_GetPtr(ST(0),(void **) &_arg0,(char *) 0 )) {
 622         croak("Type error in argument 1 of icalcomponent_strip_errors. Expected icalcomponentPtr.");
 623         XSRETURN(1);
 624     }
 625     icalcomponent_strip_errors(_arg0);
 626     XSRETURN(argvi);
 627 }
 628
 629 XS(_wrap_icalcomponent_convert_errors) {
 630
 631     icalcomponent * _arg0;
 632     int argvi = 0;
 633     dXSARGS ;
 634
 635     cv = cv;
 636     if ((items < 1) || (items > 1))
 637         croak("Usage: icalcomponent_convert_errors(component);");
 638     if (SWIG_GetPtr(ST(0),(void **) &_arg0,(char *) 0 )) {
 639         croak("Type error in argument 1 of icalcomponent_convert_errors. Expected icalcomponentPtr.");
 640         XSRETURN(1);
 641     }
 642     icalcomponent_convert_errors(_arg0);
 643     XSRETURN(argvi);
 644 }
 645
 646 XS(_wrap_icalcomponent_get_current_property) {
 647
 648     icalproperty * _result;
 649     icalcomponent * _arg0;
 650     int argvi = 0;
 651     dXSARGS ;
 652
 653     cv = cv;
 654     if ((items < 1) || (items > 1))
 655         croak("Usage: icalcomponent_get_current_property(component);");
 656     if (SWIG_GetPtr(ST(0),(void **) &_arg0,(char *) 0 )) {
 657         croak("Type error in argument 1 of icalcomponent_get_current_property. Expected icalcomponentPtr.");
 658         XSRETURN(1);
 659     }
 660     _result = (icalproperty *)icalcomponent_get_current_property(_arg0);
 661     ST(argvi) = sv_newmortal();
 662     sv_setref_pv(ST(argvi++),"icalpropertyPtr", (void *) _result);
 663     XSRETURN(argvi);
 664 }
 665
 666 XS(_wrap_icalcomponent_get_first_property) {
 667
 668     icalproperty * _result;
 669     icalcomponent * _arg0;
 670     icalproperty_kind * _arg1;
 671     int argvi = 0;
 672     dXSARGS ;
 673
 674     cv = cv;
 675     if ((items < 2) || (items > 2))
 676         croak("Usage: icalcomponent_get_first_property(component,kind);");
 677     if (SWIG_GetPtr(ST(0),(void **) &_arg0,(char *) 0 )) {
 678         croak("Type error in argument 1 of icalcomponent_get_first_property. Expected icalcomponentPtr.");
 679         XSRETURN(1);
 680     }
 681     if (SWIG_GetPtr(ST(1),(void **) &_arg1,"icalproperty_kindPtr")) {
 682         croak("Type error in argument 2 of icalcomponent_get_first_property. Expected icalproperty_kindPtr.");
 683         XSRETURN(1);
 684     }
 685     _result = (icalproperty *)icalcomponent_get_first_property(_arg0,*_arg1);
 686     ST(argvi) = sv_newmortal();
 687     sv_setref_pv(ST(argvi++),"icalpropertyPtr", (void *) _result);
 688     XSRETURN(argvi);
 689 }
 690
 691 XS(_wrap_icalcomponent_get_next_property) {
 692
 693     icalproperty * _result;
 694     icalcomponent * _arg0;
 695     icalproperty_kind * _arg1;
 696     int argvi = 0;
 697     dXSARGS ;
 698
 699     cv = cv;
 700     if ((items < 2) || (items > 2))
 701         croak("Usage: icalcomponent_get_next_property(component,kind);");
 702     if (SWIG_GetPtr(ST(0),(void **) &_arg0,(char *) 0 )) {
 703         croak("Type error in argument 1 of icalcomponent_get_next_property. Expected icalcomponentPtr.");
 704         XSRETURN(1);
 705     }
 706     if (SWIG_GetPtr(ST(1),(void **) &_arg1,"icalproperty_kindPtr")) {
 707         croak("Type error in argument 2 of icalcomponent_get_next_property. Expected icalproperty_kindPtr.");
 708         XSRETURN(1);
 709     }
 710     _result = (icalproperty *)icalcomponent_get_next_property(_arg0,*_arg1);
 711     ST(argvi) = sv_newmortal();
 712     sv_setref_pv(ST(argvi++),"icalpropertyPtr", (void *) _result);
 713     XSRETURN(argvi);
 714 }
 715
 716 XS(_wrap_icalcomponent_get_current_component) {
 717
 718     icalcomponent * _result;
 719     icalcomponent * _arg0;
 720     int argvi = 0;
 721     dXSARGS ;
 722
 723     cv = cv;
 724     if ((items < 1) || (items > 1))
 725         croak("Usage: icalcomponent_get_current_component(component);");
 726     if (SWIG_GetPtr(ST(0),(void **) &_arg0,(char *) 0 )) {
 727         croak("Type error in argument 1 of icalcomponent_get_current_component. Expected icalcomponentPtr.");
 728         XSRETURN(1);
 729     }
 730     _result = (icalcomponent *)icalcomponent_get_current_component(_arg0);
 731     ST(argvi) = sv_newmortal();
 732     sv_setref_pv(ST(argvi++),"icalcomponentPtr", (void *) _result);
 733     XSRETURN(argvi);
 734 }
 735
 736 XS(_wrap_icalcomponent_get_first_component) {
 737
 738     icalcomponent * _result;
 739     icalcomponent * _arg0;
 740     icalcomponent_kind * _arg1;
 741     int argvi = 0;
 742     dXSARGS ;
 743
 744     cv = cv;
 745     if ((items < 2) || (items > 2))
 746         croak("Usage: icalcomponent_get_first_component(component,kind);");
 747     if (SWIG_GetPtr(ST(0),(void **) &_arg0,(char *) 0 )) {
 748         croak("Type error in argument 1 of icalcomponent_get_first_component. Expected icalcomponentPtr.");
 749         XSRETURN(1);
 750     }
 751     if (SWIG_GetPtr(ST(1),(void **) &_arg1,"icalcomponent_kindPtr")) {
 752         croak("Type error in argument 2 of icalcomponent_get_first_component. Expected icalcomponent_kindPtr.");
 753         XSRETURN(1);
 754     }
 755     _result = (icalcomponent *)icalcomponent_get_first_component(_arg0,*_arg1);
 756     ST(argvi) = sv_newmortal();
 757     sv_setref_pv(ST(argvi++),"icalcomponentPtr", (void *) _result);
 758     XSRETURN(argvi);
 759 }
 760
 761 XS(_wrap_icalcomponent_get_next_component) {
 762
 763     icalcomponent * _result;
 764     icalcomponent * _arg0;
 765     icalcomponent_kind * _arg1;
 766     int argvi = 0;
 767     dXSARGS ;
 768
 769     cv = cv;
 770     if ((items < 2) || (items > 2))
 771         croak("Usage: icalcomponent_get_next_component(component,kind);");
 772     if (SWIG_GetPtr(ST(0),(void **) &_arg0,(char *) 0 )) {
 773         croak("Type error in argument 1 of icalcomponent_get_next_component. Expected icalcomponentPtr.");
 774         XSRETURN(1);
 775     }
 776     if (SWIG_GetPtr(ST(1),(void **) &_arg1,"icalcomponent_kindPtr")) {
 777         croak("Type error in argument 2 of icalcomponent_get_next_component. Expected icalcomponent_kindPtr.");
 778         XSRETURN(1);
 779     }
 780     _result = (icalcomponent *)icalcomponent_get_next_component(_arg0,*_arg1);
 781     ST(argvi) = sv_newmortal();
 782     sv_setref_pv(ST(argvi++),"icalcomponentPtr", (void *) _result);
 783     XSRETURN(argvi);
 784 }
 785
 786 XS(_wrap_icalcomponent_add_property) {
 787
 788     icalcomponent * _arg0;
 789     icalproperty * _arg1;
 790     int argvi = 0;
 791     dXSARGS ;
 792
 793     cv = cv;
 794     if ((items < 2) || (items > 2))
 795         croak("Usage: icalcomponent_add_property(component,property);");
 796     if (SWIG_GetPtr(ST(0),(void **) &_arg0,(char *) 0 )) {
 797         croak("Type error in argument 1 of icalcomponent_add_property. Expected icalcomponentPtr.");
 798         XSRETURN(1);
 799     }
 800     if (SWIG_GetPtr(ST(1),(void **) &_arg1,(char *) 0 )) {
 801         croak("Type error in argument 2 of icalcomponent_add_property. Expected icalpropertyPtr.");
 802         XSRETURN(1);
 803     }
 804     icalcomponent_add_property(_arg0,_arg1);
 805     XSRETURN(argvi);
 806 }
 807
 808 XS(_wrap_icalcomponent_remove_property) {
 809
 810     icalcomponent * _arg0;
 811     icalproperty * _arg1;
 812     int argvi = 0;
 813     dXSARGS ;
 814
 815     cv = cv;
 816     if ((items < 2) || (items > 2))
 817         croak("Usage: icalcomponent_remove_property(component,property);");
 818     if (SWIG_GetPtr(ST(0),(void **) &_arg0,(char *) 0 )) {
 819         croak("Type error in argument 1 of icalcomponent_remove_property. Expected icalcomponentPtr.");
 820         XSRETURN(1);
 821     }
 822     if (SWIG_GetPtr(ST(1),(void **) &_arg1,(char *) 0 )) {
 823         croak("Type error in argument 2 of icalcomponent_remove_property. Expected icalpropertyPtr.");
 824         XSRETURN(1);
 825     }
 826     icalcomponent_remove_property(_arg0,_arg1);
 827     XSRETURN(argvi);
 828 }
 829
 830 XS(_wrap_icalcomponent_get_parent) {
 831
 832     icalcomponent * _result;
 833     icalcomponent * _arg0;
 834     int argvi = 0;
 835     dXSARGS ;
 836
 837     cv = cv;
 838     if ((items < 1) || (items > 1))
 839         croak("Usage: icalcomponent_get_parent(component);");
 840     if (SWIG_GetPtr(ST(0),(void **) &_arg0,(char *) 0 )) {
 841         croak("Type error in argument 1 of icalcomponent_get_parent. Expected icalcomponentPtr.");
 842         XSRETURN(1);
 843     }
 844     _result = (icalcomponent *)icalcomponent_get_parent(_arg0);
 845     ST(argvi) = sv_newmortal();
 846     sv_setref_pv(ST(argvi++),"icalcomponentPtr", (void *) _result);
 847     XSRETURN(argvi);
 848 }
 849
 850 XS(_wrap_icalcomponent_isa) {
 851
 852     icalcomponent_kind * _result;
 853     icalcomponent * _arg0;
 854     int argvi = 0;
 855     dXSARGS ;
 856
 857     cv = cv;
 858     if ((items < 1) || (items > 1))
 859         croak("Usage: icalcomponent_isa(component);");
 860     if (SWIG_GetPtr(ST(0),(void **) &_arg0,(char *) 0 )) {
 861         croak("Type error in argument 1 of icalcomponent_isa. Expected icalcomponentPtr.");
 862         XSRETURN(1);
 863     }
 864     _result = (icalcomponent_kind *) malloc(sizeof(icalcomponent_kind ));
 865     *(_result) = icalcomponent_isa(_arg0);
 866     ST(argvi) = sv_newmortal();
 867     sv_setref_pv(ST(argvi++),"icalcomponent_kindPtr", (void *) _result);
 868     XSRETURN(argvi);
 869 }
 870
 871 XS(_wrap_icalrestriction_check) {
 872
 873     int  _result;
 874     icalcomponent * _arg0;
 875     int argvi = 0;
 876     dXSARGS ;
 877
 878     cv = cv;
 879     if ((items < 1) || (items > 1))
 880         croak("Usage: icalrestriction_check(comp);");
 881     if (SWIG_GetPtr(ST(0),(void **) &_arg0,(char *) 0 )) {
 882         croak("Type error in argument 1 of icalrestriction_check. Expected icalcomponentPtr.");
 883         XSRETURN(1);
 884     }
 885     _result = (int )icalrestriction_check(_arg0);
 886     ST(argvi) = sv_newmortal();
 887     sv_setiv(ST(argvi++),(IV) _result);
 888     XSRETURN(argvi);
 889 }
 890
 891 XS(_wrap_icalproperty_string_to_kind) {
 892
 893     int  _result;
 894     char * _arg0;
 895     int argvi = 0;
 896     dXSARGS ;
 897
 898     cv = cv;
 899     if ((items < 1) || (items > 1))
 900         croak("Usage: icalproperty_string_to_kind(string);");
 901     _arg0 = (char *) SvPV(ST(0),na);
 902     _result = (int )icalproperty_string_to_kind(_arg0);
 903     ST(argvi) = sv_newmortal();
 904     sv_setiv(ST(argvi++),(IV) _result);
 905     XSRETURN(argvi);
 906 }
 907
 908 XS(_wrap_icalproperty_new) {
 909
 910     icalproperty * _result;
 911     int  _arg0;
 912     int argvi = 0;
 913     dXSARGS ;
 914
 915     cv = cv;
 916     if ((items < 1) || (items > 1))
 917         croak("Usage: icalproperty_new(kind);");
 918     _arg0 = (int )SvIV(ST(0));
 919     _result = (icalproperty *)icalproperty_new(_arg0);
 920     ST(argvi) = sv_newmortal();
 921     sv_setref_pv(ST(argvi++),"icalpropertyPtr", (void *) _result);
 922     XSRETURN(argvi);
 923 }
 924
 925 XS(_wrap_icalproperty_new_from_string) {
 926
 927     icalproperty * _result;
 928     char * _arg0;
 929     int argvi = 0;
 930     dXSARGS ;
 931
 932     cv = cv;
 933     if ((items < 1) || (items > 1))
 934         croak("Usage: icalproperty_new_from_string(str);");
 935     _arg0 = (char *) SvPV(ST(0),na);
 936     _result = (icalproperty *)icalproperty_new_from_string(_arg0);
 937     ST(argvi) = sv_newmortal();
 938     sv_setref_pv(ST(argvi++),"icalpropertyPtr", (void *) _result);
 939     XSRETURN(argvi);
 940 }
 941
 942 XS(_wrap_icalproperty_as_ical_string) {
 943
 944     char * _result;
 945     icalproperty * _arg0;
 946     int argvi = 0;
 947     dXSARGS ;
 948
 949     cv = cv;
 950     if ((items < 1) || (items > 1))
 951         croak("Usage: icalproperty_as_ical_string(prop);");
 952     if (SWIG_GetPtr(ST(0),(void **) &_arg0,(char *) 0 )) {
 953         croak("Type error in argument 1 of icalproperty_as_ical_string. Expected icalpropertyPtr.");
 954         XSRETURN(1);
 955     }
 956     _result = (char *)icalproperty_as_ical_string(_arg0);
 957     ST(argvi) = sv_newmortal();
 958     sv_setpv((SV*)ST(argvi++),(char *) _result);
 959     XSRETURN(argvi);
 960 }
 961
 962 XS(_wrap_icalproperty_set_parameter_from_string) {
 963
 964     icalproperty * _arg0;
 965     char * _arg1;
 966     char * _arg2;
 967     int argvi = 0;
 968     dXSARGS ;
 969
 970     cv = cv;
 971     if ((items < 3) || (items > 3))
 972         croak("Usage: icalproperty_set_parameter_from_string(prop,name,value);");
 973     if (SWIG_GetPtr(ST(0),(void **) &_arg0,(char *) 0 )) {
 974         croak("Type error in argument 1 of icalproperty_set_parameter_from_string. Expected icalpropertyPtr.");
 975         XSRETURN(1);
 976     }
 977     _arg1 = (char *) SvPV(ST(1),na);
 978     _arg2 = (char *) SvPV(ST(2),na);
 979     icalproperty_set_parameter_from_string(_arg0,_arg1,_arg2);
 980     XSRETURN(argvi);
 981 }
 982
 983 XS(_wrap_icalproperty_set_value_from_string) {
 984
 985     icalproperty * _arg0;
 986     char * _arg1;
 987     char * _arg2;
 988     int argvi = 0;
 989     dXSARGS ;
 990
 991     cv = cv;
 992     if ((items < 3) || (items > 3))
 993         croak("Usage: icalproperty_set_value_from_string(prop,value,kind);");
 994     if (SWIG_GetPtr(ST(0),(void **) &_arg0,(char *) 0 )) {
 995         croak("Type error in argument 1 of icalproperty_set_value_from_string. Expected icalpropertyPtr.");
 996         XSRETURN(1);
 997     }
 998     _arg1 = (char *) SvPV(ST(1),na);
 999     _arg2 = (char *) SvPV(ST(2),na);
1000     icalproperty_set_value_from_string(_arg0,_arg1,_arg2);
1001     XSRETURN(argvi);
1002 }
1003
1004 XS(_wrap_icalproperty_get_value_as_string) {
1005
1006     char * _result;
1007     icalproperty * _arg0;
1008     int argvi = 0;
1009     dXSARGS ;
1010
1011     cv = cv;
1012     if ((items < 1) || (items > 1))
1013         croak("Usage: icalproperty_get_value_as_string(prop);");
1014     if (SWIG_GetPtr(ST(0),(void **) &_arg0,(char *) 0 )) {
1015         croak("Type error in argument 1 of icalproperty_get_value_as_string. Expected icalpropertyPtr.");
1016         XSRETURN(1);
1017     }
1018     _result = (char *)icalproperty_get_value_as_string(_arg0);
1019     ST(argvi) = sv_newmortal();
1020     sv_setpv((SV*)ST(argvi++),(char *) _result);
1021     XSRETURN(argvi);
1022 }
1023
1024 XS(_wrap_icalproperty_get_parameter_as_string) {
1025
1026     char * _result;
1027     icalproperty * _arg0;
1028     char * _arg1;
1029     int argvi = 0;
1030     dXSARGS ;
1031
1032     cv = cv;
1033     if ((items < 2) || (items > 2))
1034         croak("Usage: icalproperty_get_parameter_as_string(prop,name);");
1035     if (SWIG_GetPtr(ST(0),(void **) &_arg0,(char *) 0 )) {
1036         croak("Type error in argument 1 of icalproperty_get_parameter_as_string. Expected icalpropertyPtr.");
1037         XSRETURN(1);
1038     }
1039     _arg1 = (char *) SvPV(ST(1),na);
1040     _result = (char *)icalproperty_get_parameter_as_string(_arg0,_arg1);
1041     ST(argvi) = sv_newmortal();
1042     sv_setpv((SV*)ST(argvi++),(char *) _result);
1043     XSRETURN(argvi);
1044 }
1045
1046 XS(_wrap_icalproperty_get_parent) {
1047
1048     icalcomponent * _result;
1049     icalproperty * _arg0;
1050     int argvi = 0;
1051     dXSARGS ;
1052
1053     cv = cv;
1054     if ((items < 1) || (items > 1))
1055         croak("Usage: icalproperty_get_parent(property);");
1056     if (SWIG_GetPtr(ST(0),(void **) &_arg0,(char *) 0 )) {
1057         croak("Type error in argument 1 of icalproperty_get_parent. Expected icalpropertyPtr.");
1058         XSRETURN(1);
1059     }
1060     _result = (icalcomponent *)icalproperty_get_parent(_arg0);
1061     ST(argvi) = sv_newmortal();
1062     sv_setref_pv(ST(argvi++),"icalcomponentPtr", (void *) _result);
1063     XSRETURN(argvi);
1064 }
1065
1066 XS(_wrap_icalerror_set_error_state) {
1067
1068     icalerrorenum  _arg0;
1069     icalerrorstate  _arg1;
1070     int argvi = 0;
1071     dXSARGS ;
1072
1073     cv = cv;
1074     if ((items < 2) || (items > 2))
1075         croak("Usage: icalerror_set_error_state(error,icalerrorstate );");
1076     _arg0 = (icalerrorenum )SvIV(ST(0));
1077     _arg1 = (icalerrorstate )SvIV(ST(1));
1078     icalerror_set_error_state(_arg0,_arg1);
1079     XSRETURN(argvi);
1080 }
1081
1082 XS(_wrap_icalerror_get_error_state) {
1083
1084     icalerrorstate  _result;
1085     icalerrorenum  _arg0;
1086     int argvi = 0;
1087     dXSARGS ;
1088
1089     cv = cv;
1090     if ((items < 1) || (items > 1))
1091         croak("Usage: icalerror_get_error_state(error);");
1092     _arg0 = (icalerrorenum )SvIV(ST(0));
1093     _result = (icalerrorstate )icalerror_get_error_state(_arg0);
1094     ST(argvi) = sv_newmortal();
1095     sv_setiv(ST(argvi++),(IV) _result);
1096     XSRETURN(argvi);
1097 }
1098
1099 XS(_wrap_icalenum_property_kind_to_string) {
1100
1101     char * _result;
1102     icalproperty_kind * _arg0;
1103     int argvi = 0;
1104     dXSARGS ;
1105
1106     cv = cv;
1107     if ((items < 1) || (items > 1))
1108         croak("Usage: icalenum_property_kind_to_string(kind);");
1109     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"icalproperty_kindPtr")) {
1110         croak("Type error in argument 1 of icalenum_property_kind_to_string. Expected icalproperty_kindPtr.");
1111         XSRETURN(1);
1112     }
1113     _result = (char *)icalenum_property_kind_to_string(*_arg0);
1114     ST(argvi) = sv_newmortal();
1115     sv_setpv((SV*)ST(argvi++),(char *) _result);
1116     XSRETURN(argvi);
1117 }
1118
1119 XS(_wrap_icalenum_string_to_property_kind) {
1120
1121     icalproperty_kind * _result;
1122     char * _arg0;
1123     int argvi = 0;
1124     dXSARGS ;
1125
1126     cv = cv;
1127     if ((items < 1) || (items > 1))
1128         croak("Usage: icalenum_string_to_property_kind(string);");
1129     _arg0 = (char *) SvPV(ST(0),na);
1130     _result = (icalproperty_kind *) malloc(sizeof(icalproperty_kind ));
1131     *(_result) = icalenum_string_to_property_kind(_arg0);
1132     ST(argvi) = sv_newmortal();
1133     sv_setref_pv(ST(argvi++),"icalproperty_kindPtr", (void *) _result);
1134     XSRETURN(argvi);
1135 }
1136
1137 XS(_wrap_icalenum_value_kind_to_string) {
1138
1139     char * _result;
1140     icalvalue_kind * _arg0;
1141     int argvi = 0;
1142     dXSARGS ;
1143
1144     cv = cv;
1145     if ((items < 1) || (items > 1))
1146         croak("Usage: icalenum_value_kind_to_string(kind);");
1147     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"icalvalue_kindPtr")) {
1148         croak("Type error in argument 1 of icalenum_value_kind_to_string. Expected icalvalue_kindPtr.");
1149         XSRETURN(1);
1150     }
1151     _result = (char *)icalenum_value_kind_to_string(*_arg0);
1152     ST(argvi) = sv_newmortal();
1153     sv_setpv((SV*)ST(argvi++),(char *) _result);
1154     XSRETURN(argvi);
1155 }
1156
1157 XS(_wrap_icalenum_parameter_kind_to_string) {
1158
1159     char * _result;
1160     icalparameter_kind * _arg0;
1161     int argvi = 0;
1162     dXSARGS ;
1163
1164     cv = cv;
1165     if ((items < 1) || (items > 1))
1166         croak("Usage: icalenum_parameter_kind_to_string(kind);");
1167     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"icalparameter_kindPtr")) {
1168         croak("Type error in argument 1 of icalenum_parameter_kind_to_string. Expected icalparameter_kindPtr.");
1169         XSRETURN(1);
1170     }
1171     _result = (char *)icalenum_parameter_kind_to_string(*_arg0);
1172     ST(argvi) = sv_newmortal();
1173     sv_setpv((SV*)ST(argvi++),(char *) _result);
1174     XSRETURN(argvi);
1175 }
1176
1177 XS(_wrap_icalenum_string_to_parameter_kind) {
1178
1179     icalparameter_kind * _result;
1180     char * _arg0;
1181     int argvi = 0;
1182     dXSARGS ;
1183
1184     cv = cv;
1185     if ((items < 1) || (items > 1))
1186         croak("Usage: icalenum_string_to_parameter_kind(string);");
1187     _arg0 = (char *) SvPV(ST(0),na);
1188     _result = (icalparameter_kind *) malloc(sizeof(icalparameter_kind ));
1189     *(_result) = icalenum_string_to_parameter_kind(_arg0);
1190     ST(argvi) = sv_newmortal();
1191     sv_setref_pv(ST(argvi++),"icalparameter_kindPtr", (void *) _result);
1192     XSRETURN(argvi);
1193 }
1194
1195 XS(_wrap_icalenum_component_kind_to_string) {
1196
1197     char * _result;
1198     icalcomponent_kind * _arg0;
1199     int argvi = 0;
1200     dXSARGS ;
1201
1202     cv = cv;
1203     if ((items < 1) || (items > 1))
1204         croak("Usage: icalenum_component_kind_to_string(kind);");
1205     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"icalcomponent_kindPtr")) {
1206         croak("Type error in argument 1 of icalenum_component_kind_to_string. Expected icalcomponent_kindPtr.");
1207         XSRETURN(1);
1208     }
1209     _result = (char *)icalenum_component_kind_to_string(*_arg0);
1210     ST(argvi) = sv_newmortal();
1211     sv_setpv((SV*)ST(argvi++),(char *) _result);
1212     XSRETURN(argvi);
1213 }
1214
1215 XS(_wrap_icalenum_string_to_component_kind) {
1216
1217     icalcomponent_kind * _result;
1218     char * _arg0;
1219     int argvi = 0;
1220     dXSARGS ;
1221
1222     cv = cv;
1223     if ((items < 1) || (items > 1))
1224         croak("Usage: icalenum_string_to_component_kind(string);");
1225     _arg0 = (char *) SvPV(ST(0),na);
1226     _result = (icalcomponent_kind *) malloc(sizeof(icalcomponent_kind ));
1227     *(_result) = icalenum_string_to_component_kind(_arg0);
1228     ST(argvi) = sv_newmortal();
1229     sv_setref_pv(ST(argvi++),"icalcomponent_kindPtr", (void *) _result);
1230     XSRETURN(argvi);
1231 }
1232
1233 XS(_wrap_icalenum_property_kind_to_value_kind) {
1234
1235     icalvalue_kind * _result;
1236     icalproperty_kind * _arg0;
1237     int argvi = 0;
1238     dXSARGS ;
1239
1240     cv = cv;
1241     if ((items < 1) || (items > 1))
1242         croak("Usage: icalenum_property_kind_to_value_kind(kind);");
1243     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"icalproperty_kindPtr")) {
1244         croak("Type error in argument 1 of icalenum_property_kind_to_value_kind. Expected icalproperty_kindPtr.");
1245         XSRETURN(1);
1246     }
1247     _result = (icalvalue_kind *) malloc(sizeof(icalvalue_kind ));
1248     *(_result) = icalenum_property_kind_to_value_kind(*_arg0);
1249     ST(argvi) = sv_newmortal();
1250     sv_setref_pv(ST(argvi++),"icalvalue_kindPtr", (void *) _result);
1251     XSRETURN(argvi);
1252 }
1253
1254 XS(_wrap_icallangbind_new_array) {
1255
1256     int * _result;
1257     int  _arg0;
1258     int argvi = 0;
1259     dXSARGS ;
1260
1261     cv = cv;
1262     if ((items < 1) || (items > 1))
1263         croak("Usage: icallangbind_new_array(size);");
1264     _arg0 = (int )SvIV(ST(0));
1265     _result = (int *)icallangbind_new_array(_arg0);
1266     ST(argvi) = sv_newmortal();
1267     sv_setref_pv(ST(argvi++),"intPtr", (void *) _result);
1268     XSRETURN(argvi);
1269 }
1270
1271 XS(_wrap_icallangbind_free_array) {
1272
1273     int * _arg0;
1274     int argvi = 0;
1275     dXSARGS ;
1276
1277     cv = cv;
1278     if ((items < 1) || (items > 1))
1279         croak("Usage: icallangbind_free_array(array);");
1280     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"intPtr")) {
1281         croak("Type error in argument 1 of icallangbind_free_array. Expected intPtr.");
1282         XSRETURN(1);
1283     }
1284     icallangbind_free_array(_arg0);
1285     XSRETURN(argvi);
1286 }
1287
1288 XS(_wrap_icallangbind_access_array) {
1289
1290     int  _result;
1291     int * _arg0;
1292     int  _arg1;
1293     int argvi = 0;
1294     dXSARGS ;
1295
1296     cv = cv;
1297     if ((items < 2) || (items > 2))
1298         croak("Usage: icallangbind_access_array(array,index);");
1299     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"intPtr")) {
1300         croak("Type error in argument 1 of icallangbind_access_array. Expected intPtr.");
1301         XSRETURN(1);
1302     }
1303     _arg1 = (int )SvIV(ST(1));
1304     _result = (int )icallangbind_access_array(_arg0,_arg1);
1305     ST(argvi) = sv_newmortal();
1306     sv_setiv(ST(argvi++),(IV) _result);
1307     XSRETURN(argvi);
1308 }
1309
1310 XS(_wrap_icalrecur_expand_recurrence) {
1311
1312     int  _result;
1313     char * _arg0;
1314     int  _arg1;
1315     int  _arg2;
1316     int * _arg3;
1317     int argvi = 0;
1318     dXSARGS ;
1319
1320     cv = cv;
1321     if ((items < 4) || (items > 4))
1322         croak("Usage: icalrecur_expand_recurrence(rule,start,count,array);");
1323     _arg0 = (char *) SvPV(ST(0),na);
1324     _arg1 = (int )SvIV(ST(1));
1325     _arg2 = (int )SvIV(ST(2));
1326     if (SWIG_GetPtr(ST(3),(void **) &_arg3,"intPtr")) {
1327         croak("Type error in argument 4 of icalrecur_expand_recurrence. Expected intPtr.");
1328         XSRETURN(1);
1329     }
1330     _result = (int )icalrecur_expand_recurrence(_arg0,_arg1,_arg2,_arg3);
1331     ST(argvi) = sv_newmortal();
1332     sv_setiv(ST(argvi++),(IV) _result);
1333     XSRETURN(argvi);
1334 }
1335
1336 XS(_wrap_icallangbind_get_first_property) {
1337
1338     icalproperty * _result;
1339     icalcomponent * _arg0;
1340     char * _arg1;
1341     int argvi = 0;
1342     dXSARGS ;
1343
1344     cv = cv;
1345     if ((items < 2) || (items > 2))
1346         croak("Usage: icallangbind_get_first_property(c,prop);");
1347     if (SWIG_GetPtr(ST(0),(void **) &_arg0,(char *) 0 )) {
1348         croak("Type error in argument 1 of icallangbind_get_first_property. Expected icalcomponentPtr.");
1349         XSRETURN(1);
1350     }
1351     _arg1 = (char *) SvPV(ST(1),na);
1352     _result = (icalproperty *)icallangbind_get_first_property(_arg0,_arg1);
1353     ST(argvi) = sv_newmortal();
1354     sv_setref_pv(ST(argvi++),"icalpropertyPtr", (void *) _result);
1355     XSRETURN(argvi);
1356 }
1357
1358 XS(_wrap_icallangbind_get_next_property) {
1359
1360     icalproperty * _result;
1361     icalcomponent * _arg0;
1362     char * _arg1;
1363     int argvi = 0;
1364     dXSARGS ;
1365
1366     cv = cv;
1367     if ((items < 2) || (items > 2))
1368         croak("Usage: icallangbind_get_next_property(c,prop);");
1369     if (SWIG_GetPtr(ST(0),(void **) &_arg0,(char *) 0 )) {
1370         croak("Type error in argument 1 of icallangbind_get_next_property. Expected icalcomponentPtr.");
1371         XSRETURN(1);
1372     }
1373     _arg1 = (char *) SvPV(ST(1),na);
1374     _result = (icalproperty *)icallangbind_get_next_property(_arg0,_arg1);
1375     ST(argvi) = sv_newmortal();
1376     sv_setref_pv(ST(argvi++),"icalpropertyPtr", (void *) _result);
1377     XSRETURN(argvi);
1378 }
1379
1380 XS(_wrap_icallangbind_get_first_component) {
1381
1382     icalcomponent * _result;
1383     icalcomponent * _arg0;
1384     char * _arg1;
1385     int argvi = 0;
1386     dXSARGS ;
1387
1388     cv = cv;
1389     if ((items < 2) || (items > 2))
1390         croak("Usage: icallangbind_get_first_component(c,comp);");
1391     if (SWIG_GetPtr(ST(0),(void **) &_arg0,(char *) 0 )) {
1392         croak("Type error in argument 1 of icallangbind_get_first_component. Expected icalcomponentPtr.");
1393         XSRETURN(1);
1394     }
1395     _arg1 = (char *) SvPV(ST(1),na);
1396     _result = (icalcomponent *)icallangbind_get_first_component(_arg0,_arg1);
1397     ST(argvi) = sv_newmortal();
1398     sv_setref_pv(ST(argvi++),"icalcomponentPtr", (void *) _result);
1399     XSRETURN(argvi);
1400 }
1401
1402 XS(_wrap_icallangbind_get_next_component) {
1403
1404     icalcomponent * _result;
1405     icalcomponent * _arg0;
1406     char * _arg1;
1407     int argvi = 0;
1408     dXSARGS ;
1409
1410     cv = cv;
1411     if ((items < 2) || (items > 2))
1412         croak("Usage: icallangbind_get_next_component(c,comp);");
1413     if (SWIG_GetPtr(ST(0),(void **) &_arg0,(char *) 0 )) {
1414         croak("Type error in argument 1 of icallangbind_get_next_component. Expected icalcomponentPtr.");
1415         XSRETURN(1);
1416     }
1417     _arg1 = (char *) SvPV(ST(1),na);
1418     _result = (icalcomponent *)icallangbind_get_next_component(_arg0,_arg1);
1419     ST(argvi) = sv_newmortal();
1420     sv_setref_pv(ST(argvi++),"icalcomponentPtr", (void *) _result);
1421     XSRETURN(argvi);
1422 }
1423
1424 XS(_wrap_icallangbind_property_eval_string) {
1425
1426     char * _result;
1427     icalproperty * _arg0;
1428     char * _arg1;
1429     int argvi = 0;
1430     dXSARGS ;
1431
1432     cv = cv;
1433     if ((items < 2) || (items > 2))
1434         croak("Usage: icallangbind_property_eval_string(prop,sep);");
1435     if (SWIG_GetPtr(ST(0),(void **) &_arg0,(char *) 0 )) {
1436         croak("Type error in argument 1 of icallangbind_property_eval_string. Expected icalpropertyPtr.");
1437         XSRETURN(1);
1438     }
1439     _arg1 = (char *) SvPV(ST(1),na);
1440     _result = (char *)icallangbind_property_eval_string(_arg0,_arg1);
1441     ST(argvi) = sv_newmortal();
1442     sv_setpv((SV*)ST(argvi++),(char *) _result);
1443     XSRETURN(argvi);
1444 }
1445
1446 XS(_wrap_icaltime_from_timet) {
1447
1448     struct icaltimetype * _result;
1449     int  _arg0;
1450     int  _arg1;
1451     int argvi = 0;
1452     dXSARGS ;
1453
1454     cv = cv;
1455     if ((items < 2) || (items > 2))
1456         croak("Usage: icaltime_from_timet(v,is_date);");
1457     _arg0 = (int )SvIV(ST(0));
1458     _arg1 = (int )SvIV(ST(1));
1459     _result = (struct icaltimetype *) malloc(sizeof(struct icaltimetype ));
1460     *(_result) = icaltime_from_timet(_arg0,_arg1);
1461     ST(argvi) = sv_newmortal();
1462     sv_setref_pv(ST(argvi++),"struct icaltimetypePtr", (void *) _result);
1463     XSRETURN(argvi);
1464 }
1465
1466 XS(_wrap_icaltime_as_timet) {
1467
1468     int  _result;
1469     struct icaltimetype * _arg0;
1470     int argvi = 0;
1471     dXSARGS ;
1472
1473     cv = cv;
1474     if ((items < 1) || (items > 1))
1475         croak("Usage: icaltime_as_timet(struct icaltimetype *);");
1476     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaltimetypePtr")) {
1477         croak("Type error in argument 1 of icaltime_as_timet. Expected struct icaltimetypePtr.");
1478         XSRETURN(1);
1479     }
1480     _result = (int )icaltime_as_timet(*_arg0);
1481     ST(argvi) = sv_newmortal();
1482     sv_setiv(ST(argvi++),(IV) _result);
1483     XSRETURN(argvi);
1484 }
1485
1486 XS(_wrap_icaltime_as_ical_string) {
1487
1488     char * _result;
1489     struct icaltimetype * _arg0;
1490     int argvi = 0;
1491     dXSARGS ;
1492
1493     cv = cv;
1494     if ((items < 1) || (items > 1))
1495         croak("Usage: icaltime_as_ical_string(tt);");
1496     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaltimetypePtr")) {
1497         croak("Type error in argument 1 of icaltime_as_ical_string. Expected struct icaltimetypePtr.");
1498         XSRETURN(1);
1499     }
1500     _result = (char *)icaltime_as_ical_string(*_arg0);
1501     ST(argvi) = sv_newmortal();
1502     sv_setpv((SV*)ST(argvi++),(char *) _result);
1503     XSRETURN(argvi);
1504 }
1505
1506 XS(_wrap_icaltime_from_string) {
1507
1508     struct icaltimetype * _result;
1509     char * _arg0;
1510     int argvi = 0;
1511     dXSARGS ;
1512
1513     cv = cv;
1514     if ((items < 1) || (items > 1))
1515         croak("Usage: icaltime_from_string(str);");
1516     _arg0 = (char *) SvPV(ST(0),na);
1517     _result = (struct icaltimetype *) malloc(sizeof(struct icaltimetype ));
1518     *(_result) = icaltime_from_string(_arg0);
1519     ST(argvi) = sv_newmortal();
1520     sv_setref_pv(ST(argvi++),"struct icaltimetypePtr", (void *) _result);
1521     XSRETURN(argvi);
1522 }
1523
1524 XS(_wrap_icaltime_utc_offset) {
1525
1526     int  _result;
1527     struct icaltimetype * _arg0;
1528     char * _arg1;
1529     int argvi = 0;
1530     dXSARGS ;
1531
1532     cv = cv;
1533     if ((items < 2) || (items > 2))
1534         croak("Usage: icaltime_utc_offset(tt,tzid);");
1535     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaltimetypePtr")) {
1536         croak("Type error in argument 1 of icaltime_utc_offset. Expected struct icaltimetypePtr.");
1537         XSRETURN(1);
1538     }
1539     _arg1 = (char *) SvPV(ST(1),na);
1540     _result = (int )icaltime_utc_offset(*_arg0,_arg1);
1541     ST(argvi) = sv_newmortal();
1542     sv_setiv(ST(argvi++),(IV) _result);
1543     XSRETURN(argvi);
1544 }
1545
1546 XS(_wrap_icaltime_as_utc) {
1547
1548     struct icaltimetype * _result;
1549     struct icaltimetype * _arg0;
1550     char * _arg1;
1551     int argvi = 0;
1552     dXSARGS ;
1553
1554     cv = cv;
1555     if ((items < 2) || (items > 2))
1556         croak("Usage: icaltime_as_utc(tt,tzid);");
1557     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaltimetypePtr")) {
1558         croak("Type error in argument 1 of icaltime_as_utc. Expected struct icaltimetypePtr.");
1559         XSRETURN(1);
1560     }
1561     _arg1 = (char *) SvPV(ST(1),na);
1562     _result = (struct icaltimetype *) malloc(sizeof(struct icaltimetype ));
1563     *(_result) = icaltime_as_utc(*_arg0,_arg1);
1564     ST(argvi) = sv_newmortal();
1565     sv_setref_pv(ST(argvi++),"struct icaltimetypePtr", (void *) _result);
1566     XSRETURN(argvi);
1567 }
1568
1569 XS(_wrap_icaltime_as_zone) {
1570
1571     struct icaltimetype * _result;
1572     struct icaltimetype * _arg0;
1573     char * _arg1;
1574     int argvi = 0;
1575     dXSARGS ;
1576
1577     cv = cv;
1578     if ((items < 2) || (items > 2))
1579         croak("Usage: icaltime_as_zone(tt,tzid);");
1580     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaltimetypePtr")) {
1581         croak("Type error in argument 1 of icaltime_as_zone. Expected struct icaltimetypePtr.");
1582         XSRETURN(1);
1583     }
1584     _arg1 = (char *) SvPV(ST(1),na);
1585     _result = (struct icaltimetype *) malloc(sizeof(struct icaltimetype ));
1586     *(_result) = icaltime_as_zone(*_arg0,_arg1);
1587     ST(argvi) = sv_newmortal();
1588     sv_setref_pv(ST(argvi++),"struct icaltimetypePtr", (void *) _result);
1589     XSRETURN(argvi);
1590 }
1591
1592 XS(_wrap_icaltime_null_time) {
1593
1594     struct icaltimetype * _result;
1595     int argvi = 0;
1596     dXSARGS ;
1597
1598     cv = cv;
1599     if ((items < 0) || (items > 0))
1600         croak("Usage: icaltime_null_time();");
1601     _result = (struct icaltimetype *) malloc(sizeof(struct icaltimetype ));
1602     *(_result) = icaltime_null_time();
1603     ST(argvi) = sv_newmortal();
1604     sv_setref_pv(ST(argvi++),"struct icaltimetypePtr", (void *) _result);
1605     XSRETURN(argvi);
1606 }
1607
1608 XS(_wrap_icaltime_is_null_time) {
1609
1610     int  _result;
1611     struct icaltimetype * _arg0;
1612     int argvi = 0;
1613     dXSARGS ;
1614
1615     cv = cv;
1616     if ((items < 1) || (items > 1))
1617         croak("Usage: icaltime_is_null_time(t);");
1618     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaltimetypePtr")) {
1619         croak("Type error in argument 1 of icaltime_is_null_time. Expected struct icaltimetypePtr.");
1620         XSRETURN(1);
1621     }
1622     _result = (int )icaltime_is_null_time(*_arg0);
1623     ST(argvi) = sv_newmortal();
1624     sv_setiv(ST(argvi++),(IV) _result);
1625     XSRETURN(argvi);
1626 }
1627
1628 XS(_wrap_icaltime_is_valid_time) {
1629
1630     int  _result;
1631     struct icaltimetype * _arg0;
1632     int argvi = 0;
1633     dXSARGS ;
1634
1635     cv = cv;
1636     if ((items < 1) || (items > 1))
1637         croak("Usage: icaltime_is_valid_time(t);");
1638     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaltimetypePtr")) {
1639         croak("Type error in argument 1 of icaltime_is_valid_time. Expected struct icaltimetypePtr.");
1640         XSRETURN(1);
1641     }
1642     _result = (int )icaltime_is_valid_time(*_arg0);
1643     ST(argvi) = sv_newmortal();
1644     sv_setiv(ST(argvi++),(IV) _result);
1645     XSRETURN(argvi);
1646 }
1647
1648 XS(_wrap_icaltime_normalize) {
1649
1650     struct icaltimetype * _result;
1651     struct icaltimetype * _arg0;
1652     int argvi = 0;
1653     dXSARGS ;
1654
1655     cv = cv;
1656     if ((items < 1) || (items > 1))
1657         croak("Usage: icaltime_normalize(t);");
1658     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaltimetypePtr")) {
1659         croak("Type error in argument 1 of icaltime_normalize. Expected struct icaltimetypePtr.");
1660         XSRETURN(1);
1661     }
1662     _result = (struct icaltimetype *) malloc(sizeof(struct icaltimetype ));
1663     *(_result) = icaltime_normalize(*_arg0);
1664     ST(argvi) = sv_newmortal();
1665     sv_setref_pv(ST(argvi++),"struct icaltimetypePtr", (void *) _result);
1666     XSRETURN(argvi);
1667 }
1668
1669 XS(_wrap_icaltime_day_of_year) {
1670
1671     short  _result;
1672     struct icaltimetype * _arg0;
1673     int argvi = 0;
1674     dXSARGS ;
1675
1676     cv = cv;
1677     if ((items < 1) || (items > 1))
1678         croak("Usage: icaltime_day_of_year(t);");
1679     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaltimetypePtr")) {
1680         croak("Type error in argument 1 of icaltime_day_of_year. Expected struct icaltimetypePtr.");
1681         XSRETURN(1);
1682     }
1683     _result = (short )icaltime_day_of_year(*_arg0);
1684     ST(argvi) = sv_newmortal();
1685     sv_setiv(ST(argvi++),(IV) _result);
1686     XSRETURN(argvi);
1687 }
1688
1689 XS(_wrap_icaltime_from_day_of_year) {
1690
1691     struct icaltimetype * _result;
1692     short  _arg0;
1693     short  _arg1;
1694     int argvi = 0;
1695     dXSARGS ;
1696
1697     cv = cv;
1698     if ((items < 2) || (items > 2))
1699         croak("Usage: icaltime_from_day_of_year(doy,year);");
1700     _arg0 = (short )SvIV(ST(0));
1701     _arg1 = (short )SvIV(ST(1));
1702     _result = (struct icaltimetype *) malloc(sizeof(struct icaltimetype ));
1703     *(_result) = icaltime_from_day_of_year(_arg0,_arg1);
1704     ST(argvi) = sv_newmortal();
1705     sv_setref_pv(ST(argvi++),"struct icaltimetypePtr", (void *) _result);
1706     XSRETURN(argvi);
1707 }
1708
1709 XS(_wrap_icaltime_day_of_week) {
1710
1711     short  _result;
1712     struct icaltimetype * _arg0;
1713     int argvi = 0;
1714     dXSARGS ;
1715
1716     cv = cv;
1717     if ((items < 1) || (items > 1))
1718         croak("Usage: icaltime_day_of_week(t);");
1719     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaltimetypePtr")) {
1720         croak("Type error in argument 1 of icaltime_day_of_week. Expected struct icaltimetypePtr.");
1721         XSRETURN(1);
1722     }
1723     _result = (short )icaltime_day_of_week(*_arg0);
1724     ST(argvi) = sv_newmortal();
1725     sv_setiv(ST(argvi++),(IV) _result);
1726     XSRETURN(argvi);
1727 }
1728
1729 XS(_wrap_icaltime_start_doy_of_week) {
1730
1731     short  _result;
1732     struct icaltimetype * _arg0;
1733     int argvi = 0;
1734     dXSARGS ;
1735
1736     cv = cv;
1737     if ((items < 1) || (items > 1))
1738         croak("Usage: icaltime_start_doy_of_week(t);");
1739     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaltimetypePtr")) {
1740         croak("Type error in argument 1 of icaltime_start_doy_of_week. Expected struct icaltimetypePtr.");
1741         XSRETURN(1);
1742     }
1743     _result = (short )icaltime_start_doy_of_week(*_arg0);
1744     ST(argvi) = sv_newmortal();
1745     sv_setiv(ST(argvi++),(IV) _result);
1746     XSRETURN(argvi);
1747 }
1748
1749 XS(_wrap_icaltime_as_ctime) {
1750
1751     char * _result;
1752     struct icaltimetype * _arg0;
1753     int argvi = 0;
1754     dXSARGS ;
1755
1756     cv = cv;
1757     if ((items < 1) || (items > 1))
1758         croak("Usage: icaltime_as_ctime(struct icaltimetype *);");
1759     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaltimetypePtr")) {
1760         croak("Type error in argument 1 of icaltime_as_ctime. Expected struct icaltimetypePtr.");
1761         XSRETURN(1);
1762     }
1763     _result = (char *)icaltime_as_ctime(*_arg0);
1764     ST(argvi) = sv_newmortal();
1765     sv_setpv((SV*)ST(argvi++),(char *) _result);
1766     XSRETURN(argvi);
1767 }
1768
1769 XS(_wrap_icaltime_week_number) {
1770
1771     short  _result;
1772     struct icaltimetype * _arg0;
1773     int argvi = 0;
1774     dXSARGS ;
1775
1776     cv = cv;
1777     if ((items < 1) || (items > 1))
1778         croak("Usage: icaltime_week_number(t);");
1779     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaltimetypePtr")) {
1780         croak("Type error in argument 1 of icaltime_week_number. Expected struct icaltimetypePtr.");
1781         XSRETURN(1);
1782     }
1783     _result = (short )icaltime_week_number(*_arg0);
1784     ST(argvi) = sv_newmortal();
1785     sv_setiv(ST(argvi++),(IV) _result);
1786     XSRETURN(argvi);
1787 }
1788
1789 XS(_wrap_icaltime_compare) {
1790
1791     int  _result;
1792     struct icaltimetype * _arg0;
1793     struct icaltimetype * _arg1;
1794     int argvi = 0;
1795     dXSARGS ;
1796
1797     cv = cv;
1798     if ((items < 2) || (items > 2))
1799         croak("Usage: icaltime_compare(a,b);");
1800     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaltimetypePtr")) {
1801         croak("Type error in argument 1 of icaltime_compare. Expected struct icaltimetypePtr.");
1802         XSRETURN(1);
1803     }
1804     if (SWIG_GetPtr(ST(1),(void **) &_arg1,"struct icaltimetypePtr")) {
1805         croak("Type error in argument 2 of icaltime_compare. Expected struct icaltimetypePtr.");
1806         XSRETURN(1);
1807     }
1808     _result = (int )icaltime_compare(*_arg0,*_arg1);
1809     ST(argvi) = sv_newmortal();
1810     sv_setiv(ST(argvi++),(IV) _result);
1811     XSRETURN(argvi);
1812 }
1813
1814 XS(_wrap_icaltime_compare_date_only) {
1815
1816     int  _result;
1817     struct icaltimetype * _arg0;
1818     struct icaltimetype * _arg1;
1819     int argvi = 0;
1820     dXSARGS ;
1821
1822     cv = cv;
1823     if ((items < 2) || (items > 2))
1824         croak("Usage: icaltime_compare_date_only(a,b);");
1825     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaltimetypePtr")) {
1826         croak("Type error in argument 1 of icaltime_compare_date_only. Expected struct icaltimetypePtr.");
1827         XSRETURN(1);
1828     }
1829     if (SWIG_GetPtr(ST(1),(void **) &_arg1,"struct icaltimetypePtr")) {
1830         croak("Type error in argument 2 of icaltime_compare_date_only. Expected struct icaltimetypePtr.");
1831         XSRETURN(1);
1832     }
1833     _result = (int )icaltime_compare_date_only(*_arg0,*_arg1);
1834     ST(argvi) = sv_newmortal();
1835     sv_setiv(ST(argvi++),(IV) _result);
1836     XSRETURN(argvi);
1837 }
1838
1839 XS(_wrap_icaltime_days_in_month) {
1840
1841     short  _result;
1842     short  _arg0;
1843     short  _arg1;
1844     int argvi = 0;
1845     dXSARGS ;
1846
1847     cv = cv;
1848     if ((items < 2) || (items > 2))
1849         croak("Usage: icaltime_days_in_month(month,year);");
1850     _arg0 = (short )SvIV(ST(0));
1851     _arg1 = (short )SvIV(ST(1));
1852     _result = (short )icaltime_days_in_month(_arg0,_arg1);
1853     ST(argvi) = sv_newmortal();
1854     sv_setiv(ST(argvi++),(IV) _result);
1855     XSRETURN(argvi);
1856 }
1857
1858 XS(_wrap_icaldurationtype_from_int) {
1859
1860     struct icaldurationtype * _result;
1861     int  _arg0;
1862     int argvi = 0;
1863     dXSARGS ;
1864
1865     cv = cv;
1866     if ((items < 1) || (items > 1))
1867         croak("Usage: icaldurationtype_from_int(t);");
1868     _arg0 = (int )SvIV(ST(0));
1869     _result = (struct icaldurationtype *) malloc(sizeof(struct icaldurationtype ));
1870     *(_result) = icaldurationtype_from_int(_arg0);
1871     ST(argvi) = sv_newmortal();
1872     sv_setref_pv(ST(argvi++),"struct icaldurationtypePtr", (void *) _result);
1873     XSRETURN(argvi);
1874 }
1875
1876 XS(_wrap_icaldurationtype_from_string) {
1877
1878     struct icaldurationtype * _result;
1879     char * _arg0;
1880     int argvi = 0;
1881     dXSARGS ;
1882
1883     cv = cv;
1884     if ((items < 1) || (items > 1))
1885         croak("Usage: icaldurationtype_from_string(char *);");
1886     _arg0 = (char *) SvPV(ST(0),na);
1887     _result = (struct icaldurationtype *) malloc(sizeof(struct icaldurationtype ));
1888     *(_result) = icaldurationtype_from_string(_arg0);
1889     ST(argvi) = sv_newmortal();
1890     sv_setref_pv(ST(argvi++),"struct icaldurationtypePtr", (void *) _result);
1891     XSRETURN(argvi);
1892 }
1893
1894 XS(_wrap_icaldurationtype_as_int) {
1895
1896     int  _result;
1897     struct icaldurationtype * _arg0;
1898     int argvi = 0;
1899     dXSARGS ;
1900
1901     cv = cv;
1902     if ((items < 1) || (items > 1))
1903         croak("Usage: icaldurationtype_as_int(duration);");
1904     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaldurationtypePtr")) {
1905         croak("Type error in argument 1 of icaldurationtype_as_int. Expected struct icaldurationtypePtr.");
1906         XSRETURN(1);
1907     }
1908     _result = (int )icaldurationtype_as_int(*_arg0);
1909     ST(argvi) = sv_newmortal();
1910     sv_setiv(ST(argvi++),(IV) _result);
1911     XSRETURN(argvi);
1912 }
1913
1914 XS(_wrap_icaldurationtype_as_ical_string) {
1915
1916     char * _result;
1917     struct icaldurationtype * _arg0;
1918     int argvi = 0;
1919     dXSARGS ;
1920
1921     cv = cv;
1922     if ((items < 1) || (items > 1))
1923         croak("Usage: icaldurationtype_as_ical_string(d);");
1924     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaldurationtypePtr")) {
1925         croak("Type error in argument 1 of icaldurationtype_as_ical_string. Expected struct icaldurationtypePtr.");
1926         XSRETURN(1);
1927     }
1928     _result = (char *)icaldurationtype_as_ical_string(*_arg0);
1929     ST(argvi) = sv_newmortal();
1930     sv_setpv((SV*)ST(argvi++),(char *) _result);
1931     XSRETURN(argvi);
1932 }
1933
1934 XS(_wrap_icaldurationtype_null_duration) {
1935
1936     struct icaldurationtype * _result;
1937     int argvi = 0;
1938     dXSARGS ;
1939
1940     cv = cv;
1941     if ((items < 0) || (items > 0))
1942         croak("Usage: icaldurationtype_null_duration();");
1943     _result = (struct icaldurationtype *) malloc(sizeof(struct icaldurationtype ));
1944     *(_result) = icaldurationtype_null_duration();
1945     ST(argvi) = sv_newmortal();
1946     sv_setref_pv(ST(argvi++),"struct icaldurationtypePtr", (void *) _result);
1947     XSRETURN(argvi);
1948 }
1949
1950 XS(_wrap_icaldurationtype_is_null_duration) {
1951
1952     int  _result;
1953     struct icaldurationtype * _arg0;
1954     int argvi = 0;
1955     dXSARGS ;
1956
1957     cv = cv;
1958     if ((items < 1) || (items > 1))
1959         croak("Usage: icaldurationtype_is_null_duration(d);");
1960     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaldurationtypePtr")) {
1961         croak("Type error in argument 1 of icaldurationtype_is_null_duration. Expected struct icaldurationtypePtr.");
1962         XSRETURN(1);
1963     }
1964     _result = (int )icaldurationtype_is_null_duration(*_arg0);
1965     ST(argvi) = sv_newmortal();
1966     sv_setiv(ST(argvi++),(IV) _result);
1967     XSRETURN(argvi);
1968 }
1969
1970 XS(_wrap_icaltime_add) {
1971
1972     struct icaltimetype * _result;
1973     struct icaltimetype * _arg0;
1974     struct icaldurationtype * _arg1;
1975     int argvi = 0;
1976     dXSARGS ;
1977
1978     cv = cv;
1979     if ((items < 2) || (items > 2))
1980         croak("Usage: icaltime_add(t,d);");
1981     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaltimetypePtr")) {
1982         croak("Type error in argument 1 of icaltime_add. Expected struct icaltimetypePtr.");
1983         XSRETURN(1);
1984     }
1985     if (SWIG_GetPtr(ST(1),(void **) &_arg1,"struct icaldurationtypePtr")) {
1986         croak("Type error in argument 2 of icaltime_add. Expected struct icaldurationtypePtr.");
1987         XSRETURN(1);
1988     }
1989     _result = (struct icaltimetype *) malloc(sizeof(struct icaltimetype ));
1990     *(_result) = icaltime_add(*_arg0,*_arg1);
1991     ST(argvi) = sv_newmortal();
1992     sv_setref_pv(ST(argvi++),"struct icaltimetypePtr", (void *) _result);
1993     XSRETURN(argvi);
1994 }
1995
1996 XS(_wrap_icaltime_subtract) {
1997
1998     struct icaldurationtype * _result;
1999     struct icaltimetype * _arg0;
2000     struct icaltimetype * _arg1;
2001     int argvi = 0;
2002     dXSARGS ;
2003
2004     cv = cv;
2005     if ((items < 2) || (items > 2))
2006         croak("Usage: icaltime_subtract(t1,t2);");
2007     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaltimetypePtr")) {
2008         croak("Type error in argument 1 of icaltime_subtract. Expected struct icaltimetypePtr.");
2009         XSRETURN(1);
2010     }
2011     if (SWIG_GetPtr(ST(1),(void **) &_arg1,"struct icaltimetypePtr")) {
2012         croak("Type error in argument 2 of icaltime_subtract. Expected struct icaltimetypePtr.");
2013         XSRETURN(1);
2014     }
2015     _result = (struct icaldurationtype *) malloc(sizeof(struct icaldurationtype ));
2016     *(_result) = icaltime_subtract(*_arg0,*_arg1);
2017     ST(argvi) = sv_newmortal();
2018     sv_setref_pv(ST(argvi++),"struct icaldurationtypePtr", (void *) _result);
2019     XSRETURN(argvi);
2020 }
2021
2022 XS(_wrap_icalperiodtype_from_string) {
2023
2024     struct icalperiodtype * _result;
2025     char * _arg0;
2026     int argvi = 0;
2027     dXSARGS ;
2028
2029     cv = cv;
2030     if ((items < 1) || (items > 1))
2031         croak("Usage: icalperiodtype_from_string(str);");
2032     _arg0 = (char *) SvPV(ST(0),na);
2033     _result = (struct icalperiodtype *) malloc(sizeof(struct icalperiodtype ));
2034     *(_result) = icalperiodtype_from_string(_arg0);
2035     ST(argvi) = sv_newmortal();
2036     sv_setref_pv(ST(argvi++),"struct icalperiodtypePtr", (void *) _result);
2037     XSRETURN(argvi);
2038 }
2039
2040 XS(_wrap_icalperiodtype_as_ical_string) {
2041
2042     char * _result;
2043     struct icalperiodtype * _arg0;
2044     int argvi = 0;
2045     dXSARGS ;
2046
2047     cv = cv;
2048     if ((items < 1) || (items > 1))
2049         croak("Usage: icalperiodtype_as_ical_string(p);");
2050     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icalperiodtypePtr")) {
2051         croak("Type error in argument 1 of icalperiodtype_as_ical_string. Expected struct icalperiodtypePtr.");
2052         XSRETURN(1);
2053     }
2054     _result = (char *)icalperiodtype_as_ical_string(*_arg0);
2055     ST(argvi) = sv_newmortal();
2056     sv_setpv((SV*)ST(argvi++),(char *) _result);
2057     XSRETURN(argvi);
2058 }
2059
2060 XS(_wrap_icalperiodtype_null_period) {
2061
2062     struct icalperiodtype * _result;
2063     int argvi = 0;
2064     dXSARGS ;
2065
2066     cv = cv;
2067     if ((items < 0) || (items > 0))
2068         croak("Usage: icalperiodtype_null_period();");
2069     _result = (struct icalperiodtype *) malloc(sizeof(struct icalperiodtype ));
2070     *(_result) = icalperiodtype_null_period();
2071     ST(argvi) = sv_newmortal();
2072     sv_setref_pv(ST(argvi++),"struct icalperiodtypePtr", (void *) _result);
2073     XSRETURN(argvi);
2074 }
2075
2076 XS(_wrap_icalperiodtype_is_null_period) {
2077
2078     int  _result;
2079     struct icalperiodtype * _arg0;
2080     int argvi = 0;
2081     dXSARGS ;
2082
2083     cv = cv;
2084     if ((items < 1) || (items > 1))
2085         croak("Usage: icalperiodtype_is_null_period(p);");
2086     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icalperiodtypePtr")) {
2087         croak("Type error in argument 1 of icalperiodtype_is_null_period. Expected struct icalperiodtypePtr.");
2088         XSRETURN(1);
2089     }
2090     _result = (int )icalperiodtype_is_null_period(*_arg0);
2091     ST(argvi) = sv_newmortal();
2092     sv_setiv(ST(argvi++),(IV) _result);
2093     XSRETURN(argvi);
2094 }
2095
2096 XS(_wrap_icalperiodtype_is_valid_period) {
2097
2098     int  _result;
2099     struct icalperiodtype * _arg0;
2100     int argvi = 0;
2101     dXSARGS ;
2102
2103     cv = cv;
2104     if ((items < 1) || (items > 1))
2105         croak("Usage: icalperiodtype_is_valid_period(p);");
2106     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icalperiodtypePtr")) {
2107         croak("Type error in argument 1 of icalperiodtype_is_valid_period. Expected struct icalperiodtypePtr.");
2108         XSRETURN(1);
2109     }
2110     _result = (int )icalperiodtype_is_valid_period(*_arg0);
2111     ST(argvi) = sv_newmortal();
2112     sv_setiv(ST(argvi++),(IV) _result);
2113     XSRETURN(argvi);
2114 }
2115
2116 #define icaltimetype_year_set(_swigobj,_swigval) (_swigobj->year = _swigval,_swigval)
2117 XS(_wrap_icaltimetype_year_set) {
2118
2119     int  _result;
2120     struct icaltimetype * _arg0;
2121     int  _arg1;
2122     int argvi = 0;
2123     dXSARGS ;
2124
2125     cv = cv;
2126     if ((items < 2) || (items > 2))
2127         croak("Usage: icaltimetype_year_set(struct icaltimetype *,int );");
2128     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaltimetypePtr")) {
2129         croak("Type error in argument 1 of icaltimetype_year_set. Expected struct icaltimetypePtr.");
2130         XSRETURN(1);
2131     }
2132     _arg1 = (int )SvIV(ST(1));
2133     _result = (int )icaltimetype_year_set(_arg0,_arg1);
2134     ST(argvi) = sv_newmortal();
2135     sv_setiv(ST(argvi++),(IV) _result);
2136     XSRETURN(argvi);
2137 }
2138
2139 #define icaltimetype_year_get(_swigobj) ((int ) _swigobj->year)
2140 XS(_wrap_icaltimetype_year_get) {
2141
2142     int  _result;
2143     struct icaltimetype * _arg0;
2144     int argvi = 0;
2145     dXSARGS ;
2146
2147     cv = cv;
2148     if ((items < 1) || (items > 1))
2149         croak("Usage: icaltimetype_year_get(struct icaltimetype *);");
2150     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaltimetypePtr")) {
2151         croak("Type error in argument 1 of icaltimetype_year_get. Expected struct icaltimetypePtr.");
2152         XSRETURN(1);
2153     }
2154     _result = (int )icaltimetype_year_get(_arg0);
2155     ST(argvi) = sv_newmortal();
2156     sv_setiv(ST(argvi++),(IV) _result);
2157     XSRETURN(argvi);
2158 }
2159
2160 #define icaltimetype_month_set(_swigobj,_swigval) (_swigobj->month = _swigval,_swigval)
2161 XS(_wrap_icaltimetype_month_set) {
2162
2163     int  _result;
2164     struct icaltimetype * _arg0;
2165     int  _arg1;
2166     int argvi = 0;
2167     dXSARGS ;
2168
2169     cv = cv;
2170     if ((items < 2) || (items > 2))
2171         croak("Usage: icaltimetype_month_set(struct icaltimetype *,int );");
2172     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaltimetypePtr")) {
2173         croak("Type error in argument 1 of icaltimetype_month_set. Expected struct icaltimetypePtr.");
2174         XSRETURN(1);
2175     }
2176     _arg1 = (int )SvIV(ST(1));
2177     _result = (int )icaltimetype_month_set(_arg0,_arg1);
2178     ST(argvi) = sv_newmortal();
2179     sv_setiv(ST(argvi++),(IV) _result);
2180     XSRETURN(argvi);
2181 }
2182
2183 #define icaltimetype_month_get(_swigobj) ((int ) _swigobj->month)
2184 XS(_wrap_icaltimetype_month_get) {
2185
2186     int  _result;
2187     struct icaltimetype * _arg0;
2188     int argvi = 0;
2189     dXSARGS ;
2190
2191     cv = cv;
2192     if ((items < 1) || (items > 1))
2193         croak("Usage: icaltimetype_month_get(struct icaltimetype *);");
2194     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaltimetypePtr")) {
2195         croak("Type error in argument 1 of icaltimetype_month_get. Expected struct icaltimetypePtr.");
2196         XSRETURN(1);
2197     }
2198     _result = (int )icaltimetype_month_get(_arg0);
2199     ST(argvi) = sv_newmortal();
2200     sv_setiv(ST(argvi++),(IV) _result);
2201     XSRETURN(argvi);
2202 }
2203
2204 #define icaltimetype_day_set(_swigobj,_swigval) (_swigobj->day = _swigval,_swigval)
2205 XS(_wrap_icaltimetype_day_set) {
2206
2207     int  _result;
2208     struct icaltimetype * _arg0;
2209     int  _arg1;
2210     int argvi = 0;
2211     dXSARGS ;
2212
2213     cv = cv;
2214     if ((items < 2) || (items > 2))
2215         croak("Usage: icaltimetype_day_set(struct icaltimetype *,int );");
2216     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaltimetypePtr")) {
2217         croak("Type error in argument 1 of icaltimetype_day_set. Expected struct icaltimetypePtr.");
2218         XSRETURN(1);
2219     }
2220     _arg1 = (int )SvIV(ST(1));
2221     _result = (int )icaltimetype_day_set(_arg0,_arg1);
2222     ST(argvi) = sv_newmortal();
2223     sv_setiv(ST(argvi++),(IV) _result);
2224     XSRETURN(argvi);
2225 }
2226
2227 #define icaltimetype_day_get(_swigobj) ((int ) _swigobj->day)
2228 XS(_wrap_icaltimetype_day_get) {
2229
2230     int  _result;
2231     struct icaltimetype * _arg0;
2232     int argvi = 0;
2233     dXSARGS ;
2234
2235     cv = cv;
2236     if ((items < 1) || (items > 1))
2237         croak("Usage: icaltimetype_day_get(struct icaltimetype *);");
2238     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaltimetypePtr")) {
2239         croak("Type error in argument 1 of icaltimetype_day_get. Expected struct icaltimetypePtr.");
2240         XSRETURN(1);
2241     }
2242     _result = (int )icaltimetype_day_get(_arg0);
2243     ST(argvi) = sv_newmortal();
2244     sv_setiv(ST(argvi++),(IV) _result);
2245     XSRETURN(argvi);
2246 }
2247
2248 #define icaltimetype_hour_set(_swigobj,_swigval) (_swigobj->hour = _swigval,_swigval)
2249 XS(_wrap_icaltimetype_hour_set) {
2250
2251     int  _result;
2252     struct icaltimetype * _arg0;
2253     int  _arg1;
2254     int argvi = 0;
2255     dXSARGS ;
2256
2257     cv = cv;
2258     if ((items < 2) || (items > 2))
2259         croak("Usage: icaltimetype_hour_set(struct icaltimetype *,int );");
2260     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaltimetypePtr")) {
2261         croak("Type error in argument 1 of icaltimetype_hour_set. Expected struct icaltimetypePtr.");
2262         XSRETURN(1);
2263     }
2264     _arg1 = (int )SvIV(ST(1));
2265     _result = (int )icaltimetype_hour_set(_arg0,_arg1);
2266     ST(argvi) = sv_newmortal();
2267     sv_setiv(ST(argvi++),(IV) _result);
2268     XSRETURN(argvi);
2269 }
2270
2271 #define icaltimetype_hour_get(_swigobj) ((int ) _swigobj->hour)
2272 XS(_wrap_icaltimetype_hour_get) {
2273
2274     int  _result;
2275     struct icaltimetype * _arg0;
2276     int argvi = 0;
2277     dXSARGS ;
2278
2279     cv = cv;
2280     if ((items < 1) || (items > 1))
2281         croak("Usage: icaltimetype_hour_get(struct icaltimetype *);");
2282     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaltimetypePtr")) {
2283         croak("Type error in argument 1 of icaltimetype_hour_get. Expected struct icaltimetypePtr.");
2284         XSRETURN(1);
2285     }
2286     _result = (int )icaltimetype_hour_get(_arg0);
2287     ST(argvi) = sv_newmortal();
2288     sv_setiv(ST(argvi++),(IV) _result);
2289     XSRETURN(argvi);
2290 }
2291
2292 #define icaltimetype_minute_set(_swigobj,_swigval) (_swigobj->minute = _swigval,_swigval)
2293 XS(_wrap_icaltimetype_minute_set) {
2294
2295     int  _result;
2296     struct icaltimetype * _arg0;
2297     int  _arg1;
2298     int argvi = 0;
2299     dXSARGS ;
2300
2301     cv = cv;
2302     if ((items < 2) || (items > 2))
2303         croak("Usage: icaltimetype_minute_set(struct icaltimetype *,int );");
2304     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaltimetypePtr")) {
2305         croak("Type error in argument 1 of icaltimetype_minute_set. Expected struct icaltimetypePtr.");
2306         XSRETURN(1);
2307     }
2308     _arg1 = (int )SvIV(ST(1));
2309     _result = (int )icaltimetype_minute_set(_arg0,_arg1);
2310     ST(argvi) = sv_newmortal();
2311     sv_setiv(ST(argvi++),(IV) _result);
2312     XSRETURN(argvi);
2313 }
2314
2315 #define icaltimetype_minute_get(_swigobj) ((int ) _swigobj->minute)
2316 XS(_wrap_icaltimetype_minute_get) {
2317
2318     int  _result;
2319     struct icaltimetype * _arg0;
2320     int argvi = 0;
2321     dXSARGS ;
2322
2323     cv = cv;
2324     if ((items < 1) || (items > 1))
2325         croak("Usage: icaltimetype_minute_get(struct icaltimetype *);");
2326     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaltimetypePtr")) {
2327         croak("Type error in argument 1 of icaltimetype_minute_get. Expected struct icaltimetypePtr.");
2328         XSRETURN(1);
2329     }
2330     _result = (int )icaltimetype_minute_get(_arg0);
2331     ST(argvi) = sv_newmortal();
2332     sv_setiv(ST(argvi++),(IV) _result);
2333     XSRETURN(argvi);
2334 }
2335
2336 #define icaltimetype_second_set(_swigobj,_swigval) (_swigobj->second = _swigval,_swigval)
2337 XS(_wrap_icaltimetype_second_set) {
2338
2339     int  _result;
2340     struct icaltimetype * _arg0;
2341     int  _arg1;
2342     int argvi = 0;
2343     dXSARGS ;
2344
2345     cv = cv;
2346     if ((items < 2) || (items > 2))
2347         croak("Usage: icaltimetype_second_set(struct icaltimetype *,int );");
2348     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaltimetypePtr")) {
2349         croak("Type error in argument 1 of icaltimetype_second_set. Expected struct icaltimetypePtr.");
2350         XSRETURN(1);
2351     }
2352     _arg1 = (int )SvIV(ST(1));
2353     _result = (int )icaltimetype_second_set(_arg0,_arg1);
2354     ST(argvi) = sv_newmortal();
2355     sv_setiv(ST(argvi++),(IV) _result);
2356     XSRETURN(argvi);
2357 }
2358
2359 #define icaltimetype_second_get(_swigobj) ((int ) _swigobj->second)
2360 XS(_wrap_icaltimetype_second_get) {
2361
2362     int  _result;
2363     struct icaltimetype * _arg0;
2364     int argvi = 0;
2365     dXSARGS ;
2366
2367     cv = cv;
2368     if ((items < 1) || (items > 1))
2369         croak("Usage: icaltimetype_second_get(struct icaltimetype *);");
2370     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaltimetypePtr")) {
2371         croak("Type error in argument 1 of icaltimetype_second_get. Expected struct icaltimetypePtr.");
2372         XSRETURN(1);
2373     }
2374     _result = (int )icaltimetype_second_get(_arg0);
2375     ST(argvi) = sv_newmortal();
2376     sv_setiv(ST(argvi++),(IV) _result);
2377     XSRETURN(argvi);
2378 }
2379
2380 #define icaltimetype_is_utc_set(_swigobj,_swigval) (_swigobj->is_utc = _swigval,_swigval)
2381 XS(_wrap_icaltimetype_is_utc_set) {
2382
2383     int  _result;
2384     struct icaltimetype * _arg0;
2385     int  _arg1;
2386     int argvi = 0;
2387     dXSARGS ;
2388
2389     cv = cv;
2390     if ((items < 2) || (items > 2))
2391         croak("Usage: icaltimetype_is_utc_set(struct icaltimetype *,int );");
2392     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaltimetypePtr")) {
2393         croak("Type error in argument 1 of icaltimetype_is_utc_set. Expected struct icaltimetypePtr.");
2394         XSRETURN(1);
2395     }
2396     _arg1 = (int )SvIV(ST(1));
2397     _result = (int )icaltimetype_is_utc_set(_arg0,_arg1);
2398     ST(argvi) = sv_newmortal();
2399     sv_setiv(ST(argvi++),(IV) _result);
2400     XSRETURN(argvi);
2401 }
2402
2403 #define icaltimetype_is_utc_get(_swigobj) ((int ) _swigobj->is_utc)
2404 XS(_wrap_icaltimetype_is_utc_get) {
2405
2406     int  _result;
2407     struct icaltimetype * _arg0;
2408     int argvi = 0;
2409     dXSARGS ;
2410
2411     cv = cv;
2412     if ((items < 1) || (items > 1))
2413         croak("Usage: icaltimetype_is_utc_get(struct icaltimetype *);");
2414     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaltimetypePtr")) {
2415         croak("Type error in argument 1 of icaltimetype_is_utc_get. Expected struct icaltimetypePtr.");
2416         XSRETURN(1);
2417     }
2418     _result = (int )icaltimetype_is_utc_get(_arg0);
2419     ST(argvi) = sv_newmortal();
2420     sv_setiv(ST(argvi++),(IV) _result);
2421     XSRETURN(argvi);
2422 }
2423
2424 #define icaltimetype_is_date_set(_swigobj,_swigval) (_swigobj->is_date = _swigval,_swigval)
2425 XS(_wrap_icaltimetype_is_date_set) {
2426
2427     int  _result;
2428     struct icaltimetype * _arg0;
2429     int  _arg1;
2430     int argvi = 0;
2431     dXSARGS ;
2432
2433     cv = cv;
2434     if ((items < 2) || (items > 2))
2435         croak("Usage: icaltimetype_is_date_set(struct icaltimetype *,int );");
2436     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaltimetypePtr")) {
2437         croak("Type error in argument 1 of icaltimetype_is_date_set. Expected struct icaltimetypePtr.");
2438         XSRETURN(1);
2439     }
2440     _arg1 = (int )SvIV(ST(1));
2441     _result = (int )icaltimetype_is_date_set(_arg0,_arg1);
2442     ST(argvi) = sv_newmortal();
2443     sv_setiv(ST(argvi++),(IV) _result);
2444     XSRETURN(argvi);
2445 }
2446
2447 #define icaltimetype_is_date_get(_swigobj) ((int ) _swigobj->is_date)
2448 XS(_wrap_icaltimetype_is_date_get) {
2449
2450     int  _result;
2451     struct icaltimetype * _arg0;
2452     int argvi = 0;
2453     dXSARGS ;
2454
2455     cv = cv;
2456     if ((items < 1) || (items > 1))
2457         croak("Usage: icaltimetype_is_date_get(struct icaltimetype *);");
2458     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaltimetypePtr")) {
2459         croak("Type error in argument 1 of icaltimetype_is_date_get. Expected struct icaltimetypePtr.");
2460         XSRETURN(1);
2461     }
2462     _result = (int )icaltimetype_is_date_get(_arg0);
2463     ST(argvi) = sv_newmortal();
2464     sv_setiv(ST(argvi++),(IV) _result);
2465     XSRETURN(argvi);
2466 }
2467
2468 #define icaldurationtype_is_neg_set(_swigobj,_swigval) (_swigobj->is_neg = _swigval,_swigval)
2469 XS(_wrap_icaldurationtype_is_neg_set) {
2470
2471     int  _result;
2472     struct icaldurationtype * _arg0;
2473     int  _arg1;
2474     int argvi = 0;
2475     dXSARGS ;
2476
2477     cv = cv;
2478     if ((items < 2) || (items > 2))
2479         croak("Usage: icaldurationtype_is_neg_set(struct icaldurationtype *,int );");
2480     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaldurationtypePtr")) {
2481         croak("Type error in argument 1 of icaldurationtype_is_neg_set. Expected struct icaldurationtypePtr.");
2482         XSRETURN(1);
2483     }
2484     _arg1 = (int )SvIV(ST(1));
2485     _result = (int )icaldurationtype_is_neg_set(_arg0,_arg1);
2486     ST(argvi) = sv_newmortal();
2487     sv_setiv(ST(argvi++),(IV) _result);
2488     XSRETURN(argvi);
2489 }
2490
2491 #define icaldurationtype_is_neg_get(_swigobj) ((int ) _swigobj->is_neg)
2492 XS(_wrap_icaldurationtype_is_neg_get) {
2493
2494     int  _result;
2495     struct icaldurationtype * _arg0;
2496     int argvi = 0;
2497     dXSARGS ;
2498
2499     cv = cv;
2500     if ((items < 1) || (items > 1))
2501         croak("Usage: icaldurationtype_is_neg_get(struct icaldurationtype *);");
2502     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaldurationtypePtr")) {
2503         croak("Type error in argument 1 of icaldurationtype_is_neg_get. Expected struct icaldurationtypePtr.");
2504         XSRETURN(1);
2505     }
2506     _result = (int )icaldurationtype_is_neg_get(_arg0);
2507     ST(argvi) = sv_newmortal();
2508     sv_setiv(ST(argvi++),(IV) _result);
2509     XSRETURN(argvi);
2510 }
2511
2512 #define icaldurationtype_days_set(_swigobj,_swigval) (_swigobj->days = _swigval,_swigval)
2513 XS(_wrap_icaldurationtype_days_set) {
2514
2515     unsigned int  _result;
2516     struct icaldurationtype * _arg0;
2517     unsigned int  _arg1;
2518     int argvi = 0;
2519     dXSARGS ;
2520
2521     cv = cv;
2522     if ((items < 2) || (items > 2))
2523         croak("Usage: icaldurationtype_days_set(struct icaldurationtype *,unsigned int );");
2524     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaldurationtypePtr")) {
2525         croak("Type error in argument 1 of icaldurationtype_days_set. Expected struct icaldurationtypePtr.");
2526         XSRETURN(1);
2527     }
2528     _arg1 = (unsigned int )SvIV(ST(1));
2529     _result = (unsigned int )icaldurationtype_days_set(_arg0,_arg1);
2530     ST(argvi) = sv_newmortal();
2531     sv_setiv(ST(argvi++),(IV) _result);
2532     XSRETURN(argvi);
2533 }
2534
2535 #define icaldurationtype_days_get(_swigobj) ((unsigned int ) _swigobj->days)
2536 XS(_wrap_icaldurationtype_days_get) {
2537
2538     unsigned int  _result;
2539     struct icaldurationtype * _arg0;
2540     int argvi = 0;
2541     dXSARGS ;
2542
2543     cv = cv;
2544     if ((items < 1) || (items > 1))
2545         croak("Usage: icaldurationtype_days_get(struct icaldurationtype *);");
2546     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaldurationtypePtr")) {
2547         croak("Type error in argument 1 of icaldurationtype_days_get. Expected struct icaldurationtypePtr.");
2548         XSRETURN(1);
2549     }
2550     _result = (unsigned int )icaldurationtype_days_get(_arg0);
2551     ST(argvi) = sv_newmortal();
2552     sv_setiv(ST(argvi++),(IV) _result);
2553     XSRETURN(argvi);
2554 }
2555
2556 #define icaldurationtype_weeks_set(_swigobj,_swigval) (_swigobj->weeks = _swigval,_swigval)
2557 XS(_wrap_icaldurationtype_weeks_set) {
2558
2559     unsigned int  _result;
2560     struct icaldurationtype * _arg0;
2561     unsigned int  _arg1;
2562     int argvi = 0;
2563     dXSARGS ;
2564
2565     cv = cv;
2566     if ((items < 2) || (items > 2))
2567         croak("Usage: icaldurationtype_weeks_set(struct icaldurationtype *,unsigned int );");
2568     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaldurationtypePtr")) {
2569         croak("Type error in argument 1 of icaldurationtype_weeks_set. Expected struct icaldurationtypePtr.");
2570         XSRETURN(1);
2571     }
2572     _arg1 = (unsigned int )SvIV(ST(1));
2573     _result = (unsigned int )icaldurationtype_weeks_set(_arg0,_arg1);
2574     ST(argvi) = sv_newmortal();
2575     sv_setiv(ST(argvi++),(IV) _result);
2576     XSRETURN(argvi);
2577 }
2578
2579 #define icaldurationtype_weeks_get(_swigobj) ((unsigned int ) _swigobj->weeks)
2580 XS(_wrap_icaldurationtype_weeks_get) {
2581
2582     unsigned int  _result;
2583     struct icaldurationtype * _arg0;
2584     int argvi = 0;
2585     dXSARGS ;
2586
2587     cv = cv;
2588     if ((items < 1) || (items > 1))
2589         croak("Usage: icaldurationtype_weeks_get(struct icaldurationtype *);");
2590     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaldurationtypePtr")) {
2591         croak("Type error in argument 1 of icaldurationtype_weeks_get. Expected struct icaldurationtypePtr.");
2592         XSRETURN(1);
2593     }
2594     _result = (unsigned int )icaldurationtype_weeks_get(_arg0);
2595     ST(argvi) = sv_newmortal();
2596     sv_setiv(ST(argvi++),(IV) _result);
2597     XSRETURN(argvi);
2598 }
2599
2600 #define icaldurationtype_hours_set(_swigobj,_swigval) (_swigobj->hours = _swigval,_swigval)
2601 XS(_wrap_icaldurationtype_hours_set) {
2602
2603     unsigned int  _result;
2604     struct icaldurationtype * _arg0;
2605     unsigned int  _arg1;
2606     int argvi = 0;
2607     dXSARGS ;
2608
2609     cv = cv;
2610     if ((items < 2) || (items > 2))
2611         croak("Usage: icaldurationtype_hours_set(struct icaldurationtype *,unsigned int );");
2612     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaldurationtypePtr")) {
2613         croak("Type error in argument 1 of icaldurationtype_hours_set. Expected struct icaldurationtypePtr.");
2614         XSRETURN(1);
2615     }
2616     _arg1 = (unsigned int )SvIV(ST(1));
2617     _result = (unsigned int )icaldurationtype_hours_set(_arg0,_arg1);
2618     ST(argvi) = sv_newmortal();
2619     sv_setiv(ST(argvi++),(IV) _result);
2620     XSRETURN(argvi);
2621 }
2622
2623 #define icaldurationtype_hours_get(_swigobj) ((unsigned int ) _swigobj->hours)
2624 XS(_wrap_icaldurationtype_hours_get) {
2625
2626     unsigned int  _result;
2627     struct icaldurationtype * _arg0;
2628     int argvi = 0;
2629     dXSARGS ;
2630
2631     cv = cv;
2632     if ((items < 1) || (items > 1))
2633         croak("Usage: icaldurationtype_hours_get(struct icaldurationtype *);");
2634     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaldurationtypePtr")) {
2635         croak("Type error in argument 1 of icaldurationtype_hours_get. Expected struct icaldurationtypePtr.");
2636         XSRETURN(1);
2637     }
2638     _result = (unsigned int )icaldurationtype_hours_get(_arg0);
2639     ST(argvi) = sv_newmortal();
2640     sv_setiv(ST(argvi++),(IV) _result);
2641     XSRETURN(argvi);
2642 }
2643
2644 #define icaldurationtype_minutes_set(_swigobj,_swigval) (_swigobj->minutes = _swigval,_swigval)
2645 XS(_wrap_icaldurationtype_minutes_set) {
2646
2647     unsigned int  _result;
2648     struct icaldurationtype * _arg0;
2649     unsigned int  _arg1;
2650     int argvi = 0;
2651     dXSARGS ;
2652
2653     cv = cv;
2654     if ((items < 2) || (items > 2))
2655         croak("Usage: icaldurationtype_minutes_set(struct icaldurationtype *,unsigned int );");
2656     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaldurationtypePtr")) {
2657         croak("Type error in argument 1 of icaldurationtype_minutes_set. Expected struct icaldurationtypePtr.");
2658         XSRETURN(1);
2659     }
2660     _arg1 = (unsigned int )SvIV(ST(1));
2661     _result = (unsigned int )icaldurationtype_minutes_set(_arg0,_arg1);
2662     ST(argvi) = sv_newmortal();
2663     sv_setiv(ST(argvi++),(IV) _result);
2664     XSRETURN(argvi);
2665 }
2666
2667 #define icaldurationtype_minutes_get(_swigobj) ((unsigned int ) _swigobj->minutes)
2668 XS(_wrap_icaldurationtype_minutes_get) {
2669
2670     unsigned int  _result;
2671     struct icaldurationtype * _arg0;
2672     int argvi = 0;
2673     dXSARGS ;
2674
2675     cv = cv;
2676     if ((items < 1) || (items > 1))
2677         croak("Usage: icaldurationtype_minutes_get(struct icaldurationtype *);");
2678     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaldurationtypePtr")) {
2679         croak("Type error in argument 1 of icaldurationtype_minutes_get. Expected struct icaldurationtypePtr.");
2680         XSRETURN(1);
2681     }
2682     _result = (unsigned int )icaldurationtype_minutes_get(_arg0);
2683     ST(argvi) = sv_newmortal();
2684     sv_setiv(ST(argvi++),(IV) _result);
2685     XSRETURN(argvi);
2686 }
2687
2688 #define icaldurationtype_seconds_set(_swigobj,_swigval) (_swigobj->seconds = _swigval,_swigval)
2689 XS(_wrap_icaldurationtype_seconds_set) {
2690
2691     unsigned int  _result;
2692     struct icaldurationtype * _arg0;
2693     unsigned int  _arg1;
2694     int argvi = 0;
2695     dXSARGS ;
2696
2697     cv = cv;
2698     if ((items < 2) || (items > 2))
2699         croak("Usage: icaldurationtype_seconds_set(struct icaldurationtype *,unsigned int );");
2700     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaldurationtypePtr")) {
2701         croak("Type error in argument 1 of icaldurationtype_seconds_set. Expected struct icaldurationtypePtr.");
2702         XSRETURN(1);
2703     }
2704     _arg1 = (unsigned int )SvIV(ST(1));
2705     _result = (unsigned int )icaldurationtype_seconds_set(_arg0,_arg1);
2706     ST(argvi) = sv_newmortal();
2707     sv_setiv(ST(argvi++),(IV) _result);
2708     XSRETURN(argvi);
2709 }
2710
2711 #define icaldurationtype_seconds_get(_swigobj) ((unsigned int ) _swigobj->seconds)
2712 XS(_wrap_icaldurationtype_seconds_get) {
2713
2714     unsigned int  _result;
2715     struct icaldurationtype * _arg0;
2716     int argvi = 0;
2717     dXSARGS ;
2718
2719     cv = cv;
2720     if ((items < 1) || (items > 1))
2721         croak("Usage: icaldurationtype_seconds_get(struct icaldurationtype *);");
2722     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icaldurationtypePtr")) {
2723         croak("Type error in argument 1 of icaldurationtype_seconds_get. Expected struct icaldurationtypePtr.");
2724         XSRETURN(1);
2725     }
2726     _result = (unsigned int )icaldurationtype_seconds_get(_arg0);
2727     ST(argvi) = sv_newmortal();
2728     sv_setiv(ST(argvi++),(IV) _result);
2729     XSRETURN(argvi);
2730 }
2731
2732 #define icalperiodtype_start_set(_swigobj,_swigval) (_swigobj->start = *(_swigval),_swigval)
2733 XS(_wrap_icalperiodtype_start_set) {
2734
2735     struct icaltimetype * _result;
2736     struct icalperiodtype * _arg0;
2737     struct icaltimetype * _arg1;
2738     int argvi = 0;
2739     dXSARGS ;
2740
2741     cv = cv;
2742     if ((items < 2) || (items > 2))
2743         croak("Usage: icalperiodtype_start_set(struct icalperiodtype *,struct icaltimetype *);");
2744     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icalperiodtypePtr")) {
2745         croak("Type error in argument 1 of icalperiodtype_start_set. Expected struct icalperiodtypePtr.");
2746         XSRETURN(1);
2747     }
2748     if (SWIG_GetPtr(ST(1),(void **) &_arg1,"struct icaltimetypePtr")) {
2749         croak("Type error in argument 2 of icalperiodtype_start_set. Expected struct icaltimetypePtr.");
2750         XSRETURN(1);
2751     }
2752     _result = (struct icaltimetype *)icalperiodtype_start_set(_arg0,_arg1);
2753     ST(argvi) = sv_newmortal();
2754     sv_setref_pv(ST(argvi++),"struct icaltimetypePtr", (void *) _result);
2755     XSRETURN(argvi);
2756 }
2757
2758 #define icalperiodtype_start_get(_swigobj) (&_swigobj->start)
2759 XS(_wrap_icalperiodtype_start_get) {
2760
2761     struct icaltimetype * _result;
2762     struct icalperiodtype * _arg0;
2763     int argvi = 0;
2764     dXSARGS ;
2765
2766     cv = cv;
2767     if ((items < 1) || (items > 1))
2768         croak("Usage: icalperiodtype_start_get(struct icalperiodtype *);");
2769     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icalperiodtypePtr")) {
2770         croak("Type error in argument 1 of icalperiodtype_start_get. Expected struct icalperiodtypePtr.");
2771         XSRETURN(1);
2772     }
2773     _result = (struct icaltimetype *)icalperiodtype_start_get(_arg0);
2774     ST(argvi) = sv_newmortal();
2775     sv_setref_pv(ST(argvi++),"struct icaltimetypePtr", (void *) _result);
2776     XSRETURN(argvi);
2777 }
2778
2779 #define icalperiodtype_end_set(_swigobj,_swigval) (_swigobj->end = *(_swigval),_swigval)
2780 XS(_wrap_icalperiodtype_end_set) {
2781
2782     struct icaltimetype * _result;
2783     struct icalperiodtype * _arg0;
2784     struct icaltimetype * _arg1;
2785     int argvi = 0;
2786     dXSARGS ;
2787
2788     cv = cv;
2789     if ((items < 2) || (items > 2))
2790         croak("Usage: icalperiodtype_end_set(struct icalperiodtype *,struct icaltimetype *);");
2791     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icalperiodtypePtr")) {
2792         croak("Type error in argument 1 of icalperiodtype_end_set. Expected struct icalperiodtypePtr.");
2793         XSRETURN(1);
2794     }
2795     if (SWIG_GetPtr(ST(1),(void **) &_arg1,"struct icaltimetypePtr")) {
2796         croak("Type error in argument 2 of icalperiodtype_end_set. Expected struct icaltimetypePtr.");
2797         XSRETURN(1);
2798     }
2799     _result = (struct icaltimetype *)icalperiodtype_end_set(_arg0,_arg1);
2800     ST(argvi) = sv_newmortal();
2801     sv_setref_pv(ST(argvi++),"struct icaltimetypePtr", (void *) _result);
2802     XSRETURN(argvi);
2803 }
2804
2805 #define icalperiodtype_end_get(_swigobj) (&_swigobj->end)
2806 XS(_wrap_icalperiodtype_end_get) {
2807
2808     struct icaltimetype * _result;
2809     struct icalperiodtype * _arg0;
2810     int argvi = 0;
2811     dXSARGS ;
2812
2813     cv = cv;
2814     if ((items < 1) || (items > 1))
2815         croak("Usage: icalperiodtype_end_get(struct icalperiodtype *);");
2816     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icalperiodtypePtr")) {
2817         croak("Type error in argument 1 of icalperiodtype_end_get. Expected struct icalperiodtypePtr.");
2818         XSRETURN(1);
2819     }
2820     _result = (struct icaltimetype *)icalperiodtype_end_get(_arg0);
2821     ST(argvi) = sv_newmortal();
2822     sv_setref_pv(ST(argvi++),"struct icaltimetypePtr", (void *) _result);
2823     XSRETURN(argvi);
2824 }
2825
2826 #define icalperiodtype_duration_set(_swigobj,_swigval) (_swigobj->duration = *(_swigval),_swigval)
2827 XS(_wrap_icalperiodtype_duration_set) {
2828
2829     struct icaldurationtype * _result;
2830     struct icalperiodtype * _arg0;
2831     struct icaldurationtype * _arg1;
2832     int argvi = 0;
2833     dXSARGS ;
2834
2835     cv = cv;
2836     if ((items < 2) || (items > 2))
2837         croak("Usage: icalperiodtype_duration_set(struct icalperiodtype *,struct icaldurationtype *);");
2838     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icalperiodtypePtr")) {
2839         croak("Type error in argument 1 of icalperiodtype_duration_set. Expected struct icalperiodtypePtr.");
2840         XSRETURN(1);
2841     }
2842     if (SWIG_GetPtr(ST(1),(void **) &_arg1,"struct icaldurationtypePtr")) {
2843         croak("Type error in argument 2 of icalperiodtype_duration_set. Expected struct icaldurationtypePtr.");
2844         XSRETURN(1);
2845     }
2846     _result = (struct icaldurationtype *)icalperiodtype_duration_set(_arg0,_arg1);
2847     ST(argvi) = sv_newmortal();
2848     sv_setref_pv(ST(argvi++),"struct icaldurationtypePtr", (void *) _result);
2849     XSRETURN(argvi);
2850 }
2851
2852 #define icalperiodtype_duration_get(_swigobj) (&_swigobj->duration)
2853 XS(_wrap_icalperiodtype_duration_get) {
2854
2855     struct icaldurationtype * _result;
2856     struct icalperiodtype * _arg0;
2857     int argvi = 0;
2858     dXSARGS ;
2859
2860     cv = cv;
2861     if ((items < 1) || (items > 1))
2862         croak("Usage: icalperiodtype_duration_get(struct icalperiodtype *);");
2863     if (SWIG_GetPtr(ST(0),(void **) &_arg0,"struct icalperiodtypePtr")) {
2864         croak("Type error in argument 1 of icalperiodtype_duration_get. Expected struct icalperiodtypePtr.");
2865         XSRETURN(1);
2866     }
2867     _result = (struct icaldurationtype *)icalperiodtype_duration_get(_arg0);
2868     ST(argvi) = sv_newmortal();
2869     sv_setref_pv(ST(argvi++),"struct icaldurationtypePtr", (void *) _result);
2870     XSRETURN(argvi);
2871 }
2872
2873 XS(_wrap_perl5_Net__ICal__Libical_var_init) {
2874     dXSARGS;
2875     SV *sv;
2876     cv = cv; items = items;
2877     swig_setiv("ICAL_BADARG_ERROR", (long) ICAL_BADARG_ERROR);
2878     swig_setiv("ICAL_NEWFAILED_ERROR", (long) ICAL_NEWFAILED_ERROR);
2879     swig_setiv("ICAL_MALFORMEDDATA_ERROR", (long) ICAL_MALFORMEDDATA_ERROR);
2880     swig_setiv("ICAL_PARSE_ERROR", (long) ICAL_PARSE_ERROR);
2881     swig_setiv("ICAL_INTERNAL_ERROR", (long) ICAL_INTERNAL_ERROR);
2882     swig_setiv("ICAL_FILE_ERROR", (long) ICAL_FILE_ERROR);
2883     swig_setiv("ICAL_ALLOCATION_ERROR", (long) ICAL_ALLOCATION_ERROR);
2884     swig_setiv("ICAL_USAGE_ERROR", (long) ICAL_USAGE_ERROR);
2885     swig_setiv("ICAL_NO_ERROR", (long) ICAL_NO_ERROR);
2886     swig_setiv("ICAL_UNKNOWN_ERROR", (long) ICAL_UNKNOWN_ERROR);
2887     swig_setiv("ICAL_ERROR_FATAL", (long) ICAL_ERROR_FATAL);
2888     swig_setiv("ICAL_ERROR_NONFATAL", (long) ICAL_ERROR_NONFATAL);
2889     swig_setiv("ICAL_ERROR_DEFAULT", (long) ICAL_ERROR_DEFAULT);
2890     swig_setiv("ICAL_ERROR_UNKNOWN", (long) ICAL_ERROR_UNKNOWN);
2891     swig_setpv("icaltimetype_zone", "icaltimetype::zone");
2892     XSRETURN(1);
2893 }
2894 #ifdef __cplusplus
2895 extern "C"
2896 #endif
2897 XS(boot_Net__ICal__Libical) {
2898          dXSARGS;
2899          char *file = __FILE__;
2900          cv = cv; items = items;
2901          newXS("Net::ICal::Libical::var_Net__ICal__Libical_init", _wrap_perl5_Net__ICal__Libical_var_init, file);
2902          newXS("Net::ICal::Libical::icalparser_parse_string", _wrap_icalparser_parse_string, file);
2903          newXS("Net::ICal::Libical::icalcomponent_new", _wrap_icalcomponent_new, file);
2904          newXS("Net::ICal::Libical::icalcomponent_new_clone", _wrap_icalcomponent_new_clone, file);
2905          newXS("Net::ICal::Libical::icalcomponent_new_from_string", _wrap_icalcomponent_new_from_string, file);
2906          newXS("Net::ICal::Libical::icalcomponent_as_ical_string", _wrap_icalcomponent_as_ical_string, file);
2907          newXS("Net::ICal::Libical::icalcomponent_free", _wrap_icalcomponent_free, file);
2908          newXS("Net::ICal::Libical::icalcomponent_count_errors", _wrap_icalcomponent_count_errors, file);
2909          newXS("Net::ICal::Libical::icalcomponent_strip_errors", _wrap_icalcomponent_strip_errors, file);
2910          newXS("Net::ICal::Libical::icalcomponent_convert_errors", _wrap_icalcomponent_convert_errors, file);
2911          newXS("Net::ICal::Libical::icalcomponent_get_current_property", _wrap_icalcomponent_get_current_property, file);
2912          newXS("Net::ICal::Libical::icalcomponent_get_first_property", _wrap_icalcomponent_get_first_property, file);
2913          newXS("Net::ICal::Libical::icalcomponent_get_next_property", _wrap_icalcomponent_get_next_property, file);
2914          newXS("Net::ICal::Libical::icalcomponent_get_current_component", _wrap_icalcomponent_get_current_component, file);
2915          newXS("Net::ICal::Libical::icalcomponent_get_first_component", _wrap_icalcomponent_get_first_component, file);
2916          newXS("Net::ICal::Libical::icalcomponent_get_next_component", _wrap_icalcomponent_get_next_component, file);
2917          newXS("Net::ICal::Libical::icalcomponent_add_property", _wrap_icalcomponent_add_property, file);
2918          newXS("Net::ICal::Libical::icalcomponent_remove_property", _wrap_icalcomponent_remove_property, file);
2919          newXS("Net::ICal::Libical::icalcomponent_get_parent", _wrap_icalcomponent_get_parent, file);
2920          newXS("Net::ICal::Libical::icalcomponent_isa", _wrap_icalcomponent_isa, file);
2921          newXS("Net::ICal::Libical::icalrestriction_check", _wrap_icalrestriction_check, file);
2922          newXS("Net::ICal::Libical::icalproperty_string_to_kind", _wrap_icalproperty_string_to_kind, file);
2923          newXS("Net::ICal::Libical::icalproperty_new", _wrap_icalproperty_new, file);
2924          newXS("Net::ICal::Libical::icalproperty_new_from_string", _wrap_icalproperty_new_from_string, file);
2925          newXS("Net::ICal::Libical::icalproperty_as_ical_string", _wrap_icalproperty_as_ical_string, file);
2926          newXS("Net::ICal::Libical::icalproperty_set_parameter_from_string", _wrap_icalproperty_set_parameter_from_string, file);
2927          newXS("Net::ICal::Libical::icalproperty_set_value_from_string", _wrap_icalproperty_set_value_from_string, file);
2928          newXS("Net::ICal::Libical::icalproperty_get_value_as_string", _wrap_icalproperty_get_value_as_string, file);
2929          newXS("Net::ICal::Libical::icalproperty_get_parameter_as_string", _wrap_icalproperty_get_parameter_as_string, file);
2930          newXS("Net::ICal::Libical::icalproperty_get_parent", _wrap_icalproperty_get_parent, file);
2931          newXS("Net::ICal::Libical::icalerror_set_error_state", _wrap_icalerror_set_error_state, file);
2932          newXS("Net::ICal::Libical::icalerror_get_error_state", _wrap_icalerror_get_error_state, file);
2933          newXS("Net::ICal::Libical::icalenum_property_kind_to_string", _wrap_icalenum_property_kind_to_string, file);
2934          newXS("Net::ICal::Libical::icalenum_string_to_property_kind", _wrap_icalenum_string_to_property_kind, file);
2935          newXS("Net::ICal::Libical::icalenum_value_kind_to_string", _wrap_icalenum_value_kind_to_string, file);
2936          newXS("Net::ICal::Libical::icalenum_parameter_kind_to_string", _wrap_icalenum_parameter_kind_to_string, file);
2937          newXS("Net::ICal::Libical::icalenum_string_to_parameter_kind", _wrap_icalenum_string_to_parameter_kind, file);
2938          newXS("Net::ICal::Libical::icalenum_component_kind_to_string", _wrap_icalenum_component_kind_to_string, file);
2939          newXS("Net::ICal::Libical::icalenum_string_to_component_kind", _wrap_icalenum_string_to_component_kind, file);
2940          newXS("Net::ICal::Libical::icalenum_property_kind_to_value_kind", _wrap_icalenum_property_kind_to_value_kind, file);
2941          newXS("Net::ICal::Libical::icallangbind_new_array", _wrap_icallangbind_new_array, file);
2942          newXS("Net::ICal::Libical::icallangbind_free_array", _wrap_icallangbind_free_array, file);
2943          newXS("Net::ICal::Libical::icallangbind_access_array", _wrap_icallangbind_access_array, file);
2944          newXS("Net::ICal::Libical::icalrecur_expand_recurrence", _wrap_icalrecur_expand_recurrence, file);
2945          newXS("Net::ICal::Libical::icallangbind_get_first_property", _wrap_icallangbind_get_first_property, file);
2946          newXS("Net::ICal::Libical::icallangbind_get_next_property", _wrap_icallangbind_get_next_property, file);
2947          newXS("Net::ICal::Libical::icallangbind_get_first_component", _wrap_icallangbind_get_first_component, file);
2948          newXS("Net::ICal::Libical::icallangbind_get_next_component", _wrap_icallangbind_get_next_component, file);
2949          newXS("Net::ICal::Libical::icallangbind_property_eval_string", _wrap_icallangbind_property_eval_string, file);
2950          newXS("Net::ICal::Libical::icaltime_from_timet", _wrap_icaltime_from_timet, file);
2951          newXS("Net::ICal::Libical::icaltime_as_timet", _wrap_icaltime_as_timet, file);
2952          newXS("Net::ICal::Libical::icaltime_as_ical_string", _wrap_icaltime_as_ical_string, file);
2953          newXS("Net::ICal::Libical::icaltime_from_string", _wrap_icaltime_from_string, file);
2954          newXS("Net::ICal::Libical::icaltime_utc_offset", _wrap_icaltime_utc_offset, file);
2955          newXS("Net::ICal::Libical::icaltime_as_utc", _wrap_icaltime_as_utc, file);
2956          newXS("Net::ICal::Libical::icaltime_as_zone", _wrap_icaltime_as_zone, file);
2957          newXS("Net::ICal::Libical::icaltime_null_time", _wrap_icaltime_null_time, file);
2958          newXS("Net::ICal::Libical::icaltime_is_null_time", _wrap_icaltime_is_null_time, file);
2959          newXS("Net::ICal::Libical::icaltime_is_valid_time", _wrap_icaltime_is_valid_time, file);
2960          newXS("Net::ICal::Libical::icaltime_normalize", _wrap_icaltime_normalize, file);
2961          newXS("Net::ICal::Libical::icaltime_day_of_year", _wrap_icaltime_day_of_year, file);
2962          newXS("Net::ICal::Libical::icaltime_from_day_of_year", _wrap_icaltime_from_day_of_year, file);
2963          newXS("Net::ICal::Libical::icaltime_day_of_week", _wrap_icaltime_day_of_week, file);
2964          newXS("Net::ICal::Libical::icaltime_start_doy_of_week", _wrap_icaltime_start_doy_of_week, file);
2965          newXS("Net::ICal::Libical::icaltime_as_ctime", _wrap_icaltime_as_ctime, file);
2966          newXS("Net::ICal::Libical::icaltime_week_number", _wrap_icaltime_week_number, file);
2967          newXS("Net::ICal::Libical::icaltime_compare", _wrap_icaltime_compare, file);
2968          newXS("Net::ICal::Libical::icaltime_compare_date_only", _wrap_icaltime_compare_date_only, file);
2969          newXS("Net::ICal::Libical::icaltime_days_in_month", _wrap_icaltime_days_in_month, file);
2970          newXS("Net::ICal::Libical::icaldurationtype_from_int", _wrap_icaldurationtype_from_int, file);
2971          newXS("Net::ICal::Libical::icaldurationtype_from_string", _wrap_icaldurationtype_from_string, file);
2972          newXS("Net::ICal::Libical::icaldurationtype_as_int", _wrap_icaldurationtype_as_int, file);
2973          newXS("Net::ICal::Libical::icaldurationtype_as_ical_string", _wrap_icaldurationtype_as_ical_string, file);
2974          newXS("Net::ICal::Libical::icaldurationtype_null_duration", _wrap_icaldurationtype_null_duration, file);
2975          newXS("Net::ICal::Libical::icaldurationtype_is_null_duration", _wrap_icaldurationtype_is_null_duration, file);
2976          newXS("Net::ICal::Libical::icaltime_add", _wrap_icaltime_add, file);
2977          newXS("Net::ICal::Libical::icaltime_subtract", _wrap_icaltime_subtract, file);
2978          newXS("Net::ICal::Libical::icalperiodtype_from_string", _wrap_icalperiodtype_from_string, file);
2979          newXS("Net::ICal::Libical::icalperiodtype_as_ical_string", _wrap_icalperiodtype_as_ical_string, file);
2980          newXS("Net::ICal::Libical::icalperiodtype_null_period", _wrap_icalperiodtype_null_period, file);
2981          newXS("Net::ICal::Libical::icalperiodtype_is_null_period", _wrap_icalperiodtype_is_null_period, file);
2982          newXS("Net::ICal::Libical::icalperiodtype_is_valid_period", _wrap_icalperiodtype_is_valid_period, file);
2983          newXS("Net::ICal::Libical::icaltimetype_year_set", _wrap_icaltimetype_year_set, file);
2984          newXS("Net::ICal::Libical::icaltimetype_year_get", _wrap_icaltimetype_year_get, file);
2985          newXS("Net::ICal::Libical::icaltimetype_month_set", _wrap_icaltimetype_month_set, file);
2986          newXS("Net::ICal::Libical::icaltimetype_month_get", _wrap_icaltimetype_month_get, file);
2987          newXS("Net::ICal::Libical::icaltimetype_day_set", _wrap_icaltimetype_day_set, file);
2988          newXS("Net::ICal::Libical::icaltimetype_day_get", _wrap_icaltimetype_day_get, file);
2989          newXS("Net::ICal::Libical::icaltimetype_hour_set", _wrap_icaltimetype_hour_set, file);
2990          newXS("Net::ICal::Libical::icaltimetype_hour_get", _wrap_icaltimetype_hour_get, file);
2991          newXS("Net::ICal::Libical::icaltimetype_minute_set", _wrap_icaltimetype_minute_set, file);
2992          newXS("Net::ICal::Libical::icaltimetype_minute_get", _wrap_icaltimetype_minute_get, file);
2993          newXS("Net::ICal::Libical::icaltimetype_second_set", _wrap_icaltimetype_second_set, file);
2994          newXS("Net::ICal::Libical::icaltimetype_second_get", _wrap_icaltimetype_second_get, file);
2995          newXS("Net::ICal::Libical::icaltimetype_is_utc_set", _wrap_icaltimetype_is_utc_set, file);
2996          newXS("Net::ICal::Libical::icaltimetype_is_utc_get", _wrap_icaltimetype_is_utc_get, file);
2997          newXS("Net::ICal::Libical::icaltimetype_is_date_set", _wrap_icaltimetype_is_date_set, file);
2998          newXS("Net::ICal::Libical::icaltimetype_is_date_get", _wrap_icaltimetype_is_date_get, file);
2999          newXS("Net::ICal::Libical::icaldurationtype_is_neg_set", _wrap_icaldurationtype_is_neg_set, file);
3000          newXS("Net::ICal::Libical::icaldurationtype_is_neg_get", _wrap_icaldurationtype_is_neg_get, file);
3001          newXS("Net::ICal::Libical::icaldurationtype_days_set", _wrap_icaldurationtype_days_set, file);
3002          newXS("Net::ICal::Libical::icaldurationtype_days_get", _wrap_icaldurationtype_days_get, file);
3003          newXS("Net::ICal::Libical::icaldurationtype_weeks_set", _wrap_icaldurationtype_weeks_set, file);
3004          newXS("Net::ICal::Libical::icaldurationtype_weeks_get", _wrap_icaldurationtype_weeks_get, file);
3005          newXS("Net::ICal::Libical::icaldurationtype_hours_set", _wrap_icaldurationtype_hours_set, file);
3006          newXS("Net::ICal::Libical::icaldurationtype_hours_get", _wrap_icaldurationtype_hours_get, file);
3007          newXS("Net::ICal::Libical::icaldurationtype_minutes_set", _wrap_icaldurationtype_minutes_set, file);
3008          newXS("Net::ICal::Libical::icaldurationtype_minutes_get", _wrap_icaldurationtype_minutes_get, file);
3009          newXS("Net::ICal::Libical::icaldurationtype_seconds_set", _wrap_icaldurationtype_seconds_set, file);
3010          newXS("Net::ICal::Libical::icaldurationtype_seconds_get", _wrap_icaldurationtype_seconds_get, file);
3011          newXS("Net::ICal::Libical::icalperiodtype_start_set", _wrap_icalperiodtype_start_set, file);
3012          newXS("Net::ICal::Libical::icalperiodtype_start_get", _wrap_icalperiodtype_start_get, file);
3013          newXS("Net::ICal::Libical::icalperiodtype_end_set", _wrap_icalperiodtype_end_set, file);
3014          newXS("Net::ICal::Libical::icalperiodtype_end_get", _wrap_icalperiodtype_end_get, file);
3015          newXS("Net::ICal::Libical::icalperiodtype_duration_set", _wrap_icalperiodtype_duration_set, file);
3016          newXS("Net::ICal::Libical::icalperiodtype_duration_get", _wrap_icalperiodtype_duration_get, file);
3017 /*
3018  * These are the pointer type-equivalency mappings.
3019  * (Used by the SWIG pointer type-checker).
3020  */
3021          SWIG_RegisterMapping("unsigned short","short",0);
3022          SWIG_RegisterMapping("struct icaldurationtype","icaldurationtype",0);
3023          SWIG_RegisterMapping("icalperiodtype","struct icalperiodtype",0);
3024          SWIG_RegisterMapping("long","unsigned long",0);
3025          SWIG_RegisterMapping("long","signed long",0);
3026          SWIG_RegisterMapping("struct icaltimetype","icaltimetype",0);
3027          SWIG_RegisterMapping("icaldurationtype","struct icaldurationtype",0);
3028          SWIG_RegisterMapping("signed short","short",0);
3029          SWIG_RegisterMapping("struct icalperiodtype","icalperiodtype",0);
3030          SWIG_RegisterMapping("signed int","int",0);
3031          SWIG_RegisterMapping("short","unsigned short",0);
3032          SWIG_RegisterMapping("short","signed short",0);
3033          SWIG_RegisterMapping("unsigned long","long",0);
3034          SWIG_RegisterMapping("int","unsigned int",0);
3035          SWIG_RegisterMapping("int","signed int",0);
3036          SWIG_RegisterMapping("unsigned int","int",0);
3037          SWIG_RegisterMapping("icaltimetype","struct icaltimetype",0);
3038          SWIG_RegisterMapping("signed long","long",0);
3039          ST(0) = &sv_yes;
3040          XSRETURN(1);
3041 }