95 files changed, 39289 insertions, 0 deletions

diff --git a/libical/libical.pro b/libical/libical.pro
new file mode 100644
index 0000000..6baecd4
--- a/dev/null
+++ b/libical/libical.pro
@@ -0,0 +1,4 @@
+
+
+TEMPLATE = subdirs
+SUBDIRS =  src
diff --git a/libical/src/libical/config.h b/libical/src/libical/config.h
new file mode 100644
index 0000000..e69de29
--- a/dev/null
+++ b/libical/src/libical/config.h
diff --git a/libical/src/libical/defines.h b/libical/src/libical/defines.h
new file mode 100644
index 0000000..e69de29
--- a/dev/null
+++ b/libical/src/libical/defines.h
diff --git a/libical/src/libical/ical.h b/libical/src/libical/ical.h
new file mode 100644
index 0000000..69a2c3a
--- a/dev/null
+++ b/libical/src/libical/ical.h
@@ -0,0 +1,2996 @@
+#ifndef ICAL_VERSION_H
+#define ICAL_VERSION_H
+
+#define ICAL_PACKAGE "libical"
+#define ICAL_VERSION "0.23"
+
+#endif
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icaltime.h
+ CREATOR: eric 02 June 2000
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+======================================================================*/
+
+#ifndef ICALTIME_H
+#define ICALTIME_H
+
+#include <time.h>
+
+/* icaltime_span is returned by icalcomponent_get_span() */
+struct icaltime_span {
+        time_t start; /* in UTC */
+        time_t end; /* in UTC */
+        int is_busy; /* 1->busy time, 0-> free time */
+};
+
+
+struct icaltimetype
+{
+        int year;
+        int month;
+        int day;
+        int hour;
+        int minute;
+        int second;
+
+        int is_utc; /* 1-> time is in UTC timezone */
+
+        int is_date; /* 1 -> interpret this as date. */
+   
+        const char* zone; /*Ptr to Olsen placename. Libical does not own mem*/
+        };
+
+/* Convert seconds past UNIX epoch to a timetype*/
+struct icaltimetype icaltime_from_timet(time_t v, int is_date);
+
+/* Return the time as seconds past the UNIX epoch */
+time_t icaltime_as_timet(struct icaltimetype);
+
+/* Return a string represention of the time, in RFC2445 format. The
+   string is owned by libical */
+char* icaltime_as_ical_string(struct icaltimetype tt);
+
+/* Like icaltime_from_timet(), except that the input may be in seconds
+   past the epoch in floating time. This routine is deprecated */
+struct icaltimetype icaltime_from_int(int v, int is_date, int is_utc);
+
+/* Like icaltime_as_timet, but in a floating epoch. This routine is deprecated */
+int icaltime_as_int(struct icaltimetype);
+
+/* create a time from an ISO format string */
+struct icaltimetype icaltime_from_string(const char* str);
+
+/* Routines for handling timezones */
+/* Return the offset of the named zone as seconds. tt is a time
+   indicating the date for which you want the offset */
+int icaltime_utc_offset(struct icaltimetype tt, const char* tzid);
+
+/* convert tt, of timezone tzid, into a utc time. Does nothing if the
+   time is already UTC.  */
+struct icaltimetype icaltime_as_utc(struct icaltimetype tt,
+                                    const char* tzid);
+
+/* convert tt, a time in UTC, into a time in timezone tzid */
+struct icaltimetype icaltime_as_zone(struct icaltimetype tt,
+                                     const char* tzid);
+
+/* Return a null time, which indicates no time has been set. This time represent the beginning of the epoch */
+struct icaltimetype icaltime_null_time(void);
+
+/* Return true of the time is null. */
+int icaltime_is_null_time(struct icaltimetype t);
+
+/* Returns false if the time is clearly invalid, but is not null. This
+   is usually the result of creating a new time type buy not clearing
+   it, or setting one of the flags to an illegal value. */
+int icaltime_is_valid_time(struct icaltimetype t);
+
+/* Reset all of the time components to be in their normal ranges. For
+   instance, given a time with minutes=70, the minutes will be reduces
+   to 10, and the hour incremented. This allows the caller to do
+   arithmetic on times without worrying about overflow or
+   underflow. */
+struct icaltimetype icaltime_normalize(struct icaltimetype t);
+
+/* Return the day of the year of the given time */
+short icaltime_day_of_year(struct icaltimetype t);
+
+/* Create a new time, given a day of year and a year. */
+struct icaltimetype icaltime_from_day_of_year(short doy,  short year);
+
+/* Return the day of the week of the given time. Sunday is 1 */
+short icaltime_day_of_week(struct icaltimetype t);
+
+/* Return the day of the year for the Sunday of the week that the
+   given time is within. */
+short icaltime_start_doy_of_week(struct icaltimetype t);
+
+/* Return a string with the time represented in the same format as ctime(). THe string is owned by libical */
+char* icaltime_as_ctime(struct icaltimetype);
+
+/* Return the week number for the week the given time is within */
+short icaltime_week_number(struct icaltimetype t);
+
+/* Create a new time from a weeknumber and a year. */
+struct icaltimetype icaltime_from_week_number(short week_number, short year);
+
+/* Return -1, 0, or 1 to indicate that a<b, a==b or a>b */
+int icaltime_compare(struct icaltimetype a,struct icaltimetype b);
+
+/* like icaltime_compare, but only use the date parts. */
+int icaltime_compare_date_only(struct icaltimetype a, struct icaltimetype b);
+
+/* Return the number of days in the given month */
+short icaltime_days_in_month(short month,short year);
+
+
+#endif /* !ICALTIME_H */
+
+
+
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalduration.h
+ CREATOR: eric 26 Jan 2001
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+======================================================================*/
+
+#ifndef ICALDURATION_H
+#define ICALDURATION_H
+
+
+struct icaldurationtype
+{
+        int is_neg;
+        unsigned int days;
+        unsigned int weeks;
+        unsigned int hours;
+        unsigned int minutes;
+        unsigned int seconds;
+};
+
+struct icaldurationtype icaldurationtype_from_int(int t);
+struct icaldurationtype icaldurationtype_from_string(const char*);
+int icaldurationtype_as_int(struct icaldurationtype duration);
+char* icaldurationtype_as_ical_string(struct icaldurationtype d);
+struct icaldurationtype icaldurationtype_null_duration();
+int icaldurationtype_is_null_duration(struct icaldurationtype d);
+
+struct icaltimetype  icaltime_add(struct icaltimetype t,
+                                  struct icaldurationtype  d);
+
+struct icaldurationtype  icaltime_subtract(struct icaltimetype t1,
+                                           struct icaltimetype t2);
+
+#endif /* !ICALDURATION_H */
+
+
+
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalperiod.h
+ CREATOR: eric 26 Jan 2001
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+======================================================================*/
+
+#ifndef ICALPERIOD_H
+#define ICALPERIOD_H
+
+
+struct icalperiodtype 
+{
+        struct icaltimetype start; 
+        struct icaltimetype end; 
+        struct icaldurationtype duration;
+};
+
+struct icalperiodtype icalperiodtype_from_string (const char* str);
+
+const char* icalperiodtype_as_ical_string(struct icalperiodtype p);
+struct icalperiodtype icalperiodtype_null_period();
+int icalperiodtype_is_null_period(struct icalperiodtype p);
+int icalperiodtype_is_valid_period(struct icalperiodtype p);
+
+
+
+
+#endif /* !ICALTIME_H */
+
+
+
+
+/* -*- Mode: C -*-*/
+/*======================================================================
+ FILE: icalenums.h
+
+ 
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalenums.h
+
+  Contributions from:
+     Graham Davison (g.m.davison@computer.org)
+
+======================================================================*/
+
+#ifndef ICALENUMS_H
+#define ICALENUMS_H
+
+
+
+/***********************************************************************
+ * Component enumerations
+**********************************************************************/
+
+typedef enum icalcomponent_kind {
+    ICAL_NO_COMPONENT,
+            ICAL_ANY_COMPONENT,/* Used to select all components*/
+    ICAL_XROOT_COMPONENT,
+    ICAL_XATTACH_COMPONENT, /* MIME attached data, returned by parser. */
+    ICAL_VEVENT_COMPONENT,
+    ICAL_VTODO_COMPONENT,
+    ICAL_VJOURNAL_COMPONENT,
+    ICAL_VCALENDAR_COMPONENT,
+    ICAL_VFREEBUSY_COMPONENT,
+    ICAL_VALARM_COMPONENT,
+    ICAL_XAUDIOALARM_COMPONENT,  
+    ICAL_XDISPLAYALARM_COMPONENT,
+    ICAL_XEMAILALARM_COMPONENT,
+    ICAL_XPROCEDUREALARM_COMPONENT,
+    ICAL_VTIMEZONE_COMPONENT,
+    ICAL_XSTANDARD_COMPONENT,
+    ICAL_XDAYLIGHT_COMPONENT,
+    ICAL_X_COMPONENT,
+    ICAL_VSCHEDULE_COMPONENT,
+    ICAL_VQUERY_COMPONENT,
+    ICAL_VCAR_COMPONENT,
+    ICAL_VCOMMAND_COMPONENT,
+    ICAL_XLICINVALID_COMPONENT,
+    ICAL_XLICMIMEPART_COMPONENT /* a non-stardard component that mirrors
+                                structure of MIME data */
+
+} icalcomponent_kind;
+
+
+
+/***********************************************************************
+ * Request Status codes
+ **********************************************************************/
+
+typedef enum icalrequeststatus {
+    ICAL_UNKNOWN_STATUS,
+    ICAL_2_0_SUCCESS_STATUS,
+    ICAL_2_1_FALLBACK_STATUS,
+    ICAL_2_2_IGPROP_STATUS,
+    ICAL_2_3_IGPARAM_STATUS,
+    ICAL_2_4_IGXPROP_STATUS,
+    ICAL_2_5_IGXPARAM_STATUS,
+    ICAL_2_6_IGCOMP_STATUS,
+    ICAL_2_7_FORWARD_STATUS,
+    ICAL_2_8_ONEEVENT_STATUS,
+    ICAL_2_9_TRUNC_STATUS,
+    ICAL_2_10_ONETODO_STATUS,
+    ICAL_2_11_TRUNCRRULE_STATUS,
+    ICAL_3_0_INVPROPNAME_STATUS,
+    ICAL_3_1_INVPROPVAL_STATUS,
+    ICAL_3_2_INVPARAM_STATUS,
+    ICAL_3_3_INVPARAMVAL_STATUS,
+    ICAL_3_4_INVCOMP_STATUS,
+    ICAL_3_5_INVTIME_STATUS,
+    ICAL_3_6_INVRULE_STATUS,
+    ICAL_3_7_INVCU_STATUS,
+    ICAL_3_8_NOAUTH_STATUS,
+    ICAL_3_9_BADVERSION_STATUS,
+    ICAL_3_10_TOOBIG_STATUS,
+    ICAL_3_11_MISSREQCOMP_STATUS,
+    ICAL_3_12_UNKCOMP_STATUS,
+    ICAL_3_13_BADCOMP_STATUS,
+    ICAL_3_14_NOCAP_STATUS,
+    ICAL_4_0_BUSY_STATUS,
+    ICAL_5_0_MAYBE_STATUS,
+    ICAL_5_1_UNAVAIL_STATUS,
+    ICAL_5_2_NOSERVICE_STATUS,
+    ICAL_5_3_NOSCHED_STATUS
+} icalrequeststatus;
+
+
+const char* icalenum_reqstat_desc(icalrequeststatus stat);
+short icalenum_reqstat_major(icalrequeststatus stat);
+short icalenum_reqstat_minor(icalrequeststatus stat);
+icalrequeststatus icalenum_num_to_reqstat(short major, short minor);
+
+/***********************************************************************
+ * Conversion functions
+**********************************************************************/
+
+
+/* Thse routines used to be in icalenums.c, but were moved into the
+   icalproperty, icalparameter, icalvalue, or icalcomponent modules. */
+
+/* const char* icalproperty_kind_to_string(icalproperty_kind kind);*/
+#define icalenum_property_kind_to_string(x) icalproperty_kind_to_string(x)
+
+/*icalproperty_kind icalproperty_string_to_kind(const char* string)*/
+#define icalenum_string_to_property_kind(x) icalproperty_string_to_kind(x)
+
+/*icalvalue_kind icalproperty_kind_to_value_kind(icalproperty_kind kind);*/
+#define icalenum_property_kind_to_value_kind(x) icalproperty_kind_to_value_kind(x)
+
+/*const char* icalenum_method_to_string(icalproperty_method);*/
+#define icalenum_method_to_string(x) icalproperty_method_to_string(x)
+
+/*icalproperty_method icalenum_string_to_method(const char* string);*/
+#define icalenum_string_to_method(x) icalproperty_string_to_method(x)
+
+/*const char* icalenum_status_to_string(icalproperty_status);*/
+#define icalenum_status_to_string(x) icalproperty_status_to_string(x)
+
+/*icalproperty_status icalenum_string_to_status(const char* string);*/
+#define icalenum_string_to_status(x) icalproperty_string_to_status(x)
+
+/*icalvalue_kind icalenum_string_to_value_kind(const char* str);*/
+#define icalenum_string_to_value_kind(x) icalvalue_string_to_kind(x)
+
+/*const char* icalenum_value_kind_to_string(icalvalue_kind kind);*/
+#define icalenum_value_kind_to_string(x) icalvalue_kind_to_string(x)
+
+/*const char* icalenum_component_kind_to_string(icalcomponent_kind kind);*/
+#define icalenum_component_kind_to_string(x) icalcomponent_kind_to_string(x)
+
+/*icalcomponent_kind icalenum_string_to_component_kind(const char* string);*/
+#define icalenum_string_to_component_kind(x) icalcomponent_string_to_kind(x)
+
+
+#endif /* !ICALENUMS_H */
+
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icaltypes.h
+ CREATOR: eric 20 March 1999
+
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icaltypes.h
+
+======================================================================*/
+
+#ifndef ICALTYPES_H
+#define ICALTYPES_H
+
+#include <time.h>
+
+
+/* This type type should probably be an opaque type... */
+struct icalattachtype
+{
+        void* binary;
+        int owns_binary; 
+
+        char* base64;
+        int owns_base64;
+
+        char* url;
+
+        int refcount; 
+
+};
+
+/* converts base64 to binary, fetches url and stores as binary, or
+   just returns data */
+
+struct icalattachtype* icalattachtype_new(void);
+void  icalattachtype_add_reference(struct icalattachtype* v);
+void icalattachtype_free(struct icalattachtype* v);
+
+void icalattachtype_set_url(struct icalattachtype* v, char* url);
+char* icalattachtype_get_url(struct icalattachtype* v);
+
+void icalattachtype_set_base64(struct icalattachtype* v, char* base64,
+                                int owns);
+char* icalattachtype_get_base64(struct icalattachtype* v);
+
+void icalattachtype_set_binary(struct icalattachtype* v, char* binary,
+                                int owns);
+void* icalattachtype_get_binary(struct icalattachtype* v);
+
+struct icalgeotype 
+{
+        float lat;
+        float lon;
+};
+
+
+struct icaldatetimeperiodtype 
+{
+        struct icaltimetype time;
+        struct icalperiodtype period;
+};
+
+
+struct icaltriggertype 
+{
+        struct icaltimetype time; 
+        struct icaldurationtype duration;
+};
+
+struct icaltriggertype icaltriggertype_from_string(const char* str);
+
+int icaltriggertype_is_null_trigger(struct icaltriggertype tr);
+
+/* struct icalreqstattype. This struct contains two string pointers,
+but don't try to free either of them. The "desc" string is a pointer
+to a static table inside the library.  Don't try to free it. The
+"debug" string is a pointer into the string that the called passed
+into to icalreqstattype_from_string. Don't try to free it either, and
+don't use it after the original string has been freed.
+
+BTW, you would get that original string from
+*icalproperty_get_requeststatus() or icalvalue_get_text(), when
+operating on a the value of a request_status property. */
+
+struct icalreqstattype {
+
+        icalrequeststatus code;
+        const char* desc;
+        const char* debug;
+};
+
+struct icalreqstattype icalreqstattype_from_string(const char* str);
+const char* icalreqstattype_as_string(struct icalreqstattype);
+
+
+
+struct icaltimezonephase {
+    const char* tzname;
+    int is_stdandard; /* 1 = standard tme, 0 = daylight savings time */
+    struct icaltimetype dtstart;
+    int offsetto;
+    int tzoffsetfrom;
+    const char* comment;
+    struct icaldatetimeperiodtype rdate;
+    const char* rrule;    
+};
+
+
+struct icaltimezonetype {
+    const char* tzid;
+    struct icaltimetype last_mod;
+    const char* tzurl;
+    
+    /* Array of phases. The end of the array is a phase with tzname == 0 */
+    struct icaltimezonephase *phases;
+};
+
+void icaltimezonetype_free(struct icaltimezonetype tzt);
+
+
+#endif /* !ICALTYPES_H */
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalrecur.h
+ CREATOR: eric 20 March 2000
+
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+How to use: 
+
+1) Get a rule and a start time from a component
+        icalproperty rrule;
+        struct icalrecurrencetype recur;
+        struct icaltimetype dtstart;
+
+        rrule = icalcomponent_get_first_property(comp,ICAL_RRULE_PROPERTY);
+        recur = icalproperty_get_rrule(rrule);
+        start = icalproperty_get_dtstart(dtstart);
+
+Or, just make them up: 
+        recur = icalrecurrencetype_from_string("FREQ=YEARLY;BYDAY=SU,WE");
+        dtstart = icaltime_from_string("19970101T123000")
+
+2) Create an iterator
+        icalrecur_iterator* ritr;
+        ritr = icalrecur_iterator_new(recur,start);
+
+3) Iterator over the occurrences
+        struct icaltimetype next;
+        while (next = icalrecur_iterator_next(ritr) 
+               && !icaltime_is_null_time(next){
+                Do something with next
+        }
+
+Note that that the time returned by icalrecur_iterator_next is in
+whatever timezone that dtstart is in.
+
+======================================================================*/
+
+#ifndef ICALRECUR_H
+#define ICALRECUR_H
+
+#include <time.h>
+
+/***********************************************************************
+ * Recurrance enumerations
+**********************************************************************/
+
+typedef enum icalrecurrencetype_frequency
+{
+    /* These enums are used to index an array, so don't change the
+       order or the integers */
+
+    ICAL_SECONDLY_RECURRENCE=0,
+    ICAL_MINUTELY_RECURRENCE=1,
+    ICAL_HOURLY_RECURRENCE=2,
+    ICAL_DAILY_RECURRENCE=3,
+    ICAL_WEEKLY_RECURRENCE=4,
+    ICAL_MONTHLY_RECURRENCE=5,
+    ICAL_YEARLY_RECURRENCE=6,
+    ICAL_NO_RECURRENCE=7
+
+} icalrecurrencetype_frequency;
+
+typedef enum icalrecurrencetype_weekday
+{
+    ICAL_NO_WEEKDAY,
+    ICAL_SUNDAY_WEEKDAY,
+    ICAL_MONDAY_WEEKDAY,
+    ICAL_TUESDAY_WEEKDAY,
+    ICAL_WEDNESDAY_WEEKDAY,
+    ICAL_THURSDAY_WEEKDAY,
+    ICAL_FRIDAY_WEEKDAY,
+    ICAL_SATURDAY_WEEKDAY
+} icalrecurrencetype_weekday;
+
+enum {
+    ICAL_RECURRENCE_ARRAY_MAX = 0x7f7f,
+    ICAL_RECURRENCE_ARRAY_MAX_BYTE = 0x7f
+};
+
+
+
+/********************** Recurrence type routines **************/
+
+/* See RFC 2445 Section 4.3.10, RECUR Value, for an explaination of
+   the values and fields in struct icalrecurrencetype */
+
+#define ICAL_BY_SECOND_SIZE 61
+#define ICAL_BY_MINUTE_SIZE 61
+#define ICAL_BY_HOUR_SIZE 25
+#define ICAL_BY_DAY_SIZE 364 /* 7 days * 52 weeks */
+#define ICAL_BY_MONTHDAY_SIZE 32
+#define ICAL_BY_YEARDAY_SIZE 367
+#define ICAL_BY_WEEKNO_SIZE 54
+#define ICAL_BY_MONTH_SIZE 13
+#define ICAL_BY_SETPOS_SIZE 367
+
+/* Main struct for holding digested recurrence rules */
+struct icalrecurrencetype 
+{
+        icalrecurrencetype_frequency freq;
+
+
+        /* until and count are mutually exclusive. */
+               struct icaltimetype until; 
+        int count;
+
+        short interval;
+        
+        icalrecurrencetype_weekday week_start;
+        
+        /* The BY* parameters can each take a list of values. Here I
+         * assume that the list of values will not be larger than the
+         * range of the value -- that is, the client will not name a
+         * value more than once. 
+         
+         * Each of the lists is terminated with the value
+         * ICAL_RECURRENCE_ARRAY_MAX unless the the list is full.
+         */
+
+        short by_second[ICAL_BY_SECOND_SIZE];
+        short by_minute[ICAL_BY_MINUTE_SIZE];
+        short by_hour[ICAL_BY_HOUR_SIZE];
+        short by_day[ICAL_BY_DAY_SIZE]; /* Encoded value, see below */
+        short by_month_day[ICAL_BY_MONTHDAY_SIZE];
+        short by_year_day[ ICAL_BY_YEARDAY_SIZE];
+        short by_week_no[ICAL_BY_WEEKNO_SIZE];
+        short by_month[ICAL_BY_MONTH_SIZE];
+        short by_set_pos[ICAL_BY_SETPOS_SIZE];
+};
+
+
+void icalrecurrencetype_clear(struct icalrecurrencetype *r);
+
+/* The 'day' element of the by_day array is encoded to allow
+representation of both the day of the week ( Monday, Tueday), but also
+the Nth day of the week ( First tuesday of the month, last thursday of
+the year) These routines decode the day values */
+
+/* 1 == Monday, etc. */
+enum icalrecurrencetype_weekday icalrecurrencetype_day_day_of_week(short day);
+
+/* 0 == any of day of week. 1 == first, 2 = second, -2 == second to last, etc */
+short icalrecurrencetype_day_position(short day);
+
+
+/***********************************************************************
+ * Recurrance rule parser
+**********************************************************************/
+
+/* Convert between strings ans recurrencetype structures. */
+struct icalrecurrencetype icalrecurrencetype_from_string(const char* str);
+char* icalrecurrencetype_as_string(struct icalrecurrencetype *recur);
+
+
+/********** recurrence iteration routines ********************/
+
+typedef void icalrecur_iterator;
+
+/* Create a new recurrence rule iterator */
+icalrecur_iterator* icalrecur_iterator_new(struct icalrecurrencetype rule, 
+                                           struct icaltimetype dtstart);
+
+/* Get the next occurrence from an iterator */
+struct icaltimetype icalrecur_iterator_next(icalrecur_iterator*);
+
+/* Free the iterator */
+void icalrecur_iterator_free(icalrecur_iterator*);
+
+/* Fills array up with at most 'count' time_t values, each
+   representing an occurrence time in seconds past the POSIX epoch */
+int icalrecur_expand_recurrence(char* rule, time_t start, 
+                                int count, time_t* array);
+
+
+#endif
+/* -*- Mode: C -*- */
+/*======================================================================
+  FILE: icalvalue.h
+  CREATOR: eric 20 March 1999
+
+
+  $Id$
+  $Locker$
+
+  
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalvalue.h
+
+  ======================================================================*/
+
+#ifndef ICALDERIVEDVALUE_H
+#define ICALDERIVEDVALUE_H
+
+     
+typedef void icalvalue;
+
+
+
+void icalvalue_set_x(icalvalue* value, const char* v);
+icalvalue* icalvalue_new_x(const char* v);
+const char* icalvalue_get_x(icalvalue* value);
+
+icalvalue* icalvalue_new_attach (struct icalattachtype* v);
+void icalvalue_set_attach(icalvalue* value, struct icalattachtype* v);
+struct icalattachtype* icalvalue_get_attach(icalvalue* value);
+
+icalvalue* icalvalue_new_recur (struct icalrecurrencetype v);
+void icalvalue_set_recur(icalvalue* value, struct icalrecurrencetype v);
+struct icalrecurrencetype icalvalue_get_recur(icalvalue* value);
+
+icalvalue* icalvalue_new_trigger (struct icaltriggertype v);
+void icalvalue_set_trigger(icalvalue* value, struct icaltriggertype v);
+struct icaltriggertype icalvalue_get_trigger(icalvalue* value);
+
+icalvalue* icalvalue_new_datetimeperiod (struct icaldatetimeperiodtype v);
+void icalvalue_set_datetimeperiod(icalvalue* value, struct icaldatetimeperiodtype v);
+struct icaldatetimeperiodtype icalvalue_get_datetimeperiod(icalvalue* value);
+
+void icalvalue_reset_kind(icalvalue* value);
+
+/* Everything below this line is machine generated. Do not edit. */
+typedef enum icalvalue_kind {
+   ICAL_ANY_VALUE=5000,
+    ICAL_QUERY_VALUE=5001,
+    ICAL_TRIGGER_VALUE=5002,
+    ICAL_STATUS_VALUE=5003,
+    ICAL_TRANSP_VALUE=5004,
+    ICAL_CLASS_VALUE=5005,
+    ICAL_DATE_VALUE=5006,
+    ICAL_STRING_VALUE=5007,
+    ICAL_INTEGER_VALUE=5008,
+    ICAL_PERIOD_VALUE=5009,
+    ICAL_TEXT_VALUE=5010,
+    ICAL_DURATION_VALUE=5011,
+    ICAL_BOOLEAN_VALUE=5012,
+    ICAL_URI_VALUE=5013,
+    ICAL_DATETIMEPERIOD_VALUE=5014,
+    ICAL_GEO_VALUE=5015,
+    ICAL_DATETIME_VALUE=5016,
+    ICAL_UTCOFFSET_VALUE=5017,
+    ICAL_ATTACH_VALUE=5018,
+    ICAL_ACTION_VALUE=5019,
+    ICAL_CALADDRESS_VALUE=5020,
+    ICAL_X_VALUE=5021,
+    ICAL_FLOAT_VALUE=5022,
+    ICAL_REQUESTSTATUS_VALUE=5023,
+    ICAL_METHOD_VALUE=5024,
+    ICAL_BINARY_VALUE=5025,
+    ICAL_RECUR_VALUE=5026,
+   ICAL_NO_VALUE=5027
+} icalvalue_kind ;
+
+#define ICALPROPERTY_FIRST_ENUM 10000
+
+typedef enum icalproperty_action {
+    ICAL_ACTION_X = 10000,
+    ICAL_ACTION_AUDIO = 10001,
+    ICAL_ACTION_DISPLAY = 10002,
+    ICAL_ACTION_EMAIL = 10003,
+    ICAL_ACTION_PROCEDURE = 10004,
+    ICAL_ACTION_NONE = 10005
+} icalproperty_action;
+
+typedef enum icalproperty_class {
+    ICAL_CLASS_X = 10006,
+    ICAL_CLASS_PUBLIC = 10007,
+    ICAL_CLASS_PRIVATE = 10008,
+    ICAL_CLASS_CONFIDENTIAL = 10009,
+    ICAL_CLASS_NONE = 10010
+} icalproperty_class;
+
+typedef enum icalproperty_method {
+    ICAL_METHOD_X = 10011,
+    ICAL_METHOD_PUBLISH = 10012,
+    ICAL_METHOD_REQUEST = 10013,
+    ICAL_METHOD_REPLY = 10014,
+    ICAL_METHOD_ADD = 10015,
+    ICAL_METHOD_CANCEL = 10016,
+    ICAL_METHOD_REFRESH = 10017,
+    ICAL_METHOD_COUNTER = 10018,
+    ICAL_METHOD_DECLINECOUNTER = 10019,
+    ICAL_METHOD_CREATE = 10020,
+    ICAL_METHOD_READ = 10021,
+    ICAL_METHOD_RESPONSE = 10022,
+    ICAL_METHOD_MOVE = 10023,
+    ICAL_METHOD_MODIFY = 10024,
+    ICAL_METHOD_GENERATEUID = 10025,
+    ICAL_METHOD_DELETE = 10026,
+    ICAL_METHOD_NONE = 10027
+} icalproperty_method;
+
+typedef enum icalproperty_status {
+    ICAL_STATUS_X = 10028,
+    ICAL_STATUS_TENTATIVE = 10029,
+    ICAL_STATUS_CONFIRMED = 10030,
+    ICAL_STATUS_COMPLETED = 10031,
+    ICAL_STATUS_NEEDSACTION = 10032,
+    ICAL_STATUS_CANCELLED = 10033,
+    ICAL_STATUS_INPROCESS = 10034,
+    ICAL_STATUS_DRAFT = 10035,
+    ICAL_STATUS_FINAL = 10036,
+    ICAL_STATUS_NONE = 10037
+} icalproperty_status;
+
+typedef enum icalproperty_transp {
+    ICAL_TRANSP_X = 10038,
+    ICAL_TRANSP_OPAQUE = 10039,
+    ICAL_TRANSP_TRANSPARENT = 10040,
+    ICAL_TRANSP_NONE = 10041
+} icalproperty_transp;
+
+#define ICALPROPERTY_LAST_ENUM 10042
+
+
+ /* QUERY */ 
+icalvalue* icalvalue_new_query(const char* v); 
+const char* icalvalue_get_query(icalvalue* value); 
+void icalvalue_set_query(icalvalue* value, const char* v);
+
+
+ /* STATUS */ 
+icalvalue* icalvalue_new_status(enum icalproperty_status v); 
+enum icalproperty_status icalvalue_get_status(icalvalue* value); 
+void icalvalue_set_status(icalvalue* value, enum icalproperty_status v);
+
+
+ /* TRANSP */ 
+icalvalue* icalvalue_new_transp(enum icalproperty_transp v); 
+enum icalproperty_transp icalvalue_get_transp(icalvalue* value); 
+void icalvalue_set_transp(icalvalue* value, enum icalproperty_transp v);
+
+
+ /* CLASS */ 
+icalvalue* icalvalue_new_class(enum icalproperty_class v); 
+enum icalproperty_class icalvalue_get_class(icalvalue* value); 
+void icalvalue_set_class(icalvalue* value, enum icalproperty_class v);
+
+
+ /* DATE */ 
+icalvalue* icalvalue_new_date(struct icaltimetype v); 
+struct icaltimetype icalvalue_get_date(icalvalue* value); 
+void icalvalue_set_date(icalvalue* value, struct icaltimetype v);
+
+
+ /* STRING */ 
+icalvalue* icalvalue_new_string(const char* v); 
+const char* icalvalue_get_string(icalvalue* value); 
+void icalvalue_set_string(icalvalue* value, const char* v);
+
+
+ /* INTEGER */ 
+icalvalue* icalvalue_new_integer(int v); 
+int icalvalue_get_integer(icalvalue* value); 
+void icalvalue_set_integer(icalvalue* value, int v);
+
+
+ /* PERIOD */ 
+icalvalue* icalvalue_new_period(struct icalperiodtype v); 
+struct icalperiodtype icalvalue_get_period(icalvalue* value); 
+void icalvalue_set_period(icalvalue* value, struct icalperiodtype v);
+
+
+ /* TEXT */ 
+icalvalue* icalvalue_new_text(const char* v); 
+const char* icalvalue_get_text(icalvalue* value); 
+void icalvalue_set_text(icalvalue* value, const char* v);
+
+
+ /* DURATION */ 
+icalvalue* icalvalue_new_duration(struct icaldurationtype v); 
+struct icaldurationtype icalvalue_get_duration(icalvalue* value); 
+void icalvalue_set_duration(icalvalue* value, struct icaldurationtype v);
+
+
+ /* BOOLEAN */ 
+icalvalue* icalvalue_new_boolean(int v); 
+int icalvalue_get_boolean(icalvalue* value); 
+void icalvalue_set_boolean(icalvalue* value, int v);
+
+
+ /* URI */ 
+icalvalue* icalvalue_new_uri(const char* v); 
+const char* icalvalue_get_uri(icalvalue* value); 
+void icalvalue_set_uri(icalvalue* value, const char* v);
+
+
+ /* GEO */ 
+icalvalue* icalvalue_new_geo(struct icalgeotype v); 
+struct icalgeotype icalvalue_get_geo(icalvalue* value); 
+void icalvalue_set_geo(icalvalue* value, struct icalgeotype v);
+
+
+ /* DATE-TIME */ 
+icalvalue* icalvalue_new_datetime(struct icaltimetype v); 
+struct icaltimetype icalvalue_get_datetime(icalvalue* value); 
+void icalvalue_set_datetime(icalvalue* value, struct icaltimetype v);
+
+
+ /* UTC-OFFSET */ 
+icalvalue* icalvalue_new_utcoffset(int v); 
+int icalvalue_get_utcoffset(icalvalue* value); 
+void icalvalue_set_utcoffset(icalvalue* value, int v);
+
+
+ /* ACTION */ 
+icalvalue* icalvalue_new_action(enum icalproperty_action v); 
+enum icalproperty_action icalvalue_get_action(icalvalue* value); 
+void icalvalue_set_action(icalvalue* value, enum icalproperty_action v);
+
+
+ /* CAL-ADDRESS */ 
+icalvalue* icalvalue_new_caladdress(const char* v); 
+const char* icalvalue_get_caladdress(icalvalue* value); 
+void icalvalue_set_caladdress(icalvalue* value, const char* v);
+
+
+ /* FLOAT */ 
+icalvalue* icalvalue_new_float(float v); 
+float icalvalue_get_float(icalvalue* value); 
+void icalvalue_set_float(icalvalue* value, float v);
+
+
+ /* REQUEST-STATUS */ 
+icalvalue* icalvalue_new_requeststatus(struct icalreqstattype v); 
+struct icalreqstattype icalvalue_get_requeststatus(icalvalue* value); 
+void icalvalue_set_requeststatus(icalvalue* value, struct icalreqstattype v);
+
+
+ /* METHOD */ 
+icalvalue* icalvalue_new_method(enum icalproperty_method v); 
+enum icalproperty_method icalvalue_get_method(icalvalue* value); 
+void icalvalue_set_method(icalvalue* value, enum icalproperty_method v);
+
+
+ /* BINARY */ 
+icalvalue* icalvalue_new_binary(const char* v); 
+const char* icalvalue_get_binary(icalvalue* value); 
+void icalvalue_set_binary(icalvalue* value, const char* v);
+
+#endif /*ICALVALUE_H*/
+/* -*- Mode: C -*- */
+/*======================================================================
+  FILE: icalparam.h
+  CREATOR: eric 20 March 1999
+
+
+  $Id$
+  $Locker$
+
+  
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalparam.h
+
+  ======================================================================*/
+
+#ifndef ICALDERIVEDPARAMETER_H
+#define ICALDERIVEDPARAMETER_H
+
+
+typedef void icalparameter;
+
+const char* icalparameter_enum_to_string(int e);
+int icalparameter_string_to_enum(const char* str); 
+
+/* Everything below this line is machine generated. Do not edit. */
+typedef enum icalparameter_kind {
+    ICAL_ANY_PARAMETER = 0,
+    ICAL_ALTREP_PARAMETER, 
+    ICAL_CN_PARAMETER, 
+    ICAL_CUTYPE_PARAMETER, 
+    ICAL_DELEGATEDFROM_PARAMETER, 
+    ICAL_DELEGATEDTO_PARAMETER, 
+    ICAL_DIR_PARAMETER, 
+    ICAL_ENCODING_PARAMETER, 
+    ICAL_FBTYPE_PARAMETER, 
+    ICAL_FMTTYPE_PARAMETER, 
+    ICAL_LANGUAGE_PARAMETER, 
+    ICAL_MEMBER_PARAMETER, 
+    ICAL_PARTSTAT_PARAMETER, 
+    ICAL_RANGE_PARAMETER, 
+    ICAL_RELATED_PARAMETER, 
+    ICAL_RELTYPE_PARAMETER, 
+    ICAL_ROLE_PARAMETER, 
+    ICAL_RSVP_PARAMETER, 
+    ICAL_SENTBY_PARAMETER, 
+    ICAL_TZID_PARAMETER, 
+    ICAL_VALUE_PARAMETER, 
+    ICAL_X_PARAMETER, 
+    ICAL_XLICCOMPARETYPE_PARAMETER, 
+    ICAL_XLICERRORTYPE_PARAMETER, 
+    ICAL_NO_PARAMETER
+} icalparameter_kind;
+
+#define ICALPARAMETER_FIRST_ENUM 20000
+
+typedef enum icalparameter_cutype {
+    ICAL_CUTYPE_X = 20000,
+    ICAL_CUTYPE_INDIVIDUAL = 20001,
+    ICAL_CUTYPE_GROUP = 20002,
+    ICAL_CUTYPE_RESOURCE = 20003,
+    ICAL_CUTYPE_ROOM = 20004,
+    ICAL_CUTYPE_UNKNOWN = 20005,
+    ICAL_CUTYPE_NONE = 20006
+} icalparameter_cutype;
+
+typedef enum icalparameter_encoding {
+    ICAL_ENCODING_X = 20007,
+    ICAL_ENCODING_8BIT = 20008,
+    ICAL_ENCODING_BASE64 = 20009,
+    ICAL_ENCODING_NONE = 20010
+} icalparameter_encoding;
+
+typedef enum icalparameter_fbtype {
+    ICAL_FBTYPE_X = 20011,
+    ICAL_FBTYPE_FREE = 20012,
+    ICAL_FBTYPE_BUSY = 20013,
+    ICAL_FBTYPE_BUSYUNAVAILABLE = 20014,
+    ICAL_FBTYPE_BUSYTENTATIVE = 20015,
+    ICAL_FBTYPE_NONE = 20016
+} icalparameter_fbtype;
+
+typedef enum icalparameter_partstat {
+    ICAL_PARTSTAT_X = 20017,
+    ICAL_PARTSTAT_NEEDSACTION = 20018,
+    ICAL_PARTSTAT_ACCEPTED = 20019,
+    ICAL_PARTSTAT_DECLINED = 20020,
+    ICAL_PARTSTAT_TENTATIVE = 20021,
+    ICAL_PARTSTAT_DELEGATED = 20022,
+    ICAL_PARTSTAT_COMPLETED = 20023,
+    ICAL_PARTSTAT_INPROCESS = 20024,
+    ICAL_PARTSTAT_NONE = 20025
+} icalparameter_partstat;
+
+typedef enum icalparameter_range {
+    ICAL_RANGE_X = 20026,
+    ICAL_RANGE_THISANDPRIOR = 20027,
+    ICAL_RANGE_THISANDFUTURE = 20028,
+    ICAL_RANGE_NONE = 20029
+} icalparameter_range;
+
+typedef enum icalparameter_related {
+    ICAL_RELATED_X = 20030,
+    ICAL_RELATED_START = 20031,
+    ICAL_RELATED_END  = 20032,
+    ICAL_RELATED_NONE = 20033
+} icalparameter_related;
+
+typedef enum icalparameter_reltype {
+    ICAL_RELTYPE_X = 20034,
+    ICAL_RELTYPE_PARENT = 20035,
+    ICAL_RELTYPE_CHILD = 20036,
+    ICAL_RELTYPE_SIBLING = 20037,
+    ICAL_RELTYPE_NONE = 20038
+} icalparameter_reltype;
+
+typedef enum icalparameter_role {
+    ICAL_ROLE_X = 20039,
+    ICAL_ROLE_CHAIR = 20040,
+    ICAL_ROLE_REQPARTICIPANT = 20041,
+    ICAL_ROLE_OPTPARTICIPANT = 20042,
+    ICAL_ROLE_NONPARTICIPANT = 20043,
+    ICAL_ROLE_NONE = 20044
+} icalparameter_role;
+
+typedef enum icalparameter_rsvp {
+    ICAL_RSVP_X = 20045,
+    ICAL_RSVP_TRUE = 20046,
+    ICAL_RSVP_FALSE = 20047,
+    ICAL_RSVP_NONE = 20048
+} icalparameter_rsvp;
+
+typedef enum icalparameter_value {
+    ICAL_VALUE_X = 20049,
+    ICAL_VALUE_BINARY = 20050,
+    ICAL_VALUE_BOOLEAN = 20051,
+    ICAL_VALUE_DATE = 20052,
+    ICAL_VALUE_DURATION = 20053,
+    ICAL_VALUE_FLOAT = 20054,
+    ICAL_VALUE_INTEGER = 20055,
+    ICAL_VALUE_PERIOD = 20056,
+    ICAL_VALUE_RECUR = 20057,
+    ICAL_VALUE_TEXT = 20058,
+    ICAL_VALUE_URI = 20059,
+    ICAL_VALUE_ERROR = 20060,
+    ICAL_VALUE_DATETIME = 20061,
+    ICAL_VALUE_UTCOFFSET = 20062,
+    ICAL_VALUE_CALADDRESS = 20063,
+    ICAL_VALUE_NONE = 20064
+} icalparameter_value;
+
+typedef enum icalparameter_xliccomparetype {
+    ICAL_XLICCOMPARETYPE_X = 20065,
+    ICAL_XLICCOMPARETYPE_EQUAL = 20066,
+    ICAL_XLICCOMPARETYPE_NOTEQUAL = 20067,
+    ICAL_XLICCOMPARETYPE_LESS = 20068,
+    ICAL_XLICCOMPARETYPE_GREATER = 20069,
+    ICAL_XLICCOMPARETYPE_LESSEQUAL = 20070,
+    ICAL_XLICCOMPARETYPE_GREATEREQUAL = 20071,
+    ICAL_XLICCOMPARETYPE_REGEX = 20072,
+    ICAL_XLICCOMPARETYPE_NONE = 20073
+} icalparameter_xliccomparetype;
+
+typedef enum icalparameter_xlicerrortype {
+    ICAL_XLICERRORTYPE_X = 20074,
+    ICAL_XLICERRORTYPE_COMPONENTPARSEERROR = 20075,
+    ICAL_XLICERRORTYPE_PROPERTYPARSEERROR = 20076,
+    ICAL_XLICERRORTYPE_PARAMETERNAMEPARSEERROR = 20077,
+    ICAL_XLICERRORTYPE_PARAMETERVALUEPARSEERROR = 20078,
+    ICAL_XLICERRORTYPE_VALUEPARSEERROR = 20079,
+    ICAL_XLICERRORTYPE_INVALIDITIP = 20080,
+    ICAL_XLICERRORTYPE_UNKNOWNVCALPROPERROR = 20081,
+    ICAL_XLICERRORTYPE_MIMEPARSEERROR = 20082,
+    ICAL_XLICERRORTYPE_NONE = 20083
+} icalparameter_xlicerrortype;
+
+#define ICALPARAMETER_LAST_ENUM 20084
+
+/* DELEGATED-FROM */
+icalparameter* icalparameter_new_delegatedfrom(const char* v);
+const char* icalparameter_get_delegatedfrom(icalparameter* value);
+void icalparameter_set_delegatedfrom(icalparameter* value, const char* v);
+
+/* DELEGATED-TO */
+icalparameter* icalparameter_new_delegatedto(const char* v);
+const char* icalparameter_get_delegatedto(icalparameter* value);
+void icalparameter_set_delegatedto(icalparameter* value, const char* v);
+
+/* RANGE */
+icalparameter* icalparameter_new_range(icalparameter_range v);
+icalparameter_range icalparameter_get_range(icalparameter* value);
+void icalparameter_set_range(icalparameter* value, icalparameter_range v);
+
+/* ENCODING */
+icalparameter* icalparameter_new_encoding(icalparameter_encoding v);
+icalparameter_encoding icalparameter_get_encoding(icalparameter* value);
+void icalparameter_set_encoding(icalparameter* value, icalparameter_encoding v);
+
+/* RSVP */
+icalparameter* icalparameter_new_rsvp(icalparameter_rsvp v);
+icalparameter_rsvp icalparameter_get_rsvp(icalparameter* value);
+void icalparameter_set_rsvp(icalparameter* value, icalparameter_rsvp v);
+
+/* PARTSTAT */
+icalparameter* icalparameter_new_partstat(icalparameter_partstat v);
+icalparameter_partstat icalparameter_get_partstat(icalparameter* value);
+void icalparameter_set_partstat(icalparameter* value, icalparameter_partstat v);
+
+/* RELTYPE */
+icalparameter* icalparameter_new_reltype(icalparameter_reltype v);
+icalparameter_reltype icalparameter_get_reltype(icalparameter* value);
+void icalparameter_set_reltype(icalparameter* value, icalparameter_reltype v);
+
+/* CUTYPE */
+icalparameter* icalparameter_new_cutype(icalparameter_cutype v);
+icalparameter_cutype icalparameter_get_cutype(icalparameter* value);
+void icalparameter_set_cutype(icalparameter* value, icalparameter_cutype v);
+
+/* MEMBER */
+icalparameter* icalparameter_new_member(const char* v);
+const char* icalparameter_get_member(icalparameter* value);
+void icalparameter_set_member(icalparameter* value, const char* v);
+
+/* FMTTYPE */
+icalparameter* icalparameter_new_fmttype(const char* v);
+const char* icalparameter_get_fmttype(icalparameter* value);
+void icalparameter_set_fmttype(icalparameter* value, const char* v);
+
+/* SENT-BY */
+icalparameter* icalparameter_new_sentby(const char* v);
+const char* icalparameter_get_sentby(icalparameter* value);
+void icalparameter_set_sentby(icalparameter* value, const char* v);
+
+/* VALUE */
+icalparameter* icalparameter_new_value(icalparameter_value v);
+icalparameter_value icalparameter_get_value(icalparameter* value);
+void icalparameter_set_value(icalparameter* value, icalparameter_value v);
+
+/* ALTREP */
+icalparameter* icalparameter_new_altrep(const char* v);
+const char* icalparameter_get_altrep(icalparameter* value);
+void icalparameter_set_altrep(icalparameter* value, const char* v);
+
+/* DIR */
+icalparameter* icalparameter_new_dir(const char* v);
+const char* icalparameter_get_dir(icalparameter* value);
+void icalparameter_set_dir(icalparameter* value, const char* v);
+
+/* RELATED */
+icalparameter* icalparameter_new_related(icalparameter_related v);
+icalparameter_related icalparameter_get_related(icalparameter* value);
+void icalparameter_set_related(icalparameter* value, icalparameter_related v);
+
+/* CN */
+icalparameter* icalparameter_new_cn(const char* v);
+const char* icalparameter_get_cn(icalparameter* value);
+void icalparameter_set_cn(icalparameter* value, const char* v);
+
+/* X-LIC-ERRORTYPE */
+icalparameter* icalparameter_new_xlicerrortype(icalparameter_xlicerrortype v);
+icalparameter_xlicerrortype icalparameter_get_xlicerrortype(icalparameter* value);
+void icalparameter_set_xlicerrortype(icalparameter* value, icalparameter_xlicerrortype v);
+
+/* X */
+icalparameter* icalparameter_new_x(const char* v);
+const char* icalparameter_get_x(icalparameter* value);
+void icalparameter_set_x(icalparameter* value, const char* v);
+
+/* LANGUAGE */
+icalparameter* icalparameter_new_language(const char* v);
+const char* icalparameter_get_language(icalparameter* value);
+void icalparameter_set_language(icalparameter* value, const char* v);
+
+/* ROLE */
+icalparameter* icalparameter_new_role(icalparameter_role v);
+icalparameter_role icalparameter_get_role(icalparameter* value);
+void icalparameter_set_role(icalparameter* value, icalparameter_role v);
+
+/* X-LIC-COMPARETYPE */
+icalparameter* icalparameter_new_xliccomparetype(icalparameter_xliccomparetype v);
+icalparameter_xliccomparetype icalparameter_get_xliccomparetype(icalparameter* value);
+void icalparameter_set_xliccomparetype(icalparameter* value, icalparameter_xliccomparetype v);
+
+/* FBTYPE */
+icalparameter* icalparameter_new_fbtype(icalparameter_fbtype v);
+icalparameter_fbtype icalparameter_get_fbtype(icalparameter* value);
+void icalparameter_set_fbtype(icalparameter* value, icalparameter_fbtype v);
+
+/* TZID */
+icalparameter* icalparameter_new_tzid(const char* v);
+const char* icalparameter_get_tzid(icalparameter* value);
+void icalparameter_set_tzid(icalparameter* value, const char* v);
+
+#endif /*ICALPARAMETER_H*/
+
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: icalderivedproperties.{c,h}
+  CREATOR: eric 09 May 1999
+  
+  $Id$
+    
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+ ======================================================================*/
+
+
+#ifndef ICALDERIVEDPROPERTY_H
+#define ICALDERIVEDPROPERTY_H
+
+#include <time.h>
+
+typedef void icalproperty;
+
+
+/* Everything below this line is machine generated. Do not edit. */
+typedef enum icalproperty_kind {
+    ICAL_ANY_PROPERTY = 0,
+    ICAL_ACTION_PROPERTY, 
+    ICAL_ATTACH_PROPERTY, 
+    ICAL_ATTENDEE_PROPERTY, 
+    ICAL_CALSCALE_PROPERTY, 
+    ICAL_CATEGORIES_PROPERTY, 
+    ICAL_CLASS_PROPERTY, 
+    ICAL_COMMENT_PROPERTY, 
+    ICAL_COMPLETED_PROPERTY, 
+    ICAL_CONTACT_PROPERTY, 
+    ICAL_CREATED_PROPERTY, 
+    ICAL_DESCRIPTION_PROPERTY, 
+    ICAL_DTEND_PROPERTY, 
+    ICAL_DTSTAMP_PROPERTY, 
+    ICAL_DTSTART_PROPERTY, 
+    ICAL_DUE_PROPERTY, 
+    ICAL_DURATION_PROPERTY, 
+    ICAL_EXDATE_PROPERTY, 
+    ICAL_EXRULE_PROPERTY, 
+    ICAL_FREEBUSY_PROPERTY, 
+    ICAL_GEO_PROPERTY, 
+    ICAL_LASTMODIFIED_PROPERTY, 
+    ICAL_LOCATION_PROPERTY, 
+    ICAL_MAXRESULTS_PROPERTY, 
+    ICAL_MAXRESULTSSIZE_PROPERTY, 
+    ICAL_METHOD_PROPERTY, 
+    ICAL_ORGANIZER_PROPERTY, 
+    ICAL_PERCENTCOMPLETE_PROPERTY, 
+    ICAL_PRIORITY_PROPERTY, 
+    ICAL_PRODID_PROPERTY, 
+    ICAL_QUERY_PROPERTY, 
+    ICAL_QUERYNAME_PROPERTY, 
+    ICAL_RDATE_PROPERTY, 
+    ICAL_RECURRENCEID_PROPERTY, 
+    ICAL_RELATEDTO_PROPERTY, 
+    ICAL_REPEAT_PROPERTY, 
+    ICAL_REQUESTSTATUS_PROPERTY, 
+    ICAL_RESOURCES_PROPERTY, 
+    ICAL_RRULE_PROPERTY, 
+    ICAL_SCOPE_PROPERTY, 
+    ICAL_SEQUENCE_PROPERTY, 
+    ICAL_STATUS_PROPERTY, 
+    ICAL_SUMMARY_PROPERTY, 
+    ICAL_TARGET_PROPERTY, 
+    ICAL_TRANSP_PROPERTY, 
+    ICAL_TRIGGER_PROPERTY, 
+    ICAL_TZID_PROPERTY, 
+    ICAL_TZNAME_PROPERTY, 
+    ICAL_TZOFFSETFROM_PROPERTY, 
+    ICAL_TZOFFSETTO_PROPERTY, 
+    ICAL_TZURL_PROPERTY, 
+    ICAL_UID_PROPERTY, 
+    ICAL_URL_PROPERTY, 
+    ICAL_VERSION_PROPERTY, 
+    ICAL_X_PROPERTY, 
+    ICAL_XLICCLUSTERCOUNT_PROPERTY, 
+    ICAL_XLICERROR_PROPERTY, 
+    ICAL_XLICMIMECHARSET_PROPERTY, 
+    ICAL_XLICMIMECID_PROPERTY, 
+    ICAL_XLICMIMECONTENTTYPE_PROPERTY, 
+    ICAL_XLICMIMEENCODING_PROPERTY, 
+    ICAL_XLICMIMEFILENAME_PROPERTY, 
+    ICAL_XLICMIMEOPTINFO_PROPERTY, 
+    ICAL_NO_PROPERTY
+} icalproperty_kind;
+
+icalproperty* icalproperty_vanew_action(enum icalproperty_action v, ...);
+
+/* ACTION */
+icalproperty* icalproperty_new_action(enum icalproperty_action v);
+void icalproperty_set_action(icalproperty* prop, enum icalproperty_action v);
+enum icalproperty_action icalproperty_get_action(icalproperty* prop);icalproperty* icalproperty_vanew_attach(struct icalattachtype* v, ...);
+
+/* ATTACH */
+icalproperty* icalproperty_new_attach(struct icalattachtype* v);
+void icalproperty_set_attach(icalproperty* prop, struct icalattachtype* v);
+struct icalattachtype* icalproperty_get_attach(icalproperty* prop);icalproperty* icalproperty_vanew_attendee(const char* v, ...);
+
+/* ATTENDEE */
+icalproperty* icalproperty_new_attendee(const char* v);
+void icalproperty_set_attendee(icalproperty* prop, const char* v);
+const char* icalproperty_get_attendee(icalproperty* prop);icalproperty* icalproperty_vanew_calscale(const char* v, ...);
+
+/* CALSCALE */
+icalproperty* icalproperty_new_calscale(const char* v);
+void icalproperty_set_calscale(icalproperty* prop, const char* v);
+const char* icalproperty_get_calscale(icalproperty* prop);icalproperty* icalproperty_vanew_categories(const char* v, ...);
+
+/* CATEGORIES */
+icalproperty* icalproperty_new_categories(const char* v);
+void icalproperty_set_categories(icalproperty* prop, const char* v);
+const char* icalproperty_get_categories(icalproperty* prop);icalproperty* icalproperty_vanew_class(const char* v, ...);
+
+/* CLASS */
+icalproperty* icalproperty_new_class(const char* v);
+void icalproperty_set_class(icalproperty* prop, const char* v);
+const char* icalproperty_get_class(icalproperty* prop);icalproperty* icalproperty_vanew_comment(const char* v, ...);
+
+/* COMMENT */
+icalproperty* icalproperty_new_comment(const char* v);
+void icalproperty_set_comment(icalproperty* prop, const char* v);
+const char* icalproperty_get_comment(icalproperty* prop);icalproperty* icalproperty_vanew_completed(struct icaltimetype v, ...);
+
+/* COMPLETED */
+icalproperty* icalproperty_new_completed(struct icaltimetype v);
+void icalproperty_set_completed(icalproperty* prop, struct icaltimetype v);
+struct icaltimetype icalproperty_get_completed(icalproperty* prop);icalproperty* icalproperty_vanew_contact(const char* v, ...);
+
+/* CONTACT */
+icalproperty* icalproperty_new_contact(const char* v);
+void icalproperty_set_contact(icalproperty* prop, const char* v);
+const char* icalproperty_get_contact(icalproperty* prop);icalproperty* icalproperty_vanew_created(struct icaltimetype v, ...);
+
+/* CREATED */
+icalproperty* icalproperty_new_created(struct icaltimetype v);
+void icalproperty_set_created(icalproperty* prop, struct icaltimetype v);
+struct icaltimetype icalproperty_get_created(icalproperty* prop);icalproperty* icalproperty_vanew_description(const char* v, ...);
+
+/* DESCRIPTION */
+icalproperty* icalproperty_new_description(const char* v);
+void icalproperty_set_description(icalproperty* prop, const char* v);
+const char* icalproperty_get_description(icalproperty* prop);icalproperty* icalproperty_vanew_dtend(struct icaltimetype v, ...);
+
+/* DTEND */
+icalproperty* icalproperty_new_dtend(struct icaltimetype v);
+void icalproperty_set_dtend(icalproperty* prop, struct icaltimetype v);
+struct icaltimetype icalproperty_get_dtend(icalproperty* prop);icalproperty* icalproperty_vanew_dtstamp(struct icaltimetype v, ...);
+
+/* DTSTAMP */
+icalproperty* icalproperty_new_dtstamp(struct icaltimetype v);
+void icalproperty_set_dtstamp(icalproperty* prop, struct icaltimetype v);
+struct icaltimetype icalproperty_get_dtstamp(icalproperty* prop);icalproperty* icalproperty_vanew_dtstart(struct icaltimetype v, ...);
+
+/* DTSTART */
+icalproperty* icalproperty_new_dtstart(struct icaltimetype v);
+void icalproperty_set_dtstart(icalproperty* prop, struct icaltimetype v);
+struct icaltimetype icalproperty_get_dtstart(icalproperty* prop);icalproperty* icalproperty_vanew_due(struct icaltimetype v, ...);
+
+/* DUE */
+icalproperty* icalproperty_new_due(struct icaltimetype v);
+void icalproperty_set_due(icalproperty* prop, struct icaltimetype v);
+struct icaltimetype icalproperty_get_due(icalproperty* prop);icalproperty* icalproperty_vanew_duration(struct icaldurationtype v, ...);
+
+/* DURATION */
+icalproperty* icalproperty_new_duration(struct icaldurationtype v);
+void icalproperty_set_duration(icalproperty* prop, struct icaldurationtype v);
+struct icaldurationtype icalproperty_get_duration(icalproperty* prop);icalproperty* icalproperty_vanew_exdate(struct icaltimetype v, ...);
+
+/* EXDATE */
+icalproperty* icalproperty_new_exdate(struct icaltimetype v);
+void icalproperty_set_exdate(icalproperty* prop, struct icaltimetype v);
+struct icaltimetype icalproperty_get_exdate(icalproperty* prop);icalproperty* icalproperty_vanew_exrule(struct icalrecurrencetype v, ...);
+
+/* EXRULE */
+icalproperty* icalproperty_new_exrule(struct icalrecurrencetype v);
+void icalproperty_set_exrule(icalproperty* prop, struct icalrecurrencetype v);
+struct icalrecurrencetype icalproperty_get_exrule(icalproperty* prop);icalproperty* icalproperty_vanew_freebusy(struct icalperiodtype v, ...);
+
+/* FREEBUSY */
+icalproperty* icalproperty_new_freebusy(struct icalperiodtype v);
+void icalproperty_set_freebusy(icalproperty* prop, struct icalperiodtype v);
+struct icalperiodtype icalproperty_get_freebusy(icalproperty* prop);icalproperty* icalproperty_vanew_geo(struct icalgeotype v, ...);
+
+/* GEO */
+icalproperty* icalproperty_new_geo(struct icalgeotype v);
+void icalproperty_set_geo(icalproperty* prop, struct icalgeotype v);
+struct icalgeotype icalproperty_get_geo(icalproperty* prop);icalproperty* icalproperty_vanew_lastmodified(struct icaltimetype v, ...);
+
+/* LAST-MODIFIED */
+icalproperty* icalproperty_new_lastmodified(struct icaltimetype v);
+void icalproperty_set_lastmodified(icalproperty* prop, struct icaltimetype v);
+struct icaltimetype icalproperty_get_lastmodified(icalproperty* prop);icalproperty* icalproperty_vanew_location(const char* v, ...);
+
+/* LOCATION */
+icalproperty* icalproperty_new_location(const char* v);
+void icalproperty_set_location(icalproperty* prop, const char* v);
+const char* icalproperty_get_location(icalproperty* prop);icalproperty* icalproperty_vanew_maxresults(int v, ...);
+
+/* MAXRESULTS */
+icalproperty* icalproperty_new_maxresults(int v);
+void icalproperty_set_maxresults(icalproperty* prop, int v);
+int icalproperty_get_maxresults(icalproperty* prop);icalproperty* icalproperty_vanew_maxresultssize(int v, ...);
+
+/* MAXRESULTSSIZE */
+icalproperty* icalproperty_new_maxresultssize(int v);
+void icalproperty_set_maxresultssize(icalproperty* prop, int v);
+int icalproperty_get_maxresultssize(icalproperty* prop);icalproperty* icalproperty_vanew_method(enum icalproperty_method v, ...);
+
+/* METHOD */
+icalproperty* icalproperty_new_method(enum icalproperty_method v);
+void icalproperty_set_method(icalproperty* prop, enum icalproperty_method v);
+enum icalproperty_method icalproperty_get_method(icalproperty* prop);icalproperty* icalproperty_vanew_organizer(const char* v, ...);
+
+/* ORGANIZER */
+icalproperty* icalproperty_new_organizer(const char* v);
+void icalproperty_set_organizer(icalproperty* prop, const char* v);
+const char* icalproperty_get_organizer(icalproperty* prop);icalproperty* icalproperty_vanew_percentcomplete(int v, ...);
+
+/* PERCENT-COMPLETE */
+icalproperty* icalproperty_new_percentcomplete(int v);
+void icalproperty_set_percentcomplete(icalproperty* prop, int v);
+int icalproperty_get_percentcomplete(icalproperty* prop);icalproperty* icalproperty_vanew_priority(int v, ...);
+
+/* PRIORITY */
+icalproperty* icalproperty_new_priority(int v);
+void icalproperty_set_priority(icalproperty* prop, int v);
+int icalproperty_get_priority(icalproperty* prop);icalproperty* icalproperty_vanew_prodid(const char* v, ...);
+
+/* PRODID */
+icalproperty* icalproperty_new_prodid(const char* v);
+void icalproperty_set_prodid(icalproperty* prop, const char* v);
+const char* icalproperty_get_prodid(icalproperty* prop);icalproperty* icalproperty_vanew_query(const char* v, ...);
+
+/* QUERY */
+icalproperty* icalproperty_new_query(const char* v);
+void icalproperty_set_query(icalproperty* prop, const char* v);
+const char* icalproperty_get_query(icalproperty* prop);icalproperty* icalproperty_vanew_queryname(const char* v, ...);
+
+/* QUERYNAME */
+icalproperty* icalproperty_new_queryname(const char* v);
+void icalproperty_set_queryname(icalproperty* prop, const char* v);
+const char* icalproperty_get_queryname(icalproperty* prop);icalproperty* icalproperty_vanew_rdate(struct icaldatetimeperiodtype v, ...);
+
+/* RDATE */
+icalproperty* icalproperty_new_rdate(struct icaldatetimeperiodtype v);
+void icalproperty_set_rdate(icalproperty* prop, struct icaldatetimeperiodtype v);
+struct icaldatetimeperiodtype icalproperty_get_rdate(icalproperty* prop);icalproperty* icalproperty_vanew_recurrenceid(struct icaltimetype v, ...);
+
+/* RECURRENCE-ID */
+icalproperty* icalproperty_new_recurrenceid(struct icaltimetype v);
+void icalproperty_set_recurrenceid(icalproperty* prop, struct icaltimetype v);
+struct icaltimetype icalproperty_get_recurrenceid(icalproperty* prop);icalproperty* icalproperty_vanew_relatedto(const char* v, ...);
+
+/* RELATED-TO */
+icalproperty* icalproperty_new_relatedto(const char* v);
+void icalproperty_set_relatedto(icalproperty* prop, const char* v);
+const char* icalproperty_get_relatedto(icalproperty* prop);icalproperty* icalproperty_vanew_repeat(int v, ...);
+
+/* REPEAT */
+icalproperty* icalproperty_new_repeat(int v);
+void icalproperty_set_repeat(icalproperty* prop, int v);
+int icalproperty_get_repeat(icalproperty* prop);icalproperty* icalproperty_vanew_requeststatus(struct icalreqstattype v, ...);
+
+/* REQUEST-STATUS */
+icalproperty* icalproperty_new_requeststatus(struct icalreqstattype v);
+void icalproperty_set_requeststatus(icalproperty* prop, struct icalreqstattype v);
+struct icalreqstattype icalproperty_get_requeststatus(icalproperty* prop);icalproperty* icalproperty_vanew_resources(const char* v, ...);
+
+/* RESOURCES */
+icalproperty* icalproperty_new_resources(const char* v);
+void icalproperty_set_resources(icalproperty* prop, const char* v);
+const char* icalproperty_get_resources(icalproperty* prop);icalproperty* icalproperty_vanew_rrule(struct icalrecurrencetype v, ...);
+
+/* RRULE */
+icalproperty* icalproperty_new_rrule(struct icalrecurrencetype v);
+void icalproperty_set_rrule(icalproperty* prop, struct icalrecurrencetype v);
+struct icalrecurrencetype icalproperty_get_rrule(icalproperty* prop);icalproperty* icalproperty_vanew_scope(const char* v, ...);
+
+/* SCOPE */
+icalproperty* icalproperty_new_scope(const char* v);
+void icalproperty_set_scope(icalproperty* prop, const char* v);
+const char* icalproperty_get_scope(icalproperty* prop);icalproperty* icalproperty_vanew_sequence(int v, ...);
+
+/* SEQUENCE */
+icalproperty* icalproperty_new_sequence(int v);
+void icalproperty_set_sequence(icalproperty* prop, int v);
+int icalproperty_get_sequence(icalproperty* prop);icalproperty* icalproperty_vanew_status(enum icalproperty_status v, ...);
+
+/* STATUS */
+icalproperty* icalproperty_new_status(enum icalproperty_status v);
+void icalproperty_set_status(icalproperty* prop, enum icalproperty_status v);
+enum icalproperty_status icalproperty_get_status(icalproperty* prop);icalproperty* icalproperty_vanew_summary(const char* v, ...);
+
+/* SUMMARY */
+icalproperty* icalproperty_new_summary(const char* v);
+void icalproperty_set_summary(icalproperty* prop, const char* v);
+const char* icalproperty_get_summary(icalproperty* prop);icalproperty* icalproperty_vanew_target(const char* v, ...);
+
+/* TARGET */
+icalproperty* icalproperty_new_target(const char* v);
+void icalproperty_set_target(icalproperty* prop, const char* v);
+const char* icalproperty_get_target(icalproperty* prop);icalproperty* icalproperty_vanew_transp(const char* v, ...);
+
+/* TRANSP */
+icalproperty* icalproperty_new_transp(const char* v);
+void icalproperty_set_transp(icalproperty* prop, const char* v);
+const char* icalproperty_get_transp(icalproperty* prop);icalproperty* icalproperty_vanew_trigger(struct icaltriggertype v, ...);
+
+/* TRIGGER */
+icalproperty* icalproperty_new_trigger(struct icaltriggertype v);
+void icalproperty_set_trigger(icalproperty* prop, struct icaltriggertype v);
+struct icaltriggertype icalproperty_get_trigger(icalproperty* prop);icalproperty* icalproperty_vanew_tzid(const char* v, ...);
+
+/* TZID */
+icalproperty* icalproperty_new_tzid(const char* v);
+void icalproperty_set_tzid(icalproperty* prop, const char* v);
+const char* icalproperty_get_tzid(icalproperty* prop);icalproperty* icalproperty_vanew_tzname(const char* v, ...);
+
+/* TZNAME */
+icalproperty* icalproperty_new_tzname(const char* v);
+void icalproperty_set_tzname(icalproperty* prop, const char* v);
+const char* icalproperty_get_tzname(icalproperty* prop);icalproperty* icalproperty_vanew_tzoffsetfrom(int v, ...);
+
+/* TZOFFSETFROM */
+icalproperty* icalproperty_new_tzoffsetfrom(int v);
+void icalproperty_set_tzoffsetfrom(icalproperty* prop, int v);
+int icalproperty_get_tzoffsetfrom(icalproperty* prop);icalproperty* icalproperty_vanew_tzoffsetto(int v, ...);
+
+/* TZOFFSETTO */
+icalproperty* icalproperty_new_tzoffsetto(int v);
+void icalproperty_set_tzoffsetto(icalproperty* prop, int v);
+int icalproperty_get_tzoffsetto(icalproperty* prop);icalproperty* icalproperty_vanew_tzurl(const char* v, ...);
+
+/* TZURL */
+icalproperty* icalproperty_new_tzurl(const char* v);
+void icalproperty_set_tzurl(icalproperty* prop, const char* v);
+const char* icalproperty_get_tzurl(icalproperty* prop);icalproperty* icalproperty_vanew_uid(const char* v, ...);
+
+/* UID */
+icalproperty* icalproperty_new_uid(const char* v);
+void icalproperty_set_uid(icalproperty* prop, const char* v);
+const char* icalproperty_get_uid(icalproperty* prop);icalproperty* icalproperty_vanew_url(const char* v, ...);
+
+/* URL */
+icalproperty* icalproperty_new_url(const char* v);
+void icalproperty_set_url(icalproperty* prop, const char* v);
+const char* icalproperty_get_url(icalproperty* prop);icalproperty* icalproperty_vanew_version(const char* v, ...);
+
+/* VERSION */
+icalproperty* icalproperty_new_version(const char* v);
+void icalproperty_set_version(icalproperty* prop, const char* v);
+const char* icalproperty_get_version(icalproperty* prop);icalproperty* icalproperty_vanew_x(const char* v, ...);
+
+/* X */
+icalproperty* icalproperty_new_x(const char* v);
+void icalproperty_set_x(icalproperty* prop, const char* v);
+const char* icalproperty_get_x(icalproperty* prop);icalproperty* icalproperty_vanew_xlicclustercount(const char* v, ...);
+
+/* X-LIC-CLUSTERCOUNT */
+icalproperty* icalproperty_new_xlicclustercount(const char* v);
+void icalproperty_set_xlicclustercount(icalproperty* prop, const char* v);
+const char* icalproperty_get_xlicclustercount(icalproperty* prop);icalproperty* icalproperty_vanew_xlicerror(const char* v, ...);
+
+/* X-LIC-ERROR */
+icalproperty* icalproperty_new_xlicerror(const char* v);
+void icalproperty_set_xlicerror(icalproperty* prop, const char* v);
+const char* icalproperty_get_xlicerror(icalproperty* prop);icalproperty* icalproperty_vanew_xlicmimecharset(const char* v, ...);
+
+/* X-LIC-MIMECHARSET */
+icalproperty* icalproperty_new_xlicmimecharset(const char* v);
+void icalproperty_set_xlicmimecharset(icalproperty* prop, const char* v);
+const char* icalproperty_get_xlicmimecharset(icalproperty* prop);icalproperty* icalproperty_vanew_xlicmimecid(const char* v, ...);
+
+/* X-LIC-MIMECID */
+icalproperty* icalproperty_new_xlicmimecid(const char* v);
+void icalproperty_set_xlicmimecid(icalproperty* prop, const char* v);
+const char* icalproperty_get_xlicmimecid(icalproperty* prop);icalproperty* icalproperty_vanew_xlicmimecontenttype(const char* v, ...);
+
+/* X-LIC-MIMECONTENTTYPE */
+icalproperty* icalproperty_new_xlicmimecontenttype(const char* v);
+void icalproperty_set_xlicmimecontenttype(icalproperty* prop, const char* v);
+const char* icalproperty_get_xlicmimecontenttype(icalproperty* prop);icalproperty* icalproperty_vanew_xlicmimeencoding(const char* v, ...);
+
+/* X-LIC-MIMEENCODING */
+icalproperty* icalproperty_new_xlicmimeencoding(const char* v);
+void icalproperty_set_xlicmimeencoding(icalproperty* prop, const char* v);
+const char* icalproperty_get_xlicmimeencoding(icalproperty* prop);icalproperty* icalproperty_vanew_xlicmimefilename(const char* v, ...);
+
+/* X-LIC-MIMEFILENAME */
+icalproperty* icalproperty_new_xlicmimefilename(const char* v);
+void icalproperty_set_xlicmimefilename(icalproperty* prop, const char* v);
+const char* icalproperty_get_xlicmimefilename(icalproperty* prop);icalproperty* icalproperty_vanew_xlicmimeoptinfo(const char* v, ...);
+
+/* X-LIC-MIMEOPTINFO */
+icalproperty* icalproperty_new_xlicmimeoptinfo(const char* v);
+void icalproperty_set_xlicmimeoptinfo(icalproperty* prop, const char* v);
+const char* icalproperty_get_xlicmimeoptinfo(icalproperty* prop);
+
+#endif /*ICALPROPERTY_H*/
+/* -*- Mode: C -*- */
+/*======================================================================
+  FILE: icalvalue.h
+  CREATOR: eric 20 March 1999
+
+
+  $Id$
+  $Locker$
+
+  
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalvalue.h
+
+  ======================================================================*/
+
+#ifndef ICALVALUE_H
+#define ICALVALUE_H
+
+#include <time.h>
+                          
+/* Defined in icalderivedvalue.h */
+/*typedef void icalvalue;*/
+
+icalvalue* icalvalue_new(icalvalue_kind kind);
+
+icalvalue* icalvalue_new_clone(icalvalue* value);
+
+icalvalue* icalvalue_new_from_string(icalvalue_kind kind, const char* str);
+
+void icalvalue_free(icalvalue* value);
+
+int icalvalue_is_valid(icalvalue* value);
+
+const char* icalvalue_as_ical_string(icalvalue* value);
+
+icalvalue_kind icalvalue_isa(icalvalue* value);
+
+int icalvalue_isa_value(void*);
+
+icalparameter_xliccomparetype icalvalue_compare(icalvalue* a, icalvalue *b);
+
+
+/* Special, non autogenerated value accessors */
+
+icalvalue* icalvalue_new_recur (struct icalrecurrencetype v);
+void icalvalue_set_recur(icalvalue* value, struct icalrecurrencetype v);
+struct icalrecurrencetype icalvalue_get_recur(icalvalue* value);
+
+icalvalue* icalvalue_new_trigger (struct icaltriggertype v);
+void icalvalue_set_trigger(icalvalue* value, struct icaltriggertype v);
+struct icaltriggertype icalvalue_get_trigger(icalvalue* value);
+
+icalvalue* icalvalue_new_datetimeperiod (struct icaldatetimeperiodtype v);
+void icalvalue_set_datetimeperiod(icalvalue* value, 
+                                  struct icaldatetimeperiodtype v);
+struct icaldatetimeperiodtype icalvalue_get_datetimeperiod(icalvalue* value);
+
+/* Convert enumerations */
+
+icalvalue_kind icalvalue_string_to_kind(const char* str);
+const char* icalvalue_kind_to_string(icalvalue_kind kind);
+
+
+#endif /*ICALVALUE_H*/
+/* -*- Mode: C -*- */
+/*======================================================================
+  FILE: icalparam.h
+  CREATOR: eric 20 March 1999
+
+
+  $Id$
+  $Locker$
+
+  
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalparam.h
+
+  ======================================================================*/
+
+#ifndef ICALPARAM_H
+#define ICALPARAM_H
+
+
+/* Declared in icalderivedparameter.h */
+/*typedef void icalparameter;*/
+
+icalparameter* icalparameter_new(icalparameter_kind kind);
+icalparameter* icalparameter_new_clone(icalparameter* p);
+
+/* Create from string of form "PARAMNAME=VALUE" */
+icalparameter* icalparameter_new_from_string(const char* value);
+
+/* Create from just the value, the part after the "=" */
+icalparameter* icalparameter_new_from_value_string(icalparameter_kind kind, const char* value);
+
+void icalparameter_free(icalparameter* parameter);
+
+char* icalparameter_as_ical_string(icalparameter* parameter);
+
+int icalparameter_is_valid(icalparameter* parameter);
+
+icalparameter_kind icalparameter_isa(icalparameter* parameter);
+
+int icalparameter_isa_parameter(void* param);
+
+/* Acess the name of an X parameer */
+void icalparameter_set_xname (icalparameter* param, const char* v);
+const char* icalparameter_get_xname(icalparameter* param);
+void icalparameter_set_xvalue (icalparameter* param, const char* v);
+const char* icalparameter_get_xvalue(icalparameter* param);
+
+/* Convert enumerations */
+
+const char* icalparameter_kind_to_string(icalparameter_kind kind);
+icalparameter_kind icalparameter_string_to_kind(const char* string);
+
+
+
+#endif 
+/* -*- Mode: C -*- */
+/*======================================================================
+  FILE: icalproperty.h
+  CREATOR: eric 20 March 1999
+
+
+  $Id$
+  $Locker$
+
+  
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalparam.h
+
+  ======================================================================*/
+
+
+#ifndef ICALPROPERTY_H
+#define ICALPROPERTY_H
+
+#include <time.h>
+
+
+
+
+/* Actually in icalderivedproperty.h:
+   typedef void icalproperty; */
+
+
+icalproperty* icalproperty_new(icalproperty_kind kind);
+
+icalproperty* icalproperty_new_clone(icalproperty * prop);
+
+icalproperty* icalproperty_new_from_string(const char* str);
+
+const char* icalproperty_as_ical_string(icalproperty* prop);
+
+void  icalproperty_free(icalproperty* prop);
+
+icalproperty_kind icalproperty_isa(icalproperty* property);
+int icalproperty_isa_property(void* property);
+
+void icalproperty_add_parameter(icalproperty* prop,icalparameter* parameter);
+void icalproperty_set_parameter(icalproperty* prop,icalparameter* parameter);
+void icalproperty_set_parameter_from_string(icalproperty* prop,
+                                            const char* name, const char* value);
+const char* icalproperty_get_parameter_as_string(icalproperty* prop,
+                                                 const char* name);
+
+void icalproperty_remove_parameter(icalproperty* prop,
+                                   icalparameter_kind kind);
+
+int icalproperty_count_parameters(icalproperty* prop);
+
+/* Iterate through the parameters */
+icalparameter* icalproperty_get_first_parameter(icalproperty* prop,
+                                                icalparameter_kind kind);
+icalparameter* icalproperty_get_next_parameter(icalproperty* prop,
+                                                icalparameter_kind kind);
+/* Access the value of the property */
+void icalproperty_set_value(icalproperty* prop, icalvalue* value);
+void icalproperty_set_value_from_string(icalproperty* prop,const char* value, const char* kind);
+
+icalvalue* icalproperty_get_value(icalproperty* prop);
+const char* icalproperty_get_value_as_string(icalproperty* prop);
+
+/* Deal with X properties */
+
+void icalproperty_set_x_name(icalproperty* prop, const char* name);
+const char* icalproperty_get_x_name(icalproperty* prop);
+
+/* Return the name of the property -- the type name converted to a
+   string, or the value of _get_x_name if the type is and X property */
+const char* icalproperty_get_name (icalproperty* prop);
+
+icalvalue_kind icalparameter_value_to_value_kind(icalparameter_value value);
+
+/* Convert kinds to string and get default value type */
+
+icalvalue_kind icalproperty_kind_to_value_kind(icalproperty_kind kind);
+icalvalue_kind icalproperty_value_kind_to_kind(icalvalue_kind kind);
+const char* icalproperty_kind_to_string(icalproperty_kind kind);
+icalproperty_kind icalproperty_string_to_kind(const char* string);
+
+icalproperty_method icalproperty_string_to_method(const char* str);
+const char* icalproperty_method_to_string(icalproperty_method method);
+
+
+const char* icalproperty_enum_to_string(int e);
+int icalproperty_string_to_enum(const char* str);
+
+const char* icalproperty_status_to_string(icalproperty_status);
+icalproperty_status icalproperty_string_to_status(const char* string);
+
+int icalproperty_enum_belongs_to_property(icalproperty_kind kind, int e);
+
+
+
+
+#endif /*ICALPROPERTY_H*/
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalattendee.h
+ CREATOR: eric 8 Mar 01
+
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icaltypes.h
+
+======================================================================*/
+
+#ifndef ICALATTENDEE_H
+#define ICALATTENDEE_H
+
+#include <time.h>
+
+struct icalorganizertype {
+    const char* value;
+    const char* common_name;
+    const char* dir;
+    const char* sentby;
+    const char* language;
+
+};
+
+/* Create a copy of the given organizer. Libical will not own the
+   memory for the strings in the copy; the call must free them */
+struct icalorganizertype icalorganizertype_new_clone(struct icalorganizertype a);
+
+
+struct icalattendeetype {
+    const char* cuid; /* Cal user id, contents of the property value */
+    /*icalparameter_cutype cutype;*/
+    const char* member;
+    /*icalparameter_role role;*/
+    int rsvp;
+    const char* delto;
+    const char* delfrom;
+    const char* sentby;
+    const char* cn;
+    const char* dir;
+    const char* language;
+};
+
+/* Create a copy of the given attendee. Libical will not own the
+   memory for the strings in the copy; the call must free them */
+struct icalattendeetype icalattendeetype_new_clone(struct icalattendeetype a);
+
+
+#endif /* !ICALATTENDEE_H */
+/*======================================================================
+ FILE: pvl.h
+ CREATOR: eric November, 1995
+
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+======================================================================*/
+
+
+#ifndef __PVL_H__
+#define __PVL_H__
+
+typedef void* pvl_list;
+typedef void* pvl_elem;
+
+/*
+  struct pvl_elem_t
+
+  This type is private. Always use pvl_elem instead. The struct would
+  not even appear in this header except to make code in the USE_MACROS
+  blocks work
+
+  */
+typedef struct pvl_elem_t
+{
+                int MAGIC;              /* Magic Identifier */
+                void *d;                /* Pointer to data user is storing */
+                struct pvl_elem_t *next;/* Next element */
+                struct pvl_elem_t *prior;/* prior element */
+} pvl_elem_t;
+
+
+
+/* This global is incremented for each call to pvl_new_element(); it gives each
+ * list a unique identifer */
+
+extern int  pvl_elem_count;
+extern int  pvl_list_count;
+
+/* Create new lists or elements */
+pvl_elem pvl_new_element(void* d, pvl_elem next,pvl_elem prior);
+pvl_list pvl_newlist(void);
+void pvl_free(pvl_list);
+
+/* Add, remove, or get the head of the list */
+void pvl_unshift(pvl_list l,void *d);
+void* pvl_shift(pvl_list l);
+pvl_elem pvl_head(pvl_list);
+
+/* Add, remove or get the tail of the list */
+void pvl_push(pvl_list l,void *d);
+void* pvl_pop(pvl_list l);
+pvl_elem pvl_tail(pvl_list);
+
+/* Insert elements in random places */
+typedef int (*pvl_comparef)(void* a, void* b); /* a, b are of the data type*/
+void pvl_insert_ordered(pvl_list l,pvl_comparef f,void *d);
+void pvl_insert_after(pvl_list l,pvl_elem e,void *d);
+void pvl_insert_before(pvl_list l,pvl_elem e,void *d);
+
+/* Remove an element, or clear the entire list */
+void* pvl_remove(pvl_list,pvl_elem); /* Remove element, return data */
+void pvl_clear(pvl_list); /* Remove all elements, de-allocate all data */
+
+int pvl_count(pvl_list);
+
+/* Navagate the list */
+pvl_elem pvl_next(pvl_elem e);
+pvl_elem pvl_prior(pvl_elem e);
+
+/* get the data in the list */
+#ifndef PVL_USE_MACROS
+void* pvl_data(pvl_elem);
+#else
+#define pvl_data(x) x==0 ? 0 : ((struct pvl_elem_t *)x)->d;
+#endif
+
+
+/* Find an element for which a function returns true */
+typedef int (*pvl_findf)(void* a, void* b); /*a is list elem, b is other data*/
+pvl_elem pvl_find(pvl_list l,pvl_findf f,void* v);
+pvl_elem pvl_find_next(pvl_list l,pvl_findf f,void* v);
+
+/* Pass each element in the list to a function */
+typedef void (*pvl_applyf)(void* a, void* b); /*a is list elem, b is other data*/
+void pvl_apply(pvl_list l,pvl_applyf f, void *v);
+
+
+#endif /* __PVL_H__ */
+
+
+
+
+
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalcomponent.h
+ CREATOR: eric 20 March 1999
+
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalcomponent.h
+
+======================================================================*/
+
+#ifndef ICALCOMPONENT_H
+#define ICALCOMPONENT_H
+
+
+typedef void icalcomponent;
+
+/* This is exposed so that callers will not have to allocate and
+   deallocate iterators. Pretend that you can't see it. */
+typedef struct icalcompiter
+{
+        icalcomponent_kind kind;
+        pvl_elem iter;
+
+} icalcompiter;
+
+icalcomponent* icalcomponent_new(icalcomponent_kind kind);
+icalcomponent* icalcomponent_new_clone(icalcomponent* component);
+icalcomponent* icalcomponent_new_from_string(char* str);
+icalcomponent* icalcomponent_vanew(icalcomponent_kind kind, ...);
+void icalcomponent_free(icalcomponent* component);
+
+char* icalcomponent_as_ical_string(icalcomponent* component);
+
+int icalcomponent_is_valid(icalcomponent* component);
+
+icalcomponent_kind icalcomponent_isa(icalcomponent* component);
+
+int icalcomponent_isa_component (void* component);
+
+/* 
+ * Working with properties
+ */
+
+void icalcomponent_add_property(icalcomponent* component,
+                                icalproperty* property);
+
+void icalcomponent_remove_property(icalcomponent* component,
+                                   icalproperty* property);
+
+int icalcomponent_count_properties(icalcomponent* component,
+                                   icalproperty_kind kind);
+
+/* Iterate through the properties */
+icalproperty* icalcomponent_get_current_property(icalcomponent* component);
+
+icalproperty* icalcomponent_get_first_property(icalcomponent* component,
+                                              icalproperty_kind kind);
+icalproperty* icalcomponent_get_next_property(icalcomponent* component,
+                                              icalproperty_kind kind);
+
+
+/* 
+ * Working with components
+ */ 
+
+
+/* Return the first VEVENT, VTODO or VJOURNAL sub-component of cop, or
+   comp if it is one of those types */
+
+icalcomponent* icalcomponent_get_inner(icalcomponent* comp);
+
+
+void icalcomponent_add_component(icalcomponent* parent,
+                                icalcomponent* child);
+
+void icalcomponent_remove_component(icalcomponent* parent,
+                                icalcomponent* child);
+
+int icalcomponent_count_components(icalcomponent* component,
+                                   icalcomponent_kind kind);
+
+/* Iteration Routines. There are two forms of iterators, internal and
+external. The internal ones came first, and are almost completely
+sufficient, but they fail badly when you want to construct a loop that
+removes components from the container.*/
+
+
+/* Iterate through components */
+icalcomponent* icalcomponent_get_current_component (icalcomponent* component);
+
+icalcomponent* icalcomponent_get_first_component(icalcomponent* component,
+                                              icalcomponent_kind kind);
+icalcomponent* icalcomponent_get_next_component(icalcomponent* component,
+                                              icalcomponent_kind kind);
+
+/* Using external iterators */
+icalcompiter icalcomponent_begin_component(icalcomponent* component,
+                                           icalcomponent_kind kind);
+icalcompiter icalcomponent_end_component(icalcomponent* component,
+                                         icalcomponent_kind kind);
+icalcomponent* icalcompiter_next(icalcompiter* i);
+icalcomponent* icalcompiter_prior(icalcompiter* i);
+icalcomponent* icalcompiter_deref(icalcompiter* i);
+
+
+
+
+/* Working with embedded error properties */
+
+int icalcomponent_count_errors(icalcomponent* component);
+
+/* Remove all X-LIC-ERROR properties*/
+void icalcomponent_strip_errors(icalcomponent* component);
+
+/* Convert some X-LIC-ERROR properties into RETURN-STATUS properties*/
+void icalcomponent_convert_errors(icalcomponent* component);
+
+/* Internal operations. They are private, and you should not be using them. */
+icalcomponent* icalcomponent_get_parent(icalcomponent* component);
+void icalcomponent_set_parent(icalcomponent* component, 
+                              icalcomponent* parent);
+
+/* Kind conversion routiens */
+
+icalcomponent_kind icalcomponent_string_to_kind(const char* string);
+
+const char* icalcomponent_kind_to_string(icalcomponent_kind kind);
+
+
+/************* Derived class methods.  ****************************
+
+If the code was in an OO language, the remaining routines would be
+members of classes derived from icalcomponent. Don't call them on the
+wrong component subtypes. */
+
+/* For VCOMPONENT: Return a reference to the first VEVENT, VTODO or
+   VJOURNAL */
+icalcomponent* icalcomponent_get_first_real_component(icalcomponent *c);
+
+/* For VEVENT, VTODO, VJOURNAL and VTIMEZONE: report the start and end
+   times of an event in UTC */
+struct icaltime_span icalcomponent_get_span(icalcomponent* comp);
+
+/******************** Convienience routines **********************/
+
+void icalcomponent_set_dtstart(icalcomponent* comp, struct icaltimetype v);
+struct icaltimetype icalcomponent_get_dtstart(icalcomponent* comp);
+
+/* For the icalcomponent routines only, dtend and duration are tied
+   together. If you call the set routine for one and the other exists,
+   the routine will calculate the change to the other. That is, if
+   there is a DTEND and you call set_duration, the routine will modify
+   DTEND to be the sum of DTSTART and the duration. If you call a get
+   routine for one and the other exists, the routine will calculate
+   the return value. If you call a set routine and neither exists, the
+   routine will create the apcompriate comperty */
+
+
+struct icaltimetype icalcomponent_get_dtend(icalcomponent* comp);
+void icalcomponent_set_dtend(icalcomponent* comp, struct icaltimetype v);
+
+void icalcomponent_set_duration(icalcomponent* comp, 
+                                struct icaldurationtype v);
+struct icaldurationtype icalcomponent_get_duration(icalcomponent* comp);
+
+void icalcomponent_set_method(icalcomponent* comp, icalproperty_method method);
+icalproperty_method icalcomponent_get_method(icalcomponent* comp);
+
+struct icaltimetype icalcomponent_get_dtstamp(icalcomponent* comp);
+void icalcomponent_set_dtstamp(icalcomponent* comp, struct icaltimetype v);
+
+
+void icalcomponent_set_summary(icalcomponent* comp, const char* v);
+const char* icalcomponent_get_summary(icalcomponent* comp);
+
+void icalcomponent_set_comment(icalcomponent* comp, const char* v);
+const char* icalcomponent_get_comment(icalcomponent* comp);
+
+void icalcomponent_set_uid(icalcomponent* comp, const char* v);
+const char* icalcomponent_get_uid(icalcomponent* comp);
+
+void icalcomponent_set_recurrenceid(icalcomponent* comp, 
+                                    struct icaltimetype v);
+struct icaltimetype icalcomponent_get_recurrenceid(icalcomponent* comp);
+
+
+void icalcomponent_set_organizer(icalcomponent* comp, 
+                                 struct icalorganizertype org);
+                                 struct icalorganizertype icalcomponent_get_organizer(icalcomponent* comp);
+
+
+void icalcomponent_add_attendee(icalcomponent *comp,
+                                struct icalattendeetype attendee);
+
+int icalcomponent_remove_attendee(icalcomponent *comp, char* cuid);
+
+/* Get the Nth attendee. Out of range indices return an attendee
+   with cuid == 0 */
+struct icalattendeetype icalcomponent_get_attendee(icalcomponent *comp,
+  int index);
+
+
+
+
+/*************** Type Specific routines ***************/
+
+icalcomponent* icalcomponent_new_vcalendar();
+icalcomponent* icalcomponent_new_vevent();
+icalcomponent* icalcomponent_new_vtodo();
+icalcomponent* icalcomponent_new_vjournal();
+icalcomponent* icalcomponent_new_valarm();
+icalcomponent* icalcomponent_new_vfreebusy();
+icalcomponent* icalcomponent_new_vtimezone();
+icalcomponent* icalcomponent_new_xstandard();
+icalcomponent* icalcomponent_new_xdaylight();
+
+
+
+#endif /* !ICALCOMPONENT_H */
+
+
+
+/* -*- Mode: C -*- */
+/*======================================================================
+  FILE: icalparser.h
+  CREATOR: eric 20 April 1999
+  
+  $Id$
+
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalparser.h
+
+======================================================================*/
+
+
+#ifndef ICALPARSER_H
+#define ICALPARSER_H
+
+
+#include <stdio.h> /* For FILE* */
+
+typedef void* icalparser;
+
+
+/***********************************************************************
+ * Line-oriented parsing. 
+ * 
+ * Create a new parser via icalparse_new_parser, then add ines one at
+ * a time with icalparse_add_line(). icalparser_add_line() will return
+ * non-zero when it has finished with a component.
+ ***********************************************************************/
+
+typedef enum icalparser_state {
+    ICALPARSER_ERROR,
+    ICALPARSER_SUCCESS,
+    ICALPARSER_BEGIN_COMP,
+    ICALPARSER_END_COMP,
+    ICALPARSER_IN_PROGRESS
+} icalparser_state;
+
+icalparser* icalparser_new(void);
+icalcomponent* icalparser_add_line(icalparser* parser, char* str );
+icalcomponent* icalparser_clean(icalparser* parser);
+icalparser_state icalparser_get_state(icalparser* parser);
+void icalparser_free(icalparser* parser);
+
+
+/***********************************************************************
+ * Message oriented parsing.  icalparser_parse takes a string that
+ * holds the text ( in RFC 2445 format ) and returns a pointer to an
+ * icalcomponent. The caller owns the memory. line_gen_func is a
+ * pointer to a function that returns one content line per invocation
+ **********************************************************************/
+
+icalcomponent* icalparser_parse(icalparser *parser,
+                                char* (*line_gen_func)(char *s, size_t size, void *d));
+
+/* Set the data that icalparser_parse will give to the line_gen_func
+   as the parameter 'd'*/
+void icalparser_set_gen_data(icalparser* parser, void* data);
+
+
+icalcomponent* icalparser_parse_string(const char* str);
+
+
+/***********************************************************************
+ * Parser support functions
+ ***********************************************************************/
+
+/* Use the flex/bison parser to turn a string into a value type */
+icalvalue*  icalparser_parse_value(icalvalue_kind kind, 
+                                   const char* str, icalcomponent** errors);
+
+/* Given a line generator function, return a single iCal content line.*/
+char* icalparser_get_line(icalparser* parser, char* (*line_gen_func)(char *s, size_t size, void *d));
+
+char* string_line_generator(char *out, size_t buf_size, void *d);
+
+#endif /* !ICALPARSE_H */
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalmemory.h
+ CREATOR: eric 30 June 1999
+
+
+ $Id$
+ $Locker$
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Initial Developer of the Original Code is Eric Busboom
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+======================================================================*/
+
+#ifndef ICALMEMORY_H
+#define ICALMEMORY_H
+
+#include <sys/types.h> /* for size_t */
+
+
+/* Tmp buffers are managed by ical. References can be returned to the
+   caller, although the caller will not own the memory. */
+
+void* icalmemory_tmp_buffer(size_t size);
+char* icalmemory_tmp_copy(const char* str);
+
+/* Add an externally allocated buffer to the ring. */
+void  icalmemory_add_tmp_buffer(void*);
+
+
+/* Free all memory used in the ring */
+void icalmemory_free_ring(void);
+
+/* Non-tmp buffers must be freed. These are mostly wrappers around
+ * malloc, etc, but are used so the caller can change the memory
+ * allocators in a future version of the library */
+
+void* icalmemory_new_buffer(size_t size);
+void* icalmemory_resize_buffer(void* buf, size_t size);
+void icalmemory_free_buffer(void* buf);
+
+/* icalmemory_append_string will copy the string 'string' to the
+   buffer 'buf' starting at position 'pos', reallocing 'buf' if it is
+   too small. 'buf_size' is the size of 'buf' and will be changed if
+   'buf' is reallocated. 'pos' will point to the last byte of the new
+   string in 'buf', usually a '\0' */
+
+/* THESE ROUTINES CAN NOT BE USED ON TMP BUFFERS. Only use them on
+   normally allocated memory, or on buffers created from
+   icalmemory_new_buffer, never with buffers created by
+   icalmemory_tmp_buffer. If icalmemory_append_string has to resize a
+   buffer on the ring, the ring will loose track of it an you will
+   have memory problems. */
+
+void icalmemory_append_string(char** buf, char** pos, size_t* buf_size, 
+                              const char* string);
+
+/*  icalmemory_append_char is similar, but is appends a character instead of a string */
+void icalmemory_append_char(char** buf, char** pos, size_t* buf_size, 
+                              char ch);
+
+/* A wrapper around strdup. Partly to trap calls to strdup, partly
+   because in -ansi, gcc on Red Hat claims that strudup is undeclared */
+char* icalmemory_strdup(const char *s);
+
+#endif /* !ICALMEMORY_H */
+
+
+
+/* -*- Mode: C -*- */
+/*======================================================================
+  FILE: icalerror.h
+  CREATOR: eric 09 May 1999
+  
+  $Id$
+
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalerror.h
+
+======================================================================*/
+
+
+#ifndef ICALERROR_H
+#define ICALERROR_H
+
+#include <assert.h>
+#include <stdio.h> /* For icalerror_warn() */
+
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#define ICAL_SETERROR_ISFUNC
+
+
+/* This routine is called before any error is triggered. It is called
+   by icalerror_set_errno, so it does not appear in all of the macros
+   below */
+void icalerror_stop_here(void);
+
+void icalerror_crash_here(void);
+
+typedef enum icalerrorenum {
+    
+    ICAL_BADARG_ERROR,
+    ICAL_NEWFAILED_ERROR,
+    ICAL_ALLOCATION_ERROR,
+    ICAL_MALFORMEDDATA_ERROR, 
+    ICAL_PARSE_ERROR,
+    ICAL_INTERNAL_ERROR, /* Like assert --internal consist. prob */
+    ICAL_FILE_ERROR,
+    ICAL_USAGE_ERROR,
+    ICAL_UNIMPLEMENTED_ERROR,
+    ICAL_UNKNOWN_ERROR, /* Used for problems in input to icalerror_strerror()*/
+    ICAL_NO_ERROR
+
+} icalerrorenum;
+
+/* The libical error enumeration, like errno*/
+extern icalerrorenum icalerrno;
+
+/* If true, libicl aborts after a call to icalerror_set_error*/
+extern int icalerror_errors_are_fatal;
+
+/* Warning messages */
+
+#ifdef __GNUC__ca
+#define icalerror_warn(message) {fprintf(stderr,"%s(), %s:%d: %s\n",__FUNCTION__,__FILE__,__LINE__,message);}
+#else /* __GNU_C__ */
+#define icalerror_warn(message) {fprintf(stderr,"%s:%d: %s\n",__FILE__,__LINE__,message);}
+#endif /* __GNU_C__ */
+
+
+void icalerror_clear_errno(void);
+
+/* Make an individual error fatal or non-fatal. */
+typedef enum icalerrorstate { 
+    ICAL_ERROR_FATAL,     /* Not fata */
+    ICAL_ERROR_NONFATAL,  /* Fatal */
+    ICAL_ERROR_DEFAULT,   /* Use the value of icalerror_errors_are_fatal*/
+    ICAL_ERROR_UNKNOWN    /* Asked state for an unknown error type */
+} icalerrorstate ;
+
+char* icalerror_strerror(icalerrorenum e);
+char* icalerror_perror();
+void icalerror_set_error_state( icalerrorenum error, icalerrorstate);
+icalerrorstate icalerror_get_error_state( icalerrorenum error);
+
+#ifndef ICAL_SETERROR_ISFUNC
+#define icalerror_set_errno(x) \
+icalerrno = x; \
+if(icalerror_get_error_state(x)==ICAL_ERROR_FATAL || \
+   (icalerror_get_error_state(x)==ICAL_ERROR_DEFAULT && \
+    icalerror_errors_are_fatal == 1 )){ \
+   icalerror_warn(icalerror_strerror(x)); \
+   assert(0); \
+} 
+#else
+void icalerror_set_errno(icalerrorenum);
+#endif
+
+#ifdef ICAL_ERRORS_ARE_FATAL
+#undef NDEBUG
+#endif
+
+#define icalerror_check_value_type(value,type);
+#define icalerror_check_property_type(value,type);
+#define icalerror_check_parameter_type(value,type);
+#define icalerror_check_component_type(value,type);
+
+/* Assert with a message */
+#ifdef ICAL_ERRORS_ARE_FATAL
+
+#ifdef __GNUC__
+#define icalerror_assert(test,message) if(!(test)){fprintf(stderr,"%s(), %s:%d: %s\n",__FUNCTION__,__FILE__,__LINE__,message);icalerror_stop_here(); abort();}
+#else /*__GNUC__*/
+#define icalerror_assert(test,message) if(!(test)){fprintf(stderr,"%s:%d: %s\n",__FILE__,__LINE__,message);icalerror_stop_here(); abort();}
+#endif /*__GNUC__*/
+
+#else /* ICAL_ERRORS_ARE_FATAL */
+#define icalerror_assert(test,message) 
+#endif /* ICAL_ERRORS_ARE_FATAL */
+
+/* Check & abort if check fails */
+#define icalerror_check_arg(test,arg) if(!(test)) { icalerror_set_errno(ICAL_BADARG_ERROR); }
+
+/* Check & return void if check fails*/
+#define icalerror_check_arg_rv(test,arg) if(!(test)) {icalerror_set_errno(ICAL_BADARG_ERROR); return; }
+
+/* Check & return 0 if check fails*/
+#define icalerror_check_arg_rz(test,arg) if(!(test)) { icalerror_set_errno(ICAL_BADARG_ERROR); return 0;}
+
+/* Check & return an error if check fails*/
+#define icalerror_check_arg_re(test,arg,error) if(!(test)) { icalerror_stop_here(); assert(0); return error;}
+
+/* Check & return something*/
+#define icalerror_check_arg_rx(test,arg,x) if(!(test)) { icalerror_set_errno(ICAL_BADARG_ERROR); return x;}
+
+
+
+/* String interfaces to set an error to NONFATAL and restore it to its
+   original value */
+
+icalerrorstate icalerror_supress(const char* error);
+void icalerror_restore(const char* error, icalerrorstate es);
+
+
+#endif /* !ICALERROR_H */
+
+
+
+/* -*- Mode: C -*- */
+/*======================================================================
+  FILE: icalrestriction.h
+  CREATOR: eric 24 April 1999
+  
+  $Id$
+
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalrestriction.h
+
+  Contributions from:
+     Graham Davison (g.m.davison@computer.org)
+
+
+======================================================================*/
+
+
+#ifndef ICALRESTRICTION_H
+#define ICALRESTRICTION_H
+
+/* These must stay in this order for icalrestriction_compare to work */
+typedef enum icalrestriction_kind {
+            ICAL_RESTRICTION_NONE=0,    /* 0 */
+            ICAL_RESTRICTION_ZERO,      /* 1 */
+            ICAL_RESTRICTION_ONE,       /* 2 */
+            ICAL_RESTRICTION_ZEROPLUS,  /* 3 */
+            ICAL_RESTRICTION_ONEPLUS,   /* 4 */
+            ICAL_RESTRICTION_ZEROORONE,         /* 5 */
+            ICAL_RESTRICTION_ONEEXCLUSIVE,/* 6 */
+            ICAL_RESTRICTION_ONEMUTUAL,         /* 7 */
+            ICAL_RESTRICTION_UNKNOWN    /* 8 */
+} icalrestriction_kind;
+
+int 
+icalrestriction_compare(icalrestriction_kind restr, int count);
+
+
+int
+icalrestriction_is_parameter_allowed(icalproperty_kind property,
+                                       icalparameter_kind parameter);
+
+int icalrestriction_check(icalcomponent* comp);
+
+
+#endif /* !ICALRESTRICTION_H */
+
+
+
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: sspm.h Mime Parser
+  CREATOR: eric 25 June 2000
+  
+  $Id$
+  $Locker$
+    
+ The contents of this file are subject to the Mozilla Public License
+ Version 1.0 (the "License"); you may not use this file except in
+ compliance with the License. You may obtain a copy of the License at
+ http://www.mozilla.org/MPL/
+ 
+ Software distributed under the License is distributed on an "AS IS"
+ basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+ the License for the specific language governing rights and
+ limitations under the License.
+ 
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The Initial Developer of the Original Code is Eric Busboom
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+ ======================================================================*/
+
+#ifndef SSPM_H
+#define SSPM_H
+
+enum sspm_major_type {
+    SSPM_NO_MAJOR_TYPE,
+    SSPM_TEXT_MAJOR_TYPE,
+    SSPM_IMAGE_MAJOR_TYPE,
+    SSPM_AUDIO_MAJOR_TYPE,
+    SSPM_VIDEO_MAJOR_TYPE,
+    SSPM_APPLICATION_MAJOR_TYPE,
+    SSPM_MULTIPART_MAJOR_TYPE,
+    SSPM_MESSAGE_MAJOR_TYPE,
+    SSPM_UNKNOWN_MAJOR_TYPE
+};
+
+enum sspm_minor_type {
+    SSPM_NO_MINOR_TYPE,
+    SSPM_ANY_MINOR_TYPE,
+    SSPM_PLAIN_MINOR_TYPE,
+    SSPM_RFC822_MINOR_TYPE,
+    SSPM_DIGEST_MINOR_TYPE,
+    SSPM_CALENDAR_MINOR_TYPE,
+    SSPM_MIXED_MINOR_TYPE,
+    SSPM_RELATED_MINOR_TYPE,
+    SSPM_ALTERNATIVE_MINOR_TYPE,
+    SSPM_PARALLEL_MINOR_TYPE,
+    SSPM_UNKNOWN_MINOR_TYPE
+};
+
+enum sspm_encoding {
+    SSPM_NO_ENCODING,
+    SSPM_QUOTED_PRINTABLE_ENCODING,
+    SSPM_8BIT_ENCODING,
+    SSPM_7BIT_ENCODING,
+    SSPM_BINARY_ENCODING,
+    SSPM_BASE64_ENCODING,
+    SSPM_UNKNOWN_ENCODING
+};
+
+enum sspm_error{
+    SSPM_NO_ERROR,
+    SSPM_UNEXPECTED_BOUNDARY_ERROR,
+    SSPM_WRONG_BOUNDARY_ERROR,
+    SSPM_NO_BOUNDARY_ERROR,
+    SSPM_NO_HEADER_ERROR,
+    SSPM_MALFORMED_HEADER_ERROR
+};
+
+
+struct sspm_header
+{
+        int def;
+        char* boundary;
+        enum sspm_major_type major;
+        enum sspm_minor_type minor;
+        char *minor_text;
+        char ** content_type_params;
+        char* charset;
+        enum sspm_encoding encoding;
+        char* filename;
+        char* content_id;
+        enum sspm_error error;
+        char* error_text;
+};
+
+struct sspm_part {
+        struct sspm_header header;
+        int level;
+        size_t data_size;
+        void *data;
+};
+
+struct sspm_action_map {
+        enum sspm_major_type major;
+        enum sspm_minor_type minor;
+        void* (*new_part)();
+        void (*add_line)(void *part, struct sspm_header *header, 
+                         char* line, size_t size);
+        void* (*end_part)(void* part);
+        void (*free_part)(void *part);
+};
+
+char* sspm_major_type_string(enum sspm_major_type type);
+char* sspm_minor_type_string(enum sspm_minor_type type);
+char* sspm_encoding_string(enum sspm_encoding type);
+
+int sspm_parse_mime(struct sspm_part *parts, 
+                    size_t max_parts,
+                    struct sspm_action_map *actions,
+                    char* (*get_string)(char *s, size_t size, void* data),
+                    void *get_string_data,
+                    struct sspm_header *first_header
+    );
+
+void sspm_free_parts(struct sspm_part *parts, size_t max_parts);
+
+char *decode_quoted_printable(char *dest, 
+                                       char *src,
+                                       size_t *size);
+char *decode_base64(char *dest, 
+                             char *src,
+                             size_t *size);
+
+
+int sspm_write_mime(struct sspm_part *parts,size_t num_parts,
+                    char **output_string, char* header);
+
+#endif /*SSPM_H*/
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalmime.h
+ CREATOR: eric 26 July 2000
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+======================================================================*/
+
+#ifndef ICALMIME_H
+#define ICALMIME_H
+
+
+        icalcomponent* icalmime_parse(char* (*line_gen_func)(char *s, size_t size, 
+                                                       void *d),
+                                void *data);
+
+/* The inverse of icalmime_parse, not implemented yet. Use sspm.h directly.  */
+char* icalmime_as_mime_string(char* component);
+
+
+
+#endif /* !ICALMIME_H */
+
+
+
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: icallangbind.h
+  CREATOR: eric 25 jan 2001
+  
+  DESCRIPTION:
+  
+  $Id$
+  $Locker$
+
+  (C) COPYRIGHT 1999 Eric Busboom 
+  http://www.softwarestudio.org
+  
+  This package is free software and is provided "as is" without
+  express or implied warranty.  It may be used, redistributed and/or
+  modified under the same terms as perl itself. ( Either the Artistic
+  License or the GPL. )
+
+  ======================================================================*/
+
+#ifndef __ICALLANGBIND_H__
+#define __ICALLANGBIND_H__
+
+int* icallangbind_new_array(int size);
+void icallangbind_free_array(int* array);
+int icallangbind_access_array(int* array, int index);
+icalproperty* icallangbind_get_property(icalcomponent *c, int n, const char* prop);
+const char* icallangbind_get_property_val(icalproperty* p);
+const char* icallangbind_get_parameter(icalproperty *p, const char* parameter);
+icalcomponent* icallangbind_get_component(icalcomponent *c, const char* comp);
+
+icalproperty* icallangbind_get_first_property(icalcomponent *c,
+                                              const char* prop);
+
+icalproperty* icallangbind_get_next_property(icalcomponent *c,
+                                              const char* prop);
+
+icalcomponent* icallangbind_get_first_component(icalcomponent *c,
+                                              const char* comp);
+
+icalcomponent* icallangbind_get_next_component(icalcomponent *c,
+                                              const char* comp);
+
+
+const char* icallangbind_property_eval_string(icalproperty* prop, char* sep);
+
+
+int icallangbind_string_to_open_flag(const char* str);
+#endif /*__ICALLANGBIND_H__*/
diff --git a/libical/src/libical/icalattendee.c b/libical/src/libical/icalattendee.c
new file mode 100644
index 0000000..30cb949
--- a/dev/null
+++ b/libical/src/libical/icalattendee.c
@@ -0,0 +1,30 @@
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: icalattendee.c
+  CREATOR: eric 08 Mar 01
+  
+  $Id$
+  $Locker$
+    
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icaltypes.c
+
+ ======================================================================*/
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "icalattendee.h"
diff --git a/libical/src/libical/icalattendee.h b/libical/src/libical/icalattendee.h
new file mode 100644
index 0000000..914e51a
--- a/dev/null
+++ b/libical/src/libical/icalattendee.h
@@ -0,0 +1,69 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalattendee.h
+ CREATOR: eric 8 Mar 01
+
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icaltypes.h
+
+======================================================================*/
+
+#ifndef ICALATTENDEE_H
+#define ICALATTENDEE_H
+
+
+#include <time.h>
+#include "icalenums.h"
+#include "icaltime.h"
+#include "icalduration.h"
+#include "icalperiod.h"
+#include "icalderivedparameter.h"
+#include "icalderivedvalue.h"
+
+struct icalorganizertype {
+    const char* value;
+    const char* common_name;
+    const char* dir;
+    const char* sentby;
+    const char* language;
+
+};
+
+/* Create a copy of the given organizer. Libical will not own the
+   memory for the strings in the copy; the call must free them */
+struct icalorganizertype icalorganizertype_new_clone(struct icalorganizertype a);
+
+
+struct icalattendeetype {
+    const char* cuid; /* Cal user id, contents of the property value */
+    /*icalparameter_cutype cutype;*/
+    const char* member;
+    /*icalparameter_role role;*/
+    int rsvp;
+    const char* delto;
+    const char* delfrom;
+    const char* sentby;
+    const char* cn;
+    const char* dir;
+    const char* language;
+};
+
+/* Create a copy of the given attendee. Libical will not own the
+   memory for the strings in the copy; the call must free them */
+struct icalattendeetype icalattendeetype_new_clone(struct icalattendeetype a);
+
+
+#endif /* !ICALATTENDEE_H */
diff --git a/libical/src/libical/icalcomponent.c b/libical/src/libical/icalcomponent.c
new file mode 100644
index 0000000..af0d3ec
--- a/dev/null
+++ b/libical/src/libical/icalcomponent.c
@@ -0,0 +1,1488 @@
+/*======================================================================
+  FILE: icalcomponent.c
+  CREATOR: eric 28 April 1999
+  
+  $Id$
+
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalcomponent.c
+
+======================================================================*/
+
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "icalcomponent.h"
+#include "pvl.h" /* "Pointer-to-void list" */
+#include "icalerror.h"
+#include "icalmemory.h"
+#include "icalenums.h"
+#include "icaltime.h"
+#include "icalduration.h"
+#include "icalperiod.h"
+#include "icalparser.h"
+
+#include <stdlib.h>  /* for malloc */
+#include <stdarg.h> /* for va_list, etc */
+#include <errno.h>
+#include <assert.h>
+#include <stdio.h> /* for fprintf */
+#include <string.h>
+
+#define MAX_TMP 1024
+
+struct icalcomponent_impl 
+{
+        char id[5];
+        icalcomponent_kind kind;
+        char* x_name;
+        pvl_list properties;
+        pvl_elem property_iterator;
+        pvl_list components;
+        pvl_elem component_iterator;
+        icalcomponent* parent;
+};
+
+/* icalproperty functions that only components get to use */
+void icalproperty_set_parent(icalproperty* property,
+                             icalcomponent* component);
+icalcomponent* icalproperty_get_parent(icalproperty* property);
+void icalcomponent_add_children(struct icalcomponent_impl *impl,va_list args);
+icalcomponent* icalcomponent_new_impl (icalcomponent_kind kind);
+int icalcomponent_property_sorter(void *a, void *b);
+
+
+void icalcomponent_add_children(struct icalcomponent_impl *impl,va_list args)
+{
+    void* vp;
+    
+    while((vp = va_arg(args, void*)) != 0) {
+
+        assert (icalcomponent_isa_component(vp) != 0 ||
+                icalproperty_isa_property(vp) != 0 ) ;
+
+        if (icalcomponent_isa_component(vp) != 0 ){
+
+            icalcomponent_add_component((icalcomponent*)impl,
+                                       (icalcomponent*)vp);
+
+        } else if (icalproperty_isa_property(vp) != 0 ){
+
+            icalcomponent_add_property((icalcomponent*)impl,
+                                       (icalproperty*)vp);
+        }
+    }    
+}
+
+icalcomponent*
+icalcomponent_new_impl (icalcomponent_kind kind)
+{
+    struct icalcomponent_impl* comp;
+
+    if ( ( comp = (struct icalcomponent_impl*)
+           malloc(sizeof(struct icalcomponent_impl))) == 0) {
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        return 0;
+    }
+    
+    strcpy(comp->id,"comp");
+
+    comp->kind = kind;
+    comp->properties = pvl_newlist();
+    comp->property_iterator = 0;
+    comp->components = pvl_newlist();
+    comp->component_iterator = 0;
+    comp->x_name = 0;
+    comp->parent = 0;
+
+    return comp;
+}
+
+icalcomponent*
+icalcomponent_new (icalcomponent_kind kind)
+{
+   return (icalcomponent*)icalcomponent_new_impl(kind);
+}
+
+icalcomponent*
+icalcomponent_vanew (icalcomponent_kind kind, ...)
+{
+   va_list args;
+
+   struct icalcomponent_impl *impl = icalcomponent_new_impl(kind);
+
+    if (impl == 0){
+        return 0;
+    }
+
+   va_start(args,kind);
+   icalcomponent_add_children(impl, args);
+   va_end(args);
+
+   return (icalcomponent*) impl;
+}
+
+icalcomponent* icalcomponent_new_from_string(char* str)
+{
+    return icalparser_parse_string(str);
+}
+
+icalcomponent* icalcomponent_new_clone(icalcomponent* component)
+{
+    struct icalcomponent_impl *old = (struct icalcomponent_impl*)component;
+    struct icalcomponent_impl *new;
+    icalproperty *p;
+    icalcomponent *c;
+    pvl_elem itr;
+
+    icalerror_check_arg_rz( (component!=0), "component");
+
+    new = icalcomponent_new_impl(old->kind);
+
+    if (new == 0){
+        return 0;
+    }
+
+    
+    for( itr = pvl_head(old->properties);
+         itr != 0;
+         itr = pvl_next(itr))
+            {
+        p = (icalproperty*)pvl_data(itr);
+        icalcomponent_add_property(new,icalproperty_new_clone(p));
+    }
+   
+   
+    for( itr = pvl_head(old->components);
+         itr != 0;
+         itr = pvl_next(itr))
+            {
+        c = (icalcomponent*)pvl_data(itr);
+        icalcomponent_add_component(new,icalcomponent_new_clone(c));
+    }
+
+   return new;
+
+}
+
+
+void
+icalcomponent_free (icalcomponent* component)
+{
+    icalproperty* prop;
+    icalcomponent* comp;
+    struct icalcomponent_impl *c = (struct icalcomponent_impl*)component;
+
+    icalerror_check_arg_rv( (component!=0), "component");
+
+#ifdef ICAL_FREE_ON_LIST_IS_ERROR
+    icalerror_assert( (c->parent ==0),"Tried to free a component that is still attached to a parent component");
+#else
+    if(c->parent != 0){
+        return;
+    }
+#endif
+
+    if(component != 0 ){
+       
+       while( (prop=pvl_pop(c->properties)) != 0){
+           assert(prop != 0);
+           icalproperty_set_parent(prop,0);
+           icalproperty_free(prop);
+       }
+       
+       pvl_free(c->properties);
+
+       while( (comp=pvl_data(pvl_head(c->components))) != 0){
+           assert(comp!=0);
+           icalcomponent_remove_component(component,comp);
+           icalcomponent_free(comp);
+       }
+       
+       pvl_free(c->components);
+
+        if (c->x_name != 0) {
+            free(c->x_name);
+        }
+
+        c->kind = ICAL_NO_COMPONENT;
+        c->properties = 0;
+        c->property_iterator = 0;
+        c->components = 0;
+        c->component_iterator = 0;
+                c->x_name = 0;
+        c->id[0] = 'X';
+
+        free(c);
+    }
+}
+
+char*
+icalcomponent_as_ical_string (icalcomponent* component)
+{
+   char* buf, *out_buf;
+   const char* tmp_buf;
+   size_t buf_size = 1024;
+   char* buf_ptr = 0;
+    pvl_elem itr;
+    struct icalcomponent_impl *impl = (struct icalcomponent_impl*)component;
+
+#ifdef ICAL_UNIX_NEWLINE    
+    char newline[] = "\n";
+#else
+    char newline[] = "\n";
+#endif
+   icalcomponent *c;
+   icalproperty *p;
+   icalcomponent_kind kind = icalcomponent_isa(component);
+
+   const char* kind_string;
+
+   buf = icalmemory_new_buffer(buf_size);
+   buf_ptr = buf; 
+
+   icalerror_check_arg_rz( (component!=0), "component");
+   icalerror_check_arg_rz( (kind!=ICAL_NO_COMPONENT), "component kind is ICAL_NO_COMPONENT");
+   
+   kind_string  = icalcomponent_kind_to_string(kind);
+
+   icalerror_check_arg_rz( (kind_string!=0),"Unknown kind of component");
+
+   icalmemory_append_string(&buf, &buf_ptr, &buf_size, "BEGIN:");
+   icalmemory_append_string(&buf, &buf_ptr, &buf_size, kind_string);
+   icalmemory_append_string(&buf, &buf_ptr, &buf_size, newline);
+   
+ 
+   for( itr = pvl_head(impl->properties);
+         itr != 0;
+         itr = pvl_next(itr))
+    { 
+    //  printf("3333calcomponent_as_ical_string System Timezone2: %s %s \n", *tzname, getenv("TZ") );
+        
+        p = (icalproperty*)pvl_data(itr);
+        
+        icalerror_assert((p!=0),"Got a null property");
+        tmp_buf = icalproperty_as_ical_string(p);
+        
+        icalmemory_append_string(&buf, &buf_ptr, &buf_size, tmp_buf);
+    }
+   
+   
+   for( itr = pvl_head(impl->components);
+        itr != 0;
+        itr = pvl_next(itr))
+   { 
+                
+       c = (icalcomponent*)pvl_data(itr);
+       
+       tmp_buf = icalcomponent_as_ical_string(c);
+       icalmemory_append_string(&buf, &buf_ptr, &buf_size, tmp_buf);
+       
+   }
+   
+   icalmemory_append_string(&buf, &buf_ptr, &buf_size, "END:");  //tzset();
+   icalmemory_append_string(&buf, &buf_ptr, &buf_size, 
+                            icalcomponent_kind_to_string(kind));
+   icalmemory_append_string(&buf, &buf_ptr, &buf_size, newline); //tzset();
+
+   out_buf = icalmemory_tmp_copy(buf);
+   free(buf);
+
+   return out_buf;
+}
+
+
+int
+icalcomponent_is_valid (icalcomponent* component)
+{
+    struct icalcomponent_impl *impl = (struct icalcomponent_impl *)component;
+
+        
+    if ( (strcmp(impl->id,"comp") == 0) &&
+         impl->kind != ICAL_NO_COMPONENT){
+        return 1;
+    } else {
+        return 0;
+    }
+
+}
+
+
+icalcomponent_kind
+icalcomponent_isa (icalcomponent* component)
+{
+    struct icalcomponent_impl *impl = (struct icalcomponent_impl *)component;
+    icalerror_check_arg_rz( (component!=0), "component");
+
+   if(component != 0)
+   {
+       return impl->kind;
+   }
+
+   return ICAL_NO_COMPONENT;
+}
+
+
+int
+icalcomponent_isa_component (void* component)
+{
+    struct icalcomponent_impl *impl = (struct icalcomponent_impl *)component;
+
+    icalerror_check_arg_rz( (component!=0), "component");
+
+    if (strcmp(impl->id,"comp") == 0) {
+        return 1;
+    } else {
+        return 0;
+    }
+
+}
+
+int icalcomponent_property_sorter(void *a, void *b)
+{
+    icalproperty_kind kinda, kindb;
+    const char *ksa, *ksb;
+
+    kinda = icalproperty_isa((icalproperty*)a);
+    kindb = icalproperty_isa((icalproperty*)b);
+
+    ksa = icalproperty_kind_to_string(kinda);
+    ksb = icalproperty_kind_to_string(kindb);
+
+    return strcmp(ksa,ksb);
+}
+
+
+void
+icalcomponent_add_property (icalcomponent* component, icalproperty* property)
+{
+    struct icalcomponent_impl *impl;
+
+    icalerror_check_arg_rv( (component!=0), "component");
+    icalerror_check_arg_rv( (property!=0), "property");
+
+     impl = (struct icalcomponent_impl*)component;
+
+    icalerror_assert( (!icalproperty_get_parent(property)),"The property has already been added to a component. Remove the property with icalcomponent_remove_property before calling icalcomponent_add_property");
+
+    icalproperty_set_parent(property,component);
+
+#ifdef ICAL_INSERT_ORDERED
+    pvl_insert_ordered(impl->properties,
+                       icalcomponent_property_sorter,property);
+#else
+    pvl_push(impl->properties,property);
+#endif
+
+}
+
+
+void
+icalcomponent_remove_property (icalcomponent* component, icalproperty* property)
+{
+    struct icalcomponent_impl *impl;
+    pvl_elem itr, next_itr;
+    struct icalproperty_impl *pimpl;
+
+    icalerror_check_arg_rv( (component!=0), "component");
+    icalerror_check_arg_rv( (property!=0), "property");
+    
+    impl = (struct icalcomponent_impl*)component;
+
+    pimpl = (struct icalproperty_impl*)property;
+
+    icalerror_assert( (icalproperty_get_parent(property)),"The property is not a member of a component");
+
+    
+    for( itr = pvl_head(impl->properties);
+         itr != 0;
+         itr = next_itr)
+    {
+        next_itr = pvl_next(itr);
+        
+        if( pvl_data(itr) == (void*)property ){
+
+           if (impl->property_iterator == itr){
+               impl->property_iterator = pvl_next(itr);
+           }
+
+           pvl_remove( impl->properties, itr); 
+          icalproperty_set_parent(property,0);
+        }
+            }
+}
+
+int
+icalcomponent_count_properties (icalcomponent* component, 
+                                icalproperty_kind kind)
+{
+    int count=0;
+    pvl_elem itr;
+    struct icalcomponent_impl *impl = (struct icalcomponent_impl*)component;
+
+    icalerror_check_arg_rz( (component!=0), "component");
+
+    for( itr = pvl_head(impl->properties);
+         itr != 0;
+         itr = pvl_next(itr))
+            {
+        if(kind == icalproperty_isa((icalproperty*)pvl_data(itr)) ||
+            kind == ICAL_ANY_PROPERTY){
+            count++;
+        }
+    }
+
+
+    return count;
+
+}
+
+icalproperty* icalcomponent_get_current_property (icalcomponent* component)
+{
+
+   struct icalcomponent_impl *c = (struct icalcomponent_impl*)component;
+   icalerror_check_arg_rz( (component!=0),"component");
+
+   if ((c->property_iterator==0)){
+       return 0;
+   }
+
+   return (icalproperty*) pvl_data(c->property_iterator);
+
+}
+
+icalproperty*
+icalcomponent_get_first_property (icalcomponent* component, icalproperty_kind kind)
+{
+   struct icalcomponent_impl *c = (struct icalcomponent_impl*)component;
+   icalerror_check_arg_rz( (component!=0),"component");
+  
+   for( c->property_iterator = pvl_head(c->properties);
+        c->property_iterator != 0;
+        c->property_iterator = pvl_next(c->property_iterator)) {
+            
+       icalproperty *p =  (icalproperty*) pvl_data(c->property_iterator);
+        
+           if (icalproperty_isa(p) == kind || kind == ICAL_ANY_PROPERTY) {
+               
+               return p;
+           }
+   }
+   return 0;
+}
+
+icalproperty*
+icalcomponent_get_next_property (icalcomponent* component, icalproperty_kind kind)
+{
+   struct icalcomponent_impl *c = (struct icalcomponent_impl*)component;
+   icalerror_check_arg_rz( (component!=0),"component");
+
+   if (c->property_iterator == 0){
+       return 0;
+   }
+
+   for( c->property_iterator = pvl_next(c->property_iterator);
+        c->property_iterator != 0;
+        c->property_iterator = pvl_next(c->property_iterator)) {
+            
+       icalproperty *p =  (icalproperty*) pvl_data(c->property_iterator);
+           
+       if (icalproperty_isa(p) == kind || kind == ICAL_ANY_PROPERTY) {
+           
+           return p;
+       }
+   }
+
+   return 0;
+}
+
+
+icalproperty**
+icalcomponent_get_properties (icalcomponent* component, icalproperty_kind kind);
+
+
+void
+icalcomponent_add_component (icalcomponent* parent, icalcomponent* child)
+{
+    struct icalcomponent_impl *impl, *cimpl;
+
+    icalerror_check_arg_rv( (parent!=0), "parent");
+    icalerror_check_arg_rv( (child!=0), "child");
+    
+    impl = (struct icalcomponent_impl*)parent;
+    cimpl = (struct icalcomponent_impl*)child;
+
+    if (cimpl->parent !=0) {
+        icalerror_set_errno(ICAL_USAGE_ERROR);
+    }
+
+    cimpl->parent = parent;
+
+    pvl_push(impl->components,child);
+}
+
+
+void
+icalcomponent_remove_component (icalcomponent* parent, icalcomponent* child)
+{
+   struct icalcomponent_impl *impl,*cimpl;
+   pvl_elem itr, next_itr;
+
+   icalerror_check_arg_rv( (parent!=0), "parent");
+   icalerror_check_arg_rv( (child!=0), "child");
+   
+   impl = (struct icalcomponent_impl*)parent;
+   cimpl = (struct icalcomponent_impl*)child;
+   
+   for( itr = pvl_head(impl->components);
+        itr != 0;
+        itr = next_itr)
+   {
+       next_itr = pvl_next(itr);
+       
+       if( pvl_data(itr) == (void*)child ){
+
+           if (impl->component_iterator == itr){
+               /* Don't let the current iterator become invalid */
+
+               /* HACK. The semantics for this are troubling. */
+               impl->component_iterator = 
+                   pvl_next(impl->component_iterator);
+                  
+           }
+           pvl_remove( impl->components, itr); 
+           cimpl->parent = 0;
+           break;
+       }
+           }
+}
+
+
+int
+icalcomponent_count_components (icalcomponent* component, 
+                                icalcomponent_kind kind)
+{
+    int count=0;
+    pvl_elem itr;
+    struct icalcomponent_impl *impl = (struct icalcomponent_impl*)component;
+
+    icalerror_check_arg_rz( (component!=0), "component");
+
+    for( itr = pvl_head(impl->components);
+         itr != 0;
+         itr = pvl_next(itr))
+    {
+        if(kind == icalcomponent_isa((icalcomponent*)pvl_data(itr)) ||
+            kind == ICAL_ANY_COMPONENT){
+            count++;
+        }
+    }
+
+    return count;
+}
+
+icalcomponent*
+icalcomponent_get_current_component(icalcomponent* component)
+{
+   struct icalcomponent_impl *c = (struct icalcomponent_impl*)component;
+
+   icalerror_check_arg_rz( (component!=0),"component");
+
+   if (c->component_iterator == 0){
+       return 0;
+   }
+
+   return (icalcomponent*) pvl_data(c->component_iterator);
+}
+
+icalcomponent*
+icalcomponent_get_first_component (icalcomponent* component, 
+                                   icalcomponent_kind kind)
+{
+   struct icalcomponent_impl *c = (struct icalcomponent_impl*)component;
+
+   icalerror_check_arg_rz( (component!=0),"component");
+  
+   for( c->component_iterator = pvl_head(c->components);
+        c->component_iterator != 0;
+        c->component_iterator = pvl_next(c->component_iterator)) {
+            
+       icalcomponent *p =  (icalcomponent*) pvl_data(c->component_iterator);
+        
+           if (icalcomponent_isa(p) == kind || kind == ICAL_ANY_COMPONENT) {
+               
+               return p;
+           }
+   }
+
+   return 0;
+}
+
+
+icalcomponent*
+icalcomponent_get_next_component (icalcomponent* component, icalcomponent_kind kind)
+{
+   struct icalcomponent_impl *c = (struct icalcomponent_impl*)component;
+
+   icalerror_check_arg_rz( (component!=0),"component");
+  
+   if (c->component_iterator == 0){
+       return 0;
+   }
+
+   for( c->component_iterator = pvl_next(c->component_iterator);
+        c->component_iterator != 0;
+        c->component_iterator = pvl_next(c->component_iterator)) {
+            
+       icalcomponent *p =  (icalcomponent*) pvl_data(c->component_iterator);
+        
+           if (icalcomponent_isa(p) == kind || kind == ICAL_ANY_COMPONENT) {
+               
+               return p;
+           }
+   }
+
+   return 0;
+}
+
+icalcomponent* icalcomponent_get_first_real_component(icalcomponent *c)
+{
+    icalcomponent *comp;
+
+    for(comp = icalcomponent_get_first_component(c,ICAL_ANY_COMPONENT);
+        comp != 0;
+        comp = icalcomponent_get_next_component(c,ICAL_ANY_COMPONENT)){
+
+        icalcomponent_kind kind = icalcomponent_isa(comp);
+
+        if(kind == ICAL_VEVENT_COMPONENT ||
+           kind == ICAL_VTODO_COMPONENT ||
+           kind == ICAL_VJOURNAL_COMPONENT ||
+           kind == ICAL_VFREEBUSY_COMPONENT ){
+            return comp;
+        }
+    }
+    return 0;
+}
+
+time_t icalcomponent_convert_time(icalproperty *p)
+{
+    struct icaltimetype sict;
+    time_t convt;
+    icalproperty *tzp;
+        
+
+    /* Though it says _dtstart, it will work for dtend too */
+    sict = icalproperty_get_dtstart(p);
+
+    tzp = icalproperty_get_first_parameter(p,ICAL_TZID_PARAMETER);
+
+    if (sict.is_utc == 1 && tzp != 0){
+        icalerror_warn("icalcomponent_get_span: component has a UTC DTSTART with a timezone specified ");
+        icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+        return 0; 
+    }
+
+    if(sict.is_utc == 1){
+        /* _as_timet will use gmtime() to do the conversion */
+        convt = icaltime_as_timet(sict);
+
+#ifdef TEST_CONVERT_TIME
+        printf("convert time: use as_timet:\n %s\n %s",
+               icalproperty_as_ical_string(p), ctime(&convt));
+#endif
+
+    } else if (sict.is_utc == 0 && tzp == 0 ) {
+        time_t offset;
+
+        /* _as_timet will use localtime() to do the conversion */
+        convt = icaltime_as_timet(sict);
+        offset = icaltime_utc_offset(sict,0);
+        convt += offset;
+
+#ifdef TEST_CONVERT_TIME
+        printf("convert time: use as_timet and adjust:\n %s\n %s",
+               icalproperty_as_ical_string(p), ctime(&convt));
+#endif
+    } else {
+        /* Convert the time to UTC for the named timezone*/
+        const char* timezone = icalparameter_get_tzid(tzp);
+        convt = icaltime_as_timet(icaltime_as_utc(sict,timezone));
+
+#ifdef TEST_CONVERT_TIME
+        printf("convert time: use _as_utc:\n %s\n %s",
+               icalproperty_as_ical_string(p), ctime(&convt));
+#endif
+            }    
+
+    return convt;
+}
+struct icaltime_span icalcomponent_get_span(icalcomponent* comp)
+{
+    icalcomponent *inner;
+    icalproperty *p, *duration;
+    icalcomponent_kind kind;
+    struct icaltime_span span;
+    struct icaltimetype start;
+
+    span.start = 0;
+    span.end = 0;
+    span.is_busy= 1;
+
+    /* initial Error checking */
+
+/*    icalerror_check_arg_rz( (comp!=0),"comp");*/
+
+    kind  = icalcomponent_isa(comp);
+
+    if(kind == ICAL_VCALENDAR_COMPONENT){
+        inner = icalcomponent_get_first_real_component(comp);
+
+        /* Maybe there is a VTIMEZONE in there */
+        if (inner == 0){
+            inner = icalcomponent_get_first_component(comp,
+                               ICAL_VTIMEZONE_COMPONENT);
+        }
+
+    } else {
+        inner = comp;
+    }
+
+    if (inner == 0){
+        icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+        /*icalerror_warn("icalcomponent_get_span: no component specified, or empty VCALENDAR component");*/
+        return span; 
+    }
+    
+    kind  = icalcomponent_isa(inner);
+
+    if( !( kind == ICAL_VEVENT_COMPONENT ||
+           kind == ICAL_VJOURNAL_COMPONENT ||
+                   kind == ICAL_VTODO_COMPONENT ||   
+           kind == ICAL_VFREEBUSY_COMPONENT )) {
+        icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+        /*icalerror_warn("icalcomponent_get_span: no component specified, or empty VCALENDAR component");*/
+        return span; 
+        
+    }
+
+
+
+    /* Get to work. starting with DTSTART */
+
+    p = icalcomponent_get_first_property(inner, ICAL_DTSTART_PROPERTY);
+
+    if (p ==0 ) {
+        icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+        /*icalerror_warn("icalcomponent_get_span: component has no DTSTART time");*/
+        return span; 
+    }
+
+
+    start = icalproperty_get_dtstart(p);
+
+    icalerror_clear_errno();
+
+    span.start = icalcomponent_convert_time(p);
+
+#ifdef TEST_CONVERT_TIME
+    printf("convert time:\n %s %s",
+           icalproperty_as_ical_string(p), ctime(&span.start));
+#endif
+
+    if(icalerrno != ICAL_NO_ERROR){
+        span.start = 0;
+        return span;
+    }
+
+    /* The end time could be specified as either a DTEND or a DURATION */
+    p = icalcomponent_get_first_property(inner, ICAL_DTEND_PROPERTY);
+    duration = icalcomponent_get_first_property(inner, ICAL_DURATION_PROPERTY);
+
+    if (p==0 && duration == 0 && start.is_date != 1) {
+        icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+        /*icalerror_warn("icalcomponent_get_span: component has neither DTEND nor DURATION time");*/
+        span.start = 0;
+        return span; 
+    } 
+
+    if (p!=0){
+        span.end = icalcomponent_convert_time(p);
+    } else if (start.is_date == 1) {
+        /* Duration is all day */
+        span.end = span.start + 60*60*24;
+    } else {
+        /* Use the duration */
+        struct icaldurationtype dur;
+        time_t durt;
+        
+        
+        dur = icalproperty_get_duration(duration);
+
+        durt = icaldurationtype_as_int(dur);
+        span.end = span.start+durt;
+    }
+
+    return span;
+
+}
+
+
+int icalcomponent_count_errors(icalcomponent* component)
+{
+    int errors = 0;
+    icalproperty *p;
+    icalcomponent *c;
+    pvl_elem itr;
+    struct icalcomponent_impl *impl = (struct icalcomponent_impl*)component;
+
+    for( itr = pvl_head(impl->properties);
+         itr != 0;
+         itr = pvl_next(itr))
+            {
+        p = (icalproperty*)pvl_data(itr);
+        
+        if(icalproperty_isa(p) == ICAL_XLICERROR_PROPERTY)
+        {
+            errors++;
+        }
+    }
+
+
+    for( itr = pvl_head(impl->components);
+         itr != 0;
+         itr = pvl_next(itr))
+            {
+        c = (icalcomponent*)pvl_data(itr);
+        
+        errors += icalcomponent_count_errors(c);
+        
+    }
+
+    return errors;
+}
+
+
+void icalcomponent_strip_errors(icalcomponent* component)
+{
+    icalproperty *p;
+    icalcomponent *c;
+    pvl_elem itr, next_itr;
+    struct icalcomponent_impl *impl = (struct icalcomponent_impl*)component;
+
+   for( itr = pvl_head(impl->properties);
+         itr != 0;
+         itr = next_itr)
+            {
+        p = (icalproperty*)pvl_data(itr);
+        next_itr = pvl_next(itr);
+
+        if(icalproperty_isa(p) == ICAL_XLICERROR_PROPERTY)
+        {
+            icalcomponent_remove_property(component,p);
+        }
+    }
+    
+    for( itr = pvl_head(impl->components);
+         itr != 0;
+         itr = pvl_next(itr))
+            {
+        c = (icalcomponent*)pvl_data(itr);
+        icalcomponent_strip_errors(c);
+    }
+}
+
+/* Hack. This will change the state of the iterators */
+void icalcomponent_convert_errors(icalcomponent* component)
+{
+    icalproperty *p, *next_p;
+    icalcomponent *c;
+
+    for(p = icalcomponent_get_first_property(component,ICAL_ANY_PROPERTY);
+        p != 0;
+        p = next_p){
+        
+        next_p = icalcomponent_get_next_property(component,ICAL_ANY_PROPERTY);
+
+        if(icalproperty_isa(p) == ICAL_XLICERROR_PROPERTY)
+        {
+            struct icalreqstattype rst;
+            icalparameter *param  = icalproperty_get_first_parameter
+                (p,ICAL_XLICERRORTYPE_PARAMETER);
+
+            rst.code = ICAL_UNKNOWN_STATUS;
+            rst.desc = 0;
+
+            switch(icalparameter_get_xlicerrortype(param)){
+
+                case  ICAL_XLICERRORTYPE_PARAMETERNAMEPARSEERROR: {
+                    rst.code = ICAL_3_2_INVPARAM_STATUS;
+                    break;
+                }
+                case  ICAL_XLICERRORTYPE_PARAMETERVALUEPARSEERROR: {
+                    rst.code = ICAL_3_3_INVPARAMVAL_STATUS;
+                    break;
+                }
+                        case  ICAL_XLICERRORTYPE_PROPERTYPARSEERROR: {      
+                    rst.code = ICAL_3_0_INVPROPNAME_STATUS;
+                    break;
+                }
+                case  ICAL_XLICERRORTYPE_VALUEPARSEERROR: {
+                    rst.code = ICAL_3_1_INVPROPVAL_STATUS;
+                    break;
+                }
+                case  ICAL_XLICERRORTYPE_COMPONENTPARSEERROR: {
+                    rst.code = ICAL_3_4_INVCOMP_STATUS;
+                    break;
+                }
+
+                default: {
+                }
+            }
+            if (rst.code != ICAL_UNKNOWN_STATUS){
+                
+                rst.debug = icalproperty_get_xlicerror(p);
+                icalcomponent_add_property(component,
+                                           icalproperty_new_requeststatus(rst));
+                
+                icalcomponent_remove_property(component,p);
+            }
+        }
+    }
+
+    for(c = icalcomponent_get_first_component(component,ICAL_ANY_COMPONENT);
+        c != 0;
+        c = icalcomponent_get_next_component(component,ICAL_ANY_COMPONENT)){
+        
+        icalcomponent_convert_errors(c);
+    }
+}
+
+
+icalcomponent* icalcomponent_get_parent(icalcomponent* component)
+{
+   struct icalcomponent_impl *c = (struct icalcomponent_impl*)component;
+
+   return c->parent;
+}
+
+void icalcomponent_set_parent(icalcomponent* component, icalcomponent* parent)
+{
+   struct icalcomponent_impl *c = (struct icalcomponent_impl*)component;
+
+   c->parent = parent;
+}
+
+icalcompiter icalcompiter_null = {ICAL_NO_COMPONENT,0};
+
+
+struct icalcomponent_kind_map {
+        icalcomponent_kind kind;
+        char name[20];
+};
+
+  
+
+static struct icalcomponent_kind_map component_map[] = 
+{
+    { ICAL_VEVENT_COMPONENT, "VEVENT" },
+    { ICAL_VTODO_COMPONENT, "VTODO" },
+    { ICAL_VJOURNAL_COMPONENT, "VJOURNAL" },
+    { ICAL_VCALENDAR_COMPONENT, "VCALENDAR" },
+    { ICAL_VFREEBUSY_COMPONENT, "VFREEBUSY" },
+    { ICAL_VTIMEZONE_COMPONENT, "VTIMEZONE" },
+    { ICAL_VALARM_COMPONENT, "VALARM" },
+    { ICAL_XSTANDARD_COMPONENT, "STANDARD" }, /*These are part of RFC2445 */
+    { ICAL_XDAYLIGHT_COMPONENT, "DAYLIGHT" }, /*but are not really components*/
+    { ICAL_X_COMPONENT, "X" },
+    { ICAL_VSCHEDULE_COMPONENT, "SCHEDULE" },
+
+    /* CAP components */
+    { ICAL_VQUERY_COMPONENT, "VQUERY" },  
+    { ICAL_VCAR_COMPONENT, "VCAR" },  
+    { ICAL_VCOMMAND_COMPONENT, "VCOMMAND" },  
+
+    /* libical private components */
+    { ICAL_XLICINVALID_COMPONENT, "X-LIC-UNKNOWN" },  
+    { ICAL_XLICMIMEPART_COMPONENT, "X-LIC-MIME-PART" },  
+    { ICAL_ANY_COMPONENT, "ANY" },  
+    { ICAL_XROOT_COMPONENT, "XROOT" },  
+
+    /* End of list */
+    { ICAL_NO_COMPONENT, "" },
+};
+
+
+
+const char* icalcomponent_kind_to_string(icalcomponent_kind kind)
+{
+    int i;
+
+    for (i=0; component_map[i].kind != ICAL_NO_COMPONENT; i++) {
+        if (component_map[i].kind == kind) {
+            return component_map[i].name;
+        }
+    }
+
+    return 0;
+
+}
+
+icalcomponent_kind icalcomponent_string_to_kind(const char* string)
+{
+    int i;
+
+    if (string ==0 ) { 
+        return ICAL_NO_COMPONENT;
+    }
+
+    for (i=0; component_map[i].kind  != ICAL_NO_COMPONENT; i++) {
+        if (strcmp(component_map[i].name, string) == 0) {
+            return component_map[i].kind;
+        }
+    }
+
+    return ICAL_NO_COMPONENT;
+}
+
+
+
+icalcompiter 
+icalcomponent_begin_component(icalcomponent* component,icalcomponent_kind kind)
+{
+    struct icalcomponent_impl *impl = (struct icalcomponent_impl*)component;
+    icalcompiter itr = icalcompiter_null;
+    pvl_elem i;
+
+    itr.kind = kind;
+
+    icalerror_check_arg_re( (component!=0),"component",icalcompiter_null);
+
+    for( i = pvl_head(impl->components); i != 0; i = pvl_next(itr.iter)) {
+        
+        icalcomponent *c =  (icalcomponent*) pvl_data(i);
+        
+        if (icalcomponent_isa(c) == kind || kind == ICAL_ANY_COMPONENT) {
+            
+            itr.iter = i;
+
+            return itr;
+        }
+    }
+
+    return icalcompiter_null;
+}
+
+icalcompiter
+icalcomponent_end_component(icalcomponent* component,icalcomponent_kind kind)
+{
+    struct icalcomponent_impl *impl = (struct icalcomponent_impl*)component;
+    icalcompiter itr; 
+    pvl_elem i;
+
+    itr.kind = kind;
+
+    icalerror_check_arg_re( (component!=0),"component",icalcompiter_null);
+
+    for( i = pvl_tail(impl->components); i != 0; i = pvl_prior(i)) {
+        
+        icalcomponent *c =  (icalcomponent*) pvl_data(i);
+        
+        if (icalcomponent_isa(c) == kind || kind == ICAL_ANY_COMPONENT) {
+            
+            itr.iter = pvl_next(i);
+
+            return itr;
+        }
+    }
+
+    return icalcompiter_null;;
+}
+
+
+icalcomponent* icalcompiter_next(icalcompiter* i)
+{
+   if (i->iter == 0){
+       return 0;
+   }
+
+   icalerror_check_arg_rz( (i!=0),"i");
+
+   for( i->iter = pvl_next(i->iter);
+        i->iter != 0;
+        i->iter = pvl_next(i->iter)) {
+            
+       icalcomponent *c =  (icalcomponent*) pvl_data(i->iter);
+        
+           if (icalcomponent_isa(c) == i->kind 
+               || i->kind == ICAL_ANY_COMPONENT) {
+               
+               return icalcompiter_deref(i);;
+           }
+   }
+
+   return 0;
+
+}
+
+icalcomponent* icalcompiter_prior(icalcompiter* i)
+{
+   if (i->iter == 0){
+       return 0;
+   }
+
+   for( i->iter = pvl_prior(i->iter);
+        i->iter != 0;
+        i->iter = pvl_prior(i->iter)) {
+            
+       icalcomponent *c =  (icalcomponent*) pvl_data(i->iter);
+        
+           if (icalcomponent_isa(c) == i->kind 
+               || i->kind == ICAL_ANY_COMPONENT) {
+               
+               return icalcompiter_deref(i);;
+           }
+   }
+
+   return 0;
+
+}
+icalcomponent* icalcompiter_deref(icalcompiter* i)
+{
+    if(i->iter ==0){
+        return 0;
+    }
+
+    return pvl_data(i->iter);
+}
+
+icalcomponent* icalcomponent_get_inner(icalcomponent* comp)
+{
+    if (icalcomponent_isa(comp) == ICAL_VCALENDAR_COMPONENT){
+        return icalcomponent_get_first_real_component(comp);
+    } else {
+        return comp;
+    }
+}
+
+
+void icalcomponent_set_dtstart(icalcomponent* comp, struct icaltimetype v)
+{
+
+    icalcomponent *inner = icalcomponent_get_inner(comp); 
+    icalproperty *prop 
+        = icalcomponent_get_first_property(inner, ICAL_DTSTART_PROPERTY);
+
+
+    if (prop == 0){
+        prop = icalproperty_new_dtstart(v);
+        icalcomponent_add_property(inner, prop);
+    }
+    
+    icalproperty_set_dtstart(prop,v);
+
+}
+
+
+struct icaltimetype icalcomponent_get_dtstart(icalcomponent* comp)
+{
+    icalcomponent *inner = icalcomponent_get_inner(comp); 
+    icalproperty *prop 
+        = icalcomponent_get_first_property(inner,ICAL_DTSTART_PROPERTY);
+
+    if (prop == 0){
+        return icaltime_null_time();
+    }
+    
+    return icalproperty_get_dtstart(prop);
+}
+
+
+struct icaltimetype icalcomponent_get_dtend(icalcomponent* comp)
+{
+    icalcomponent *inner = icalcomponent_get_inner(comp); 
+
+    icalproperty *end_prop 
+        = icalcomponent_get_first_property(inner,ICAL_DTEND_PROPERTY);
+
+    icalproperty *dur_prop 
+        = icalcomponent_get_first_property(inner, ICAL_DURATION_PROPERTY);
+
+
+    if( end_prop == 0 && dur_prop == 0){
+        return icaltime_null_time();
+    } else if ( end_prop != 0) {
+        return icalproperty_get_dtend(end_prop);
+    } else if ( dur_prop != 0) { 
+        
+        struct icaltimetype start = 
+            icalcomponent_get_dtstart(inner);
+        struct icaldurationtype duration = 
+            icalproperty_get_duration(dur_prop);
+        
+        struct icaltimetype end = icaltime_add(start,duration);
+
+        return end;
+
+    } else {
+        /* Error, both duration and dtend have been specified */
+        icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+        return icaltime_null_time();
+
+    }
+    
+}
+
+
+void icalcomponent_set_dtend(icalcomponent* comp, struct icaltimetype v)
+{
+    icalcomponent *inner = icalcomponent_get_inner(comp); 
+
+    icalproperty *end_prop 
+        = icalcomponent_get_first_property(inner,ICAL_DTEND_PROPERTY);
+
+    icalproperty *dur_prop 
+        = icalcomponent_get_first_property(inner,ICAL_DURATION_PROPERTY);
+
+
+    if( end_prop == 0 && dur_prop == 0){
+        end_prop = icalproperty_new_dtend(v);
+        icalcomponent_add_property(inner,end_prop);
+    } else if ( end_prop != 0) {
+        icalproperty_set_dtend(end_prop,v);
+    } else if ( dur_prop != 0) { 
+        struct icaltimetype start = 
+            icalcomponent_get_dtstart(inner);
+
+        struct icaltimetype end = 
+            icalcomponent_get_dtend(inner);
+
+        struct icaldurationtype dur 
+            = icaltime_subtract(end,start);
+
+        icalproperty_set_duration(dur_prop,dur);
+
+    } else {
+        /* Error, both duration and dtend have been specified */
+        icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+    }
+}
+
+void icalcomponent_set_duration(icalcomponent* comp, 
+                                struct icaldurationtype v)
+{
+    icalcomponent *inner = icalcomponent_get_inner(comp); 
+
+    icalproperty *end_prop 
+        = icalcomponent_get_first_property(inner,ICAL_DTEND_PROPERTY);
+
+    icalproperty *dur_prop 
+        = icalcomponent_get_first_property(inner,ICAL_DURATION_PROPERTY);
+
+
+    if( end_prop == 0 && dur_prop == 0){
+        dur_prop = icalproperty_new_duration(v);
+        icalcomponent_add_property(inner, dur_prop);
+    } else if ( end_prop != 0) {
+        struct icaltimetype start = 
+            icalcomponent_get_dtstart(inner);
+        
+        struct icaltimetype new_end = icaltime_add(start,v);
+
+        icalproperty_set_dtend(end_prop,new_end);
+
+    } else if ( dur_prop != 0) { 
+        icalproperty_set_duration(dur_prop,v);
+    } else {
+        /* Error, both duration and dtend have been specified */
+        icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+    }
+}
+
+struct icaldurationtype icalcomponent_get_duration(icalcomponent* comp)
+{
+    icalcomponent *inner = icalcomponent_get_inner(comp); 
+
+    icalproperty *end_prop 
+        = icalcomponent_get_first_property(inner,ICAL_DTEND_PROPERTY);
+
+    icalproperty *dur_prop 
+        = icalcomponent_get_first_property(inner,ICAL_DURATION_PROPERTY);
+
+    struct icaldurationtype null_duration;
+    memset(&null_duration,0,sizeof(struct icaldurationtype));
+
+
+    if( end_prop == 0 && dur_prop == 0){
+        return null_duration;
+    } else if ( end_prop != 0) {
+        struct icaltimetype start = 
+            icalcomponent_get_dtstart(inner);
+        time_t startt = icaltime_as_timet(start);
+
+        struct icaltimetype end = 
+            icalcomponent_get_dtend(inner);
+        time_t endt = icaltime_as_timet(end);
+        
+        return icaldurationtype_from_int(endt-startt);
+    } else if ( dur_prop != 0) { 
+        return icalproperty_get_duration(dur_prop);
+    } else {
+        /* Error, both duration and dtend have been specified */
+        icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+        return null_duration;
+    }
+}
+
+void icalcomponent_set_method(icalcomponent* comp, icalproperty_method method)
+{
+    icalproperty *prop 
+        = icalcomponent_get_first_property(comp, ICAL_METHOD_PROPERTY);
+
+
+    if (prop == 0){
+        prop = icalproperty_new_method(method);
+        icalcomponent_add_property(comp, prop);
+    }
+    
+    icalproperty_set_method(prop,method);
+
+}
+
+icalproperty_method icalcomponent_get_method(icalcomponent* comp)
+{
+    icalproperty *prop 
+        = icalcomponent_get_first_property(comp,ICAL_METHOD_PROPERTY);
+
+    if (prop == 0){
+        return ICAL_METHOD_NONE;
+    }
+    
+    return icalproperty_get_method(prop);
+}
+
+void icalcomponent_set_dtstamp(icalcomponent* comp, struct icaltimetype v)
+{
+
+    icalcomponent *inner = icalcomponent_get_inner(comp); 
+    icalproperty *prop 
+        = icalcomponent_get_first_property(inner, ICAL_DTSTAMP_PROPERTY);
+
+
+    if (prop == 0){
+        prop = icalproperty_new_dtstamp(v);
+        icalcomponent_add_property(inner, prop);
+    }
+    
+    icalproperty_set_dtstamp(prop,v);
+
+}
+
+
+struct icaltimetype icalcomponent_get_dtstamp(icalcomponent* comp)
+{
+    icalcomponent *inner = icalcomponent_get_inner(comp); 
+    icalproperty *prop 
+        = icalcomponent_get_first_property(inner,ICAL_DTSTAMP_PROPERTY);
+
+    if (prop == 0){
+        return icaltime_null_time();
+    }
+    
+    return icalproperty_get_dtstamp(prop);
+}
+
+
+void icalcomponent_set_summary(icalcomponent* comp, const char* v)
+{
+    icalcomponent *inner = icalcomponent_get_inner(comp); 
+    icalproperty *prop 
+        = icalcomponent_get_first_property(inner, ICAL_SUMMARY_PROPERTY);
+
+    if (prop == 0){
+        prop = icalproperty_new_summary(v);
+        icalcomponent_add_property(inner, prop);
+    }
+    
+    icalproperty_set_summary(prop,v);
+}
+
+
+const char* icalcomponent_get_summary(icalcomponent* comp)
+{
+    icalcomponent *inner = icalcomponent_get_inner(comp); 
+    icalproperty *prop 
+        = icalcomponent_get_first_property(inner,ICAL_SUMMARY_PROPERTY);
+
+    if (prop == 0){
+        return 0;
+    }
+    
+    return icalproperty_get_summary(prop);
+
+}
+
+void icalcomponent_set_comment(icalcomponent* comp, const char* v);
+const char* icalcomponent_get_comment(icalcomponent* comp);
+
+void icalcomponent_set_uid(icalcomponent* comp, const char* v);
+const char* icalcomponent_get_uid(icalcomponent* comp);
+
+void icalcomponent_set_recurrenceid(icalcomponent* comp, 
+                                    struct icaltimetype v);
+struct icaltimetype icalcomponent_get_recurrenceid(icalcomponent* comp);
+
+
+
+
+icalcomponent* icalcomponent_new_vcalendar()
+{
+    return icalcomponent_new(ICAL_VCALENDAR_COMPONENT);
+}
+icalcomponent* icalcomponent_new_vevent()
+{
+    return icalcomponent_new(ICAL_VEVENT_COMPONENT);
+}
+icalcomponent* icalcomponent_new_vtodo()
+{
+    return icalcomponent_new(ICAL_VTODO_COMPONENT);
+}
+icalcomponent* icalcomponent_new_vjournal()
+{
+    return icalcomponent_new(ICAL_VJOURNAL_COMPONENT);
+}
+icalcomponent* icalcomponent_new_valarm()
+{
+    return icalcomponent_new(ICAL_VALARM_COMPONENT);
+}
+icalcomponent* icalcomponent_new_vfreebusy()
+{
+    return icalcomponent_new(ICAL_VFREEBUSY_COMPONENT);
+}
+icalcomponent* icalcomponent_new_vtimezone()
+{
+    return icalcomponent_new(ICAL_VTIMEZONE_COMPONENT);
+}
+icalcomponent* icalcomponent_new_xstandard()
+{
+    return icalcomponent_new(ICAL_XSTANDARD_COMPONENT);
+}
+icalcomponent* icalcomponent_new_xdaylight()
+{
+    return icalcomponent_new(ICAL_XDAYLIGHT_COMPONENT);
+}
diff --git a/libical/src/libical/icalcomponent.h b/libical/src/libical/icalcomponent.h
new file mode 100644
index 0000000..6046bbe
--- a/dev/null
+++ b/libical/src/libical/icalcomponent.h
@@ -0,0 +1,240 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalcomponent.h
+ CREATOR: eric 20 March 1999
+
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalcomponent.h
+
+======================================================================*/
+
+#ifndef ICALCOMPONENT_H
+#define ICALCOMPONENT_H
+
+#include "icalproperty.h"
+#include "icalvalue.h"
+#include "icalenums.h" /* defines icalcomponent_kind */
+#include "icalattendee.h"
+#include "pvl.h"
+
+typedef void icalcomponent;
+
+/* This is exposed so that callers will not have to allocate and
+   deallocate iterators. Pretend that you can't see it. */
+typedef struct icalcompiter
+{
+        icalcomponent_kind kind;
+        pvl_elem iter;
+
+} icalcompiter;
+
+icalcomponent* icalcomponent_new(icalcomponent_kind kind);
+icalcomponent* icalcomponent_new_clone(icalcomponent* component);
+icalcomponent* icalcomponent_new_from_string(char* str);
+icalcomponent* icalcomponent_vanew(icalcomponent_kind kind, ...);
+void icalcomponent_free(icalcomponent* component);
+
+char* icalcomponent_as_ical_string(icalcomponent* component);
+
+int icalcomponent_is_valid(icalcomponent* component);
+
+icalcomponent_kind icalcomponent_isa(icalcomponent* component);
+
+int icalcomponent_isa_component (void* component);
+
+/* 
+ * Working with properties
+ */
+
+void icalcomponent_add_property(icalcomponent* component,
+                                icalproperty* property);
+
+void icalcomponent_remove_property(icalcomponent* component,
+                                   icalproperty* property);
+
+int icalcomponent_count_properties(icalcomponent* component,
+                                   icalproperty_kind kind);
+
+/* Iterate through the properties */
+icalproperty* icalcomponent_get_current_property(icalcomponent* component);
+
+icalproperty* icalcomponent_get_first_property(icalcomponent* component,
+                                              icalproperty_kind kind);
+icalproperty* icalcomponent_get_next_property(icalcomponent* component,
+                                              icalproperty_kind kind);
+
+
+/* 
+ * Working with components
+ */ 
+
+
+/* Return the first VEVENT, VTODO or VJOURNAL sub-component of cop, or
+   comp if it is one of those types */
+
+icalcomponent* icalcomponent_get_inner(icalcomponent* comp);
+
+
+void icalcomponent_add_component(icalcomponent* parent,
+                                icalcomponent* child);
+
+void icalcomponent_remove_component(icalcomponent* parent,
+                                icalcomponent* child);
+
+int icalcomponent_count_components(icalcomponent* component,
+                                   icalcomponent_kind kind);
+
+/* Iteration Routines. There are two forms of iterators, internal and
+external. The internal ones came first, and are almost completely
+sufficient, but they fail badly when you want to construct a loop that
+removes components from the container.*/
+
+
+/* Iterate through components */
+icalcomponent* icalcomponent_get_current_component (icalcomponent* component);
+
+icalcomponent* icalcomponent_get_first_component(icalcomponent* component,
+                                              icalcomponent_kind kind);
+icalcomponent* icalcomponent_get_next_component(icalcomponent* component,
+                                              icalcomponent_kind kind);
+
+/* Using external iterators */
+icalcompiter icalcomponent_begin_component(icalcomponent* component,
+                                           icalcomponent_kind kind);
+icalcompiter icalcomponent_end_component(icalcomponent* component,
+                                         icalcomponent_kind kind);
+icalcomponent* icalcompiter_next(icalcompiter* i);
+icalcomponent* icalcompiter_prior(icalcompiter* i);
+icalcomponent* icalcompiter_deref(icalcompiter* i);
+
+
+
+
+/* Working with embedded error properties */
+
+int icalcomponent_count_errors(icalcomponent* component);
+
+/* Remove all X-LIC-ERROR properties*/
+void icalcomponent_strip_errors(icalcomponent* component);
+
+/* Convert some X-LIC-ERROR properties into RETURN-STATUS properties*/
+void icalcomponent_convert_errors(icalcomponent* component);
+
+/* Internal operations. They are private, and you should not be using them. */
+icalcomponent* icalcomponent_get_parent(icalcomponent* component);
+void icalcomponent_set_parent(icalcomponent* component, 
+                              icalcomponent* parent);
+
+/* Kind conversion routiens */
+
+icalcomponent_kind icalcomponent_string_to_kind(const char* string);
+
+const char* icalcomponent_kind_to_string(icalcomponent_kind kind);
+
+
+/************* Derived class methods.  ****************************
+
+If the code was in an OO language, the remaining routines would be
+members of classes derived from icalcomponent. Don't call them on the
+wrong component subtypes. */
+
+/* For VCOMPONENT: Return a reference to the first VEVENT, VTODO or
+   VJOURNAL */
+icalcomponent* icalcomponent_get_first_real_component(icalcomponent *c);
+
+/* For VEVENT, VTODO, VJOURNAL and VTIMEZONE: report the start and end
+   times of an event in UTC */
+struct icaltime_span icalcomponent_get_span(icalcomponent* comp);
+
+/******************** Convienience routines **********************/
+
+void icalcomponent_set_dtstart(icalcomponent* comp, struct icaltimetype v);
+struct icaltimetype icalcomponent_get_dtstart(icalcomponent* comp);
+
+/* For the icalcomponent routines only, dtend and duration are tied
+   together. If you call the set routine for one and the other exists,
+   the routine will calculate the change to the other. That is, if
+   there is a DTEND and you call set_duration, the routine will modify
+   DTEND to be the sum of DTSTART and the duration. If you call a get
+   routine for one and the other exists, the routine will calculate
+   the return value. If you call a set routine and neither exists, the
+   routine will create the apcompriate comperty */
+
+
+struct icaltimetype icalcomponent_get_dtend(icalcomponent* comp);
+void icalcomponent_set_dtend(icalcomponent* comp, struct icaltimetype v);
+
+void icalcomponent_set_duration(icalcomponent* comp, 
+                                struct icaldurationtype v);
+struct icaldurationtype icalcomponent_get_duration(icalcomponent* comp);
+
+void icalcomponent_set_method(icalcomponent* comp, icalproperty_method method);
+icalproperty_method icalcomponent_get_method(icalcomponent* comp);
+
+struct icaltimetype icalcomponent_get_dtstamp(icalcomponent* comp);
+void icalcomponent_set_dtstamp(icalcomponent* comp, struct icaltimetype v);
+
+
+void icalcomponent_set_summary(icalcomponent* comp, const char* v);
+const char* icalcomponent_get_summary(icalcomponent* comp);
+
+void icalcomponent_set_comment(icalcomponent* comp, const char* v);
+const char* icalcomponent_get_comment(icalcomponent* comp);
+
+void icalcomponent_set_uid(icalcomponent* comp, const char* v);
+const char* icalcomponent_get_uid(icalcomponent* comp);
+
+void icalcomponent_set_recurrenceid(icalcomponent* comp, 
+                                    struct icaltimetype v);
+struct icaltimetype icalcomponent_get_recurrenceid(icalcomponent* comp);
+
+
+void icalcomponent_set_organizer(icalcomponent* comp, 
+                                 struct icalorganizertype org);
+                                 struct icalorganizertype icalcomponent_get_organizer(icalcomponent* comp);
+
+
+void icalcomponent_add_attendee(icalcomponent *comp,
+                                struct icalattendeetype attendee);
+
+int icalcomponent_remove_attendee(icalcomponent *comp, char* cuid);
+
+/* Get the Nth attendee. Out of range indices return an attendee
+   with cuid == 0 */
+struct icalattendeetype icalcomponent_get_attendee(icalcomponent *comp,
+  int index);
+
+
+
+
+/*************** Type Specific routines ***************/
+
+icalcomponent* icalcomponent_new_vcalendar();
+icalcomponent* icalcomponent_new_vevent();
+icalcomponent* icalcomponent_new_vtodo();
+icalcomponent* icalcomponent_new_vjournal();
+icalcomponent* icalcomponent_new_valarm();
+icalcomponent* icalcomponent_new_vfreebusy();
+icalcomponent* icalcomponent_new_vtimezone();
+icalcomponent* icalcomponent_new_xstandard();
+icalcomponent* icalcomponent_new_xdaylight();
+
+
+
+#endif /* !ICALCOMPONENT_H */
+
+
+
diff --git a/libical/src/libical/icalderivedparameter.c b/libical/src/libical/icalderivedparameter.c
new file mode 100644
index 0000000..6898eb6
--- a/dev/null
+++ b/libical/src/libical/icalderivedparameter.c
@@ -0,0 +1,1205 @@
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: icalderivedparameters.{c,h}
+  CREATOR: eric 09 May 1999
+  
+  $Id$
+  $Locker$
+    
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalderivedparameters.{c,h}
+
+  Contributions from:
+     Graham Davison (g.m.davison@computer.org)
+
+ ======================================================================*/
+/*#line 29 "icalparameter.c.in"*/
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+
+#include "icalparameter.h"
+#include "icalparameterimpl.h"
+
+#include "icalproperty.h"
+#include "icalerror.h"
+#include "icalmemory.h"
+
+#include <stdlib.h> /* for malloc() */
+#include <errno.h>
+#include <string.h> /* for memset() */
+
+icalvalue_kind icalparameter_value_to_value_kind(icalparameter_value value);
+
+struct icalparameter_impl* icalparameter_new_impl(icalparameter_kind kind);
+
+/* This map associates each of the parameters with the string
+   representation of the paramter's name */
+struct icalparameter_kind_map {
+    icalparameter_kind kind;
+    char *name;
+    
+};
+
+extern  struct icalparameter_kind_map parameter_map[];
+
+
+const char* icalparameter_kind_to_string(icalparameter_kind kind)
+{
+    int i;
+
+    for (i=0; parameter_map[i].kind != ICAL_NO_PARAMETER; i++) {
+        if (parameter_map[i].kind == kind) {
+            return parameter_map[i].name;
+        }
+    }
+
+    return 0;
+
+}
+
+icalparameter_kind icalparameter_string_to_kind(const char* string)
+{
+    int i;
+
+    if (string ==0 ) { 
+        return ICAL_NO_PARAMETER;
+    }
+
+    for (i=0; parameter_map[i].kind  != ICAL_NO_PARAMETER; i++) {
+
+        if (strcmp(parameter_map[i].name, string) == 0) {
+            return parameter_map[i].kind;
+        }
+    }
+
+    if(strncmp(string,"X-",2)==0){
+        return ICAL_X_PARAMETER;
+    }
+
+    return ICAL_NO_PARAMETER;
+}
+
+/* This map associates the enumerations for the VALUE parameter with
+   the kinds of VALUEs. */
+
+struct icalparameter_value_kind_map {
+    icalparameter_value value; 
+    icalvalue_kind kind; 
+};
+
+extern struct icalparameter_value_kind_map value_kind_map[];
+
+
+icalvalue_kind icalparameter_value_to_value_kind(icalparameter_value value)
+{
+    int i;
+
+    for (i=0; value_kind_map[i].kind  != ICAL_NO_VALUE; i++) {
+
+        if (value_kind_map[i].value == value) {
+            return value_kind_map[i].kind;
+        }
+    }
+
+    return ICAL_NO_VALUE;
+}
+
+
+/* This map associates the parameter enumerations with a specific parameter and the string representation of the enumeration */
+
+struct icalparameter_map {
+    icalparameter_kind kind;
+    int enumeration;
+    const char* str;
+};
+
+
+extern struct icalparameter_map icalparameter_map[];
+
+
+const char* icalparameter_enum_to_string(int e) 
+{
+    int i;
+
+    icalerror_check_arg_rz(e >= ICALPARAMETER_FIRST_ENUM,"e");
+    icalerror_check_arg_rz(e <= ICALPARAMETER_LAST_ENUM,"e");
+
+    for (i=0; icalparameter_map[i].kind != ICAL_NO_PARAMETER; i++){
+        if(e == icalparameter_map[i].enumeration){
+            return icalparameter_map[i].str;
+        }
+    }
+
+    return 0;
+}
+
+int icalparameter_string_to_enum(const char* str)
+{
+    int i;
+
+    icalerror_check_arg_rz(str != 0,"str");
+
+    for (i=0; icalparameter_map[i].kind != ICAL_NO_PARAMETER; i++){
+        if(strcmp(str,icalparameter_map[i].str) == 0) {
+            return icalparameter_map[i].enumeration;
+        }
+    }
+
+    return 0;
+}
+
+icalparameter* icalparameter_new_from_value_string(icalparameter_kind kind,const  char* val)
+{
+
+    struct icalparameter_impl* param=0;
+    int found_kind = 0;
+    int i;
+
+    icalerror_check_arg_rz((val!=0),"val");
+
+    /* Search through the parameter map to find a matching kind */
+
+    param = icalparameter_new_impl(kind);
+
+    for (i=0; icalparameter_map[i].kind != ICAL_NO_PARAMETER; i++){
+        if(kind == icalparameter_map[i].kind) {
+            found_kind = 1;
+            if(strcmp(val,icalparameter_map[i].str) == 0) {
+
+                param->data = (int)icalparameter_map[i].enumeration;
+                return param;
+            }
+        }
+    }
+    
+    if(found_kind == 1){
+        /* The kind was in the parameter map, but the string did not
+           match, so assume that it is an alternate value, like an
+           X-value.*/
+        
+        icalparameter_set_xvalue(param, val);
+
+    } else {
+ 
+        /* If the kind was not found, then it must be a string type */
+        
+        ((struct icalparameter_impl*)param)->string = icalmemory_strdup(val);
+
+    }
+
+   return param;
+}
+
+
+
+
+/* Everything below this line is machine generated. Do not edit. */
+struct  icalparameter_value_kind_map value_kind_map[] = {
+    {ICAL_VALUE_BINARY,ICAL_BINARY_VALUE},
+    {ICAL_VALUE_BOOLEAN,ICAL_BOOLEAN_VALUE},
+    {ICAL_VALUE_DATE,ICAL_DATE_VALUE},
+    {ICAL_VALUE_DURATION,ICAL_DURATION_VALUE},
+    {ICAL_VALUE_FLOAT,ICAL_FLOAT_VALUE},
+    {ICAL_VALUE_INTEGER,ICAL_INTEGER_VALUE},
+    {ICAL_VALUE_PERIOD,ICAL_PERIOD_VALUE},
+    {ICAL_VALUE_RECUR,ICAL_RECUR_VALUE},
+    {ICAL_VALUE_TEXT,ICAL_TEXT_VALUE},
+    {ICAL_VALUE_URI,ICAL_URI_VALUE},
+    {ICAL_VALUE_DATETIME,ICAL_DATETIME_VALUE},
+    {ICAL_VALUE_UTCOFFSET,ICAL_UTCOFFSET_VALUE},
+    {ICAL_VALUE_CALADDRESS,ICAL_CALADDRESS_VALUE},
+    {ICAL_VALUE_X,ICAL_X_VALUE},
+    {ICAL_VALUE_NONE,ICAL_NO_VALUE}
+};
+
+static struct icalparameter_kind_map parameter_map[] = { 
+    {ICAL_ALTREP_PARAMETER,"ALTREP"},
+    {ICAL_CN_PARAMETER,"CN"},
+    {ICAL_CUTYPE_PARAMETER,"CUTYPE"},
+    {ICAL_DELEGATEDFROM_PARAMETER,"DELEGATED-FROM"},
+    {ICAL_DELEGATEDTO_PARAMETER,"DELEGATED-TO"},
+    {ICAL_DIR_PARAMETER,"DIR"},
+    {ICAL_ENCODING_PARAMETER,"ENCODING"},
+    {ICAL_FBTYPE_PARAMETER,"FBTYPE"},
+    {ICAL_FMTTYPE_PARAMETER,"FMTTYPE"},
+    {ICAL_LANGUAGE_PARAMETER,"LANGUAGE"},
+    {ICAL_MEMBER_PARAMETER,"MEMBER"},
+    {ICAL_PARTSTAT_PARAMETER,"PARTSTAT"},
+    {ICAL_RANGE_PARAMETER,"RANGE"},
+    {ICAL_RELATED_PARAMETER,"RELATED"},
+    {ICAL_RELTYPE_PARAMETER,"RELTYPE"},
+    {ICAL_ROLE_PARAMETER,"ROLE"},
+    {ICAL_RSVP_PARAMETER,"RSVP"},
+    {ICAL_SENTBY_PARAMETER,"SENT-BY"},
+    {ICAL_TZID_PARAMETER,"TZID"},
+    {ICAL_VALUE_PARAMETER,"VALUE"},
+    {ICAL_X_PARAMETER,"X"},
+    {ICAL_XLICCOMPARETYPE_PARAMETER,"X-LIC-COMPARETYPE"},
+    {ICAL_XLICERRORTYPE_PARAMETER,"X-LIC-ERRORTYPE"},
+    { ICAL_NO_PARAMETER, ""}
+};
+
+static struct icalparameter_map icalparameter_map[] = {
+{ICAL_ANY_PARAMETER,0,""},
+    {ICAL_CUTYPE_PARAMETER,ICAL_CUTYPE_INDIVIDUAL,"INDIVIDUAL"},
+    {ICAL_CUTYPE_PARAMETER,ICAL_CUTYPE_GROUP,"GROUP"},
+    {ICAL_CUTYPE_PARAMETER,ICAL_CUTYPE_RESOURCE,"RESOURCE"},
+    {ICAL_CUTYPE_PARAMETER,ICAL_CUTYPE_ROOM,"ROOM"},
+    {ICAL_CUTYPE_PARAMETER,ICAL_CUTYPE_UNKNOWN,"UNKNOWN"},
+    {ICAL_ENCODING_PARAMETER,ICAL_ENCODING_8BIT,"8BIT"},
+    {ICAL_ENCODING_PARAMETER,ICAL_ENCODING_BASE64,"BASE64"},
+    {ICAL_FBTYPE_PARAMETER,ICAL_FBTYPE_FREE,"FREE"},
+    {ICAL_FBTYPE_PARAMETER,ICAL_FBTYPE_BUSY,"BUSY"},
+    {ICAL_FBTYPE_PARAMETER,ICAL_FBTYPE_BUSYUNAVAILABLE,"BUSYUNAVAILABLE"},
+    {ICAL_FBTYPE_PARAMETER,ICAL_FBTYPE_BUSYTENTATIVE,"BUSYTENTATIVE"},
+    {ICAL_PARTSTAT_PARAMETER,ICAL_PARTSTAT_NEEDSACTION,"NEEDS-ACTION"},
+    {ICAL_PARTSTAT_PARAMETER,ICAL_PARTSTAT_ACCEPTED,"ACCEPTED"},
+    {ICAL_PARTSTAT_PARAMETER,ICAL_PARTSTAT_DECLINED,"DECLINED"},
+    {ICAL_PARTSTAT_PARAMETER,ICAL_PARTSTAT_TENTATIVE,"TENTATIVE"},
+    {ICAL_PARTSTAT_PARAMETER,ICAL_PARTSTAT_DELEGATED,"DELEGATED"},
+    {ICAL_PARTSTAT_PARAMETER,ICAL_PARTSTAT_COMPLETED,"COMPLETED"},
+    {ICAL_PARTSTAT_PARAMETER,ICAL_PARTSTAT_INPROCESS,"INPROCESS"},
+    {ICAL_RANGE_PARAMETER,ICAL_RANGE_THISANDPRIOR,"THISANDPRIOR"},
+    {ICAL_RANGE_PARAMETER,ICAL_RANGE_THISANDFUTURE,"THISANDFUTURE"},
+    {ICAL_RELATED_PARAMETER,ICAL_RELATED_START,"START"},
+    {ICAL_RELATED_PARAMETER,ICAL_RELATED_END ,"END "},
+    {ICAL_RELTYPE_PARAMETER,ICAL_RELTYPE_PARENT,"PARENT"},
+    {ICAL_RELTYPE_PARAMETER,ICAL_RELTYPE_CHILD,"CHILD"},
+    {ICAL_RELTYPE_PARAMETER,ICAL_RELTYPE_SIBLING,"SIBLING"},
+    {ICAL_ROLE_PARAMETER,ICAL_ROLE_CHAIR,"CHAIR"},
+    {ICAL_ROLE_PARAMETER,ICAL_ROLE_REQPARTICIPANT,"REQ-PARTICIPANT"},
+    {ICAL_ROLE_PARAMETER,ICAL_ROLE_OPTPARTICIPANT,"OPT-PARTICIPANT"},
+    {ICAL_ROLE_PARAMETER,ICAL_ROLE_NONPARTICIPANT,"NON-PARTICIPANT"},
+    {ICAL_RSVP_PARAMETER,ICAL_RSVP_TRUE,"TRUE"},
+    {ICAL_RSVP_PARAMETER,ICAL_RSVP_FALSE,"FALSE"},
+    {ICAL_VALUE_PARAMETER,ICAL_VALUE_BINARY,"BINARY"},
+    {ICAL_VALUE_PARAMETER,ICAL_VALUE_BOOLEAN,"BOOLEAN"},
+    {ICAL_VALUE_PARAMETER,ICAL_VALUE_DATE,"DATE"},
+    {ICAL_VALUE_PARAMETER,ICAL_VALUE_DURATION,"DURATION"},
+    {ICAL_VALUE_PARAMETER,ICAL_VALUE_FLOAT,"FLOAT"},
+    {ICAL_VALUE_PARAMETER,ICAL_VALUE_INTEGER,"INTEGER"},
+    {ICAL_VALUE_PARAMETER,ICAL_VALUE_PERIOD,"PERIOD"},
+    {ICAL_VALUE_PARAMETER,ICAL_VALUE_RECUR,"RECUR"},
+    {ICAL_VALUE_PARAMETER,ICAL_VALUE_TEXT,"TEXT"},
+    {ICAL_VALUE_PARAMETER,ICAL_VALUE_URI,"URI"},
+    {ICAL_VALUE_PARAMETER,ICAL_VALUE_ERROR,"ERROR"},
+    {ICAL_VALUE_PARAMETER,ICAL_VALUE_DATETIME,"DATE-TIME"},
+    {ICAL_VALUE_PARAMETER,ICAL_VALUE_UTCOFFSET,"UTC-OFFSET"},
+    {ICAL_VALUE_PARAMETER,ICAL_VALUE_CALADDRESS,"CAL-ADDRESS"},
+    {ICAL_XLICCOMPARETYPE_PARAMETER,ICAL_XLICCOMPARETYPE_EQUAL,"EQUAL"},
+    {ICAL_XLICCOMPARETYPE_PARAMETER,ICAL_XLICCOMPARETYPE_NOTEQUAL,"NOTEQUAL"},
+    {ICAL_XLICCOMPARETYPE_PARAMETER,ICAL_XLICCOMPARETYPE_LESS,"LESS"},
+    {ICAL_XLICCOMPARETYPE_PARAMETER,ICAL_XLICCOMPARETYPE_GREATER,"GREATER"},
+    {ICAL_XLICCOMPARETYPE_PARAMETER,ICAL_XLICCOMPARETYPE_LESSEQUAL,"LESSEQUAL"},
+    {ICAL_XLICCOMPARETYPE_PARAMETER,ICAL_XLICCOMPARETYPE_GREATEREQUAL,"GREATEREQUAL"},
+    {ICAL_XLICCOMPARETYPE_PARAMETER,ICAL_XLICCOMPARETYPE_REGEX,"REGEX"},
+    {ICAL_XLICERRORTYPE_PARAMETER,ICAL_XLICERRORTYPE_COMPONENTPARSEERROR,"COMPONENT-PARSE-ERROR"},
+    {ICAL_XLICERRORTYPE_PARAMETER,ICAL_XLICERRORTYPE_PROPERTYPARSEERROR,"PROPERTY-PARSE-ERROR"},
+    {ICAL_XLICERRORTYPE_PARAMETER,ICAL_XLICERRORTYPE_PARAMETERNAMEPARSEERROR,"PARAMETER-NAME-PARSE-ERROR"},
+    {ICAL_XLICERRORTYPE_PARAMETER,ICAL_XLICERRORTYPE_PARAMETERVALUEPARSEERROR,"PARAMETER-VALUE-PARSE-ERROR"},
+    {ICAL_XLICERRORTYPE_PARAMETER,ICAL_XLICERRORTYPE_VALUEPARSEERROR,"VALUE-PARSE-ERROR"},
+    {ICAL_XLICERRORTYPE_PARAMETER,ICAL_XLICERRORTYPE_INVALIDITIP,"INVALID-ITIP"},
+    {ICAL_XLICERRORTYPE_PARAMETER,ICAL_XLICERRORTYPE_UNKNOWNVCALPROPERROR,"UNKNOWN-VCAL-PROP-ERROR"},
+    {ICAL_XLICERRORTYPE_PARAMETER,ICAL_XLICERRORTYPE_MIMEPARSEERROR,"MIME-PARSE-ERROR"},
+    {ICAL_NO_PARAMETER,0,""}};
+
+/* DELEGATED-FROM */
+icalparameter* icalparameter_new_delegatedfrom(const char* v)
+{
+   struct icalparameter_impl *impl;
+   icalerror_clear_errno();
+   icalerror_check_arg_rz( (v!=0),"v");
+   impl = icalparameter_new_impl(ICAL_DELEGATEDFROM_PARAMETER);
+   if (impl == 0) {
+      return 0;
+   }
+
+   icalparameter_set_delegatedfrom((icalparameter*) impl,v);
+   if (icalerrno != ICAL_NO_ERROR) {
+      icalparameter_free((icalparameter*) impl);
+      return 0;
+   }
+
+   return (icalparameter*) impl;
+}
+
+const char* icalparameter_get_delegatedfrom(icalparameter* param)
+{
+   icalerror_clear_errno();
+    icalerror_check_arg_rz( (param!=0), "param");
+    return (const char*)((struct icalparameter_impl*)param)->string;
+}
+
+void icalparameter_set_delegatedfrom(icalparameter* param, const char* v)
+{
+   icalerror_check_arg_rv( (v!=0),"v");
+   icalerror_check_arg_rv( (param!=0), "param");
+   icalerror_clear_errno();
+   
+   ((struct icalparameter_impl*)param)->string = icalmemory_strdup(v);
+}
+
+/* DELEGATED-TO */
+icalparameter* icalparameter_new_delegatedto(const char* v)
+{
+   struct icalparameter_impl *impl;
+   icalerror_clear_errno();
+   icalerror_check_arg_rz( (v!=0),"v");
+   impl = icalparameter_new_impl(ICAL_DELEGATEDTO_PARAMETER);
+   if (impl == 0) {
+      return 0;
+   }
+
+   icalparameter_set_delegatedto((icalparameter*) impl,v);
+   if (icalerrno != ICAL_NO_ERROR) {
+      icalparameter_free((icalparameter*) impl);
+      return 0;
+   }
+
+   return (icalparameter*) impl;
+}
+
+const char* icalparameter_get_delegatedto(icalparameter* param)
+{
+   icalerror_clear_errno();
+    icalerror_check_arg_rz( (param!=0), "param");
+    return (const char*)((struct icalparameter_impl*)param)->string;
+}
+
+void icalparameter_set_delegatedto(icalparameter* param, const char* v)
+{
+   icalerror_check_arg_rv( (v!=0),"v");
+   icalerror_check_arg_rv( (param!=0), "param");
+   icalerror_clear_errno();
+   
+   ((struct icalparameter_impl*)param)->string = icalmemory_strdup(v);
+}
+
+/* RANGE */
+icalparameter* icalparameter_new_range(icalparameter_range v)
+{
+   struct icalparameter_impl *impl;
+   icalerror_clear_errno();
+   icalerror_check_arg_rz(v >= ICAL_RANGE_X,"v");
+    icalerror_check_arg_rz(v < ICAL_RANGE_NONE,"v");
+   impl = icalparameter_new_impl(ICAL_RANGE_PARAMETER);
+   if (impl == 0) {
+      return 0;
+   }
+
+   icalparameter_set_range((icalparameter*) impl,v);
+   if (icalerrno != ICAL_NO_ERROR) {
+      icalparameter_free((icalparameter*) impl);
+      return 0;
+   }
+
+   return (icalparameter*) impl;
+}
+
+icalparameter_range icalparameter_get_range(icalparameter* param)
+{
+   icalerror_clear_errno();
+icalerror_check_arg( (param!=0), "param");
+
+return (icalparameter_range)((struct icalparameter_impl*)param)->data;
+}
+
+void icalparameter_set_range(icalparameter* param, icalparameter_range v)
+{
+   icalerror_check_arg_rv(v >= ICAL_RANGE_X,"v");
+    icalerror_check_arg_rv(v < ICAL_RANGE_NONE,"v");
+   icalerror_check_arg_rv( (param!=0), "param");
+   icalerror_clear_errno();
+   
+   ((struct icalparameter_impl*)param)->data = (int)v;
+}
+
+/* ENCODING */
+icalparameter* icalparameter_new_encoding(icalparameter_encoding v)
+{
+   struct icalparameter_impl *impl;
+   icalerror_clear_errno();
+   icalerror_check_arg_rz(v >= ICAL_ENCODING_X,"v");
+    icalerror_check_arg_rz(v < ICAL_ENCODING_NONE,"v");
+   impl = icalparameter_new_impl(ICAL_ENCODING_PARAMETER);
+   if (impl == 0) {
+      return 0;
+   }
+
+   icalparameter_set_encoding((icalparameter*) impl,v);
+   if (icalerrno != ICAL_NO_ERROR) {
+      icalparameter_free((icalparameter*) impl);
+      return 0;
+   }
+
+   return (icalparameter*) impl;
+}
+
+icalparameter_encoding icalparameter_get_encoding(icalparameter* param)
+{
+   icalerror_clear_errno();
+icalerror_check_arg( (param!=0), "param");
+     if ( ((struct icalparameter_impl*)param)->string != 0){
+        return ICAL_ENCODING_X;
+        }
+
+return (icalparameter_encoding)((struct icalparameter_impl*)param)->data;
+}
+
+void icalparameter_set_encoding(icalparameter* param, icalparameter_encoding v)
+{
+   icalerror_check_arg_rv(v >= ICAL_ENCODING_X,"v");
+    icalerror_check_arg_rv(v < ICAL_ENCODING_NONE,"v");
+   icalerror_check_arg_rv( (param!=0), "param");
+   icalerror_clear_errno();
+   
+   ((struct icalparameter_impl*)param)->data = (int)v;
+}
+
+/* RSVP */
+icalparameter* icalparameter_new_rsvp(icalparameter_rsvp v)
+{
+   struct icalparameter_impl *impl;
+   icalerror_clear_errno();
+   icalerror_check_arg_rz(v >= ICAL_RSVP_X,"v");
+    icalerror_check_arg_rz(v < ICAL_RSVP_NONE,"v");
+   impl = icalparameter_new_impl(ICAL_RSVP_PARAMETER);
+   if (impl == 0) {
+      return 0;
+   }
+
+   icalparameter_set_rsvp((icalparameter*) impl,v);
+   if (icalerrno != ICAL_NO_ERROR) {
+      icalparameter_free((icalparameter*) impl);
+      return 0;
+   }
+
+   return (icalparameter*) impl;
+}
+
+icalparameter_rsvp icalparameter_get_rsvp(icalparameter* param)
+{
+   icalerror_clear_errno();
+icalerror_check_arg( (param!=0), "param");
+
+return (icalparameter_rsvp)((struct icalparameter_impl*)param)->data;
+}
+
+void icalparameter_set_rsvp(icalparameter* param, icalparameter_rsvp v)
+{
+   icalerror_check_arg_rv(v >= ICAL_RSVP_X,"v");
+    icalerror_check_arg_rv(v < ICAL_RSVP_NONE,"v");
+   icalerror_check_arg_rv( (param!=0), "param");
+   icalerror_clear_errno();
+   
+   ((struct icalparameter_impl*)param)->data = (int)v;
+}
+
+/* PARTSTAT */
+icalparameter* icalparameter_new_partstat(icalparameter_partstat v)
+{
+   struct icalparameter_impl *impl;
+   icalerror_clear_errno();
+   icalerror_check_arg_rz(v >= ICAL_PARTSTAT_X,"v");
+    icalerror_check_arg_rz(v < ICAL_PARTSTAT_NONE,"v");
+   impl = icalparameter_new_impl(ICAL_PARTSTAT_PARAMETER);
+   if (impl == 0) {
+      return 0;
+   }
+
+   icalparameter_set_partstat((icalparameter*) impl,v);
+   if (icalerrno != ICAL_NO_ERROR) {
+      icalparameter_free((icalparameter*) impl);
+      return 0;
+   }
+
+   return (icalparameter*) impl;
+}
+
+icalparameter_partstat icalparameter_get_partstat(icalparameter* param)
+{
+   icalerror_clear_errno();
+icalerror_check_arg( (param!=0), "param");
+     if ( ((struct icalparameter_impl*)param)->string != 0){
+        return ICAL_PARTSTAT_X;
+        }
+
+return (icalparameter_partstat)((struct icalparameter_impl*)param)->data;
+}
+
+void icalparameter_set_partstat(icalparameter* param, icalparameter_partstat v)
+{
+   icalerror_check_arg_rv(v >= ICAL_PARTSTAT_X,"v");
+    icalerror_check_arg_rv(v < ICAL_PARTSTAT_NONE,"v");
+   icalerror_check_arg_rv( (param!=0), "param");
+   icalerror_clear_errno();
+   
+   ((struct icalparameter_impl*)param)->data = (int)v;
+}
+
+/* RELTYPE */
+icalparameter* icalparameter_new_reltype(icalparameter_reltype v)
+{
+   struct icalparameter_impl *impl;
+   icalerror_clear_errno();
+   icalerror_check_arg_rz(v >= ICAL_RELTYPE_X,"v");
+    icalerror_check_arg_rz(v < ICAL_RELTYPE_NONE,"v");
+   impl = icalparameter_new_impl(ICAL_RELTYPE_PARAMETER);
+   if (impl == 0) {
+      return 0;
+   }
+
+   icalparameter_set_reltype((icalparameter*) impl,v);
+   if (icalerrno != ICAL_NO_ERROR) {
+      icalparameter_free((icalparameter*) impl);
+      return 0;
+   }
+
+   return (icalparameter*) impl;
+}
+
+icalparameter_reltype icalparameter_get_reltype(icalparameter* param)
+{
+   icalerror_clear_errno();
+icalerror_check_arg( (param!=0), "param");
+     if ( ((struct icalparameter_impl*)param)->string != 0){
+        return ICAL_RELTYPE_X;
+        }
+
+return (icalparameter_reltype)((struct icalparameter_impl*)param)->data;
+}
+
+void icalparameter_set_reltype(icalparameter* param, icalparameter_reltype v)
+{
+   icalerror_check_arg_rv(v >= ICAL_RELTYPE_X,"v");
+    icalerror_check_arg_rv(v < ICAL_RELTYPE_NONE,"v");
+   icalerror_check_arg_rv( (param!=0), "param");
+   icalerror_clear_errno();
+   
+   ((struct icalparameter_impl*)param)->data = (int)v;
+}
+
+/* CUTYPE */
+icalparameter* icalparameter_new_cutype(icalparameter_cutype v)
+{
+   struct icalparameter_impl *impl;
+   icalerror_clear_errno();
+   icalerror_check_arg_rz(v >= ICAL_CUTYPE_X,"v");
+    icalerror_check_arg_rz(v < ICAL_CUTYPE_NONE,"v");
+   impl = icalparameter_new_impl(ICAL_CUTYPE_PARAMETER);
+   if (impl == 0) {
+      return 0;
+   }
+
+   icalparameter_set_cutype((icalparameter*) impl,v);
+   if (icalerrno != ICAL_NO_ERROR) {
+      icalparameter_free((icalparameter*) impl);
+      return 0;
+   }
+
+   return (icalparameter*) impl;
+}
+
+icalparameter_cutype icalparameter_get_cutype(icalparameter* param)
+{
+   icalerror_clear_errno();
+icalerror_check_arg( (param!=0), "param");
+     if ( ((struct icalparameter_impl*)param)->string != 0){
+        return ICAL_CUTYPE_X;
+        }
+
+return (icalparameter_cutype)((struct icalparameter_impl*)param)->data;
+}
+
+void icalparameter_set_cutype(icalparameter* param, icalparameter_cutype v)
+{
+   icalerror_check_arg_rv(v >= ICAL_CUTYPE_X,"v");
+    icalerror_check_arg_rv(v < ICAL_CUTYPE_NONE,"v");
+   icalerror_check_arg_rv( (param!=0), "param");
+   icalerror_clear_errno();
+   
+   ((struct icalparameter_impl*)param)->data = (int)v;
+}
+
+/* MEMBER */
+icalparameter* icalparameter_new_member(const char* v)
+{
+   struct icalparameter_impl *impl;
+   icalerror_clear_errno();
+   icalerror_check_arg_rz( (v!=0),"v");
+   impl = icalparameter_new_impl(ICAL_MEMBER_PARAMETER);
+   if (impl == 0) {
+      return 0;
+   }
+
+   icalparameter_set_member((icalparameter*) impl,v);
+   if (icalerrno != ICAL_NO_ERROR) {
+      icalparameter_free((icalparameter*) impl);
+      return 0;
+   }
+
+   return (icalparameter*) impl;
+}
+
+const char* icalparameter_get_member(icalparameter* param)
+{
+   icalerror_clear_errno();
+    icalerror_check_arg_rz( (param!=0), "param");
+    return (const char*)((struct icalparameter_impl*)param)->string;
+}
+
+void icalparameter_set_member(icalparameter* param, const char* v)
+{
+   icalerror_check_arg_rv( (v!=0),"v");
+   icalerror_check_arg_rv( (param!=0), "param");
+   icalerror_clear_errno();
+   
+   ((struct icalparameter_impl*)param)->string = icalmemory_strdup(v);
+}
+
+/* FMTTYPE */
+icalparameter* icalparameter_new_fmttype(const char* v)
+{
+   struct icalparameter_impl *impl;
+   icalerror_clear_errno();
+   icalerror_check_arg_rz( (v!=0),"v");
+   impl = icalparameter_new_impl(ICAL_FMTTYPE_PARAMETER);
+   if (impl == 0) {
+      return 0;
+   }
+
+   icalparameter_set_fmttype((icalparameter*) impl,v);
+   if (icalerrno != ICAL_NO_ERROR) {
+      icalparameter_free((icalparameter*) impl);
+      return 0;
+   }
+
+   return (icalparameter*) impl;
+}
+
+const char* icalparameter_get_fmttype(icalparameter* param)
+{
+   icalerror_clear_errno();
+    icalerror_check_arg_rz( (param!=0), "param");
+    return (const char*)((struct icalparameter_impl*)param)->string;
+}
+
+void icalparameter_set_fmttype(icalparameter* param, const char* v)
+{
+   icalerror_check_arg_rv( (v!=0),"v");
+   icalerror_check_arg_rv( (param!=0), "param");
+   icalerror_clear_errno();
+   
+   ((struct icalparameter_impl*)param)->string = icalmemory_strdup(v);
+}
+
+/* SENT-BY */
+icalparameter* icalparameter_new_sentby(const char* v)
+{
+   struct icalparameter_impl *impl;
+   icalerror_clear_errno();
+   icalerror_check_arg_rz( (v!=0),"v");
+   impl = icalparameter_new_impl(ICAL_SENTBY_PARAMETER);
+   if (impl == 0) {
+      return 0;
+   }
+
+   icalparameter_set_sentby((icalparameter*) impl,v);
+   if (icalerrno != ICAL_NO_ERROR) {
+      icalparameter_free((icalparameter*) impl);
+      return 0;
+   }
+
+   return (icalparameter*) impl;
+}
+
+const char* icalparameter_get_sentby(icalparameter* param)
+{
+   icalerror_clear_errno();
+    icalerror_check_arg_rz( (param!=0), "param");
+    return (const char*)((struct icalparameter_impl*)param)->string;
+}
+
+void icalparameter_set_sentby(icalparameter* param, const char* v)
+{
+   icalerror_check_arg_rv( (v!=0),"v");
+   icalerror_check_arg_rv( (param!=0), "param");
+   icalerror_clear_errno();
+   
+   ((struct icalparameter_impl*)param)->string = icalmemory_strdup(v);
+}
+
+/* VALUE */
+icalparameter* icalparameter_new_value(icalparameter_value v)
+{
+   struct icalparameter_impl *impl;
+   icalerror_clear_errno();
+   icalerror_check_arg_rz(v >= ICAL_VALUE_X,"v");
+    icalerror_check_arg_rz(v < ICAL_VALUE_NONE,"v");
+   impl = icalparameter_new_impl(ICAL_VALUE_PARAMETER);
+   if (impl == 0) {
+      return 0;
+   }
+
+   icalparameter_set_value((icalparameter*) impl,v);
+   if (icalerrno != ICAL_NO_ERROR) {
+      icalparameter_free((icalparameter*) impl);
+      return 0;
+   }
+
+   return (icalparameter*) impl;
+}
+
+icalparameter_value icalparameter_get_value(icalparameter* param)
+{
+   icalerror_clear_errno();
+icalerror_check_arg( (param!=0), "param");
+     if ( ((struct icalparameter_impl*)param)->string != 0){
+        return ICAL_VALUE_X;
+        }
+
+return (icalparameter_value)((struct icalparameter_impl*)param)->data;
+}
+
+void icalparameter_set_value(icalparameter* param, icalparameter_value v)
+{
+   icalerror_check_arg_rv(v >= ICAL_VALUE_X,"v");
+    icalerror_check_arg_rv(v < ICAL_VALUE_NONE,"v");
+   icalerror_check_arg_rv( (param!=0), "param");
+   icalerror_clear_errno();
+   
+   ((struct icalparameter_impl*)param)->data = (int)v;
+}
+
+/* ALTREP */
+icalparameter* icalparameter_new_altrep(const char* v)
+{
+   struct icalparameter_impl *impl;
+   icalerror_clear_errno();
+   icalerror_check_arg_rz( (v!=0),"v");
+   impl = icalparameter_new_impl(ICAL_ALTREP_PARAMETER);
+   if (impl == 0) {
+      return 0;
+   }
+
+   icalparameter_set_altrep((icalparameter*) impl,v);
+   if (icalerrno != ICAL_NO_ERROR) {
+      icalparameter_free((icalparameter*) impl);
+      return 0;
+   }
+
+   return (icalparameter*) impl;
+}
+
+const char* icalparameter_get_altrep(icalparameter* param)
+{
+   icalerror_clear_errno();
+    icalerror_check_arg_rz( (param!=0), "param");
+    return (const char*)((struct icalparameter_impl*)param)->string;
+}
+
+void icalparameter_set_altrep(icalparameter* param, const char* v)
+{
+   icalerror_check_arg_rv( (v!=0),"v");
+   icalerror_check_arg_rv( (param!=0), "param");
+   icalerror_clear_errno();
+   
+   ((struct icalparameter_impl*)param)->string = icalmemory_strdup(v);
+}
+
+/* DIR */
+icalparameter* icalparameter_new_dir(const char* v)
+{
+   struct icalparameter_impl *impl;
+   icalerror_clear_errno();
+   icalerror_check_arg_rz( (v!=0),"v");
+   impl = icalparameter_new_impl(ICAL_DIR_PARAMETER);
+   if (impl == 0) {
+      return 0;
+   }
+
+   icalparameter_set_dir((icalparameter*) impl,v);
+   if (icalerrno != ICAL_NO_ERROR) {
+      icalparameter_free((icalparameter*) impl);
+      return 0;
+   }
+
+   return (icalparameter*) impl;
+}
+
+const char* icalparameter_get_dir(icalparameter* param)
+{
+   icalerror_clear_errno();
+    icalerror_check_arg_rz( (param!=0), "param");
+    return (const char*)((struct icalparameter_impl*)param)->string;
+}
+
+void icalparameter_set_dir(icalparameter* param, const char* v)
+{
+   icalerror_check_arg_rv( (v!=0),"v");
+   icalerror_check_arg_rv( (param!=0), "param");
+   icalerror_clear_errno();
+   
+   ((struct icalparameter_impl*)param)->string = icalmemory_strdup(v);
+}
+
+/* RELATED */
+icalparameter* icalparameter_new_related(icalparameter_related v)
+{
+   struct icalparameter_impl *impl;
+   icalerror_clear_errno();
+   icalerror_check_arg_rz(v >= ICAL_RELATED_X,"v");
+    icalerror_check_arg_rz(v < ICAL_RELATED_NONE,"v");
+   impl = icalparameter_new_impl(ICAL_RELATED_PARAMETER);
+   if (impl == 0) {
+      return 0;
+   }
+
+   icalparameter_set_related((icalparameter*) impl,v);
+   if (icalerrno != ICAL_NO_ERROR) {
+      icalparameter_free((icalparameter*) impl);
+      return 0;
+   }
+
+   return (icalparameter*) impl;
+}
+
+icalparameter_related icalparameter_get_related(icalparameter* param)
+{
+   icalerror_clear_errno();
+icalerror_check_arg( (param!=0), "param");
+
+return (icalparameter_related)((struct icalparameter_impl*)param)->data;
+}
+
+void icalparameter_set_related(icalparameter* param, icalparameter_related v)
+{
+   icalerror_check_arg_rv(v >= ICAL_RELATED_X,"v");
+    icalerror_check_arg_rv(v < ICAL_RELATED_NONE,"v");
+   icalerror_check_arg_rv( (param!=0), "param");
+   icalerror_clear_errno();
+   
+   ((struct icalparameter_impl*)param)->data = (int)v;
+}
+
+/* CN */
+icalparameter* icalparameter_new_cn(const char* v)
+{
+   struct icalparameter_impl *impl;
+   icalerror_clear_errno();
+   icalerror_check_arg_rz( (v!=0),"v");
+   impl = icalparameter_new_impl(ICAL_CN_PARAMETER);
+   if (impl == 0) {
+      return 0;
+   }
+
+   icalparameter_set_cn((icalparameter*) impl,v);
+   if (icalerrno != ICAL_NO_ERROR) {
+      icalparameter_free((icalparameter*) impl);
+      return 0;
+   }
+
+   return (icalparameter*) impl;
+}
+
+const char* icalparameter_get_cn(icalparameter* param)
+{
+   icalerror_clear_errno();
+    icalerror_check_arg_rz( (param!=0), "param");
+    return (const char*)((struct icalparameter_impl*)param)->string;
+}
+
+void icalparameter_set_cn(icalparameter* param, const char* v)
+{
+   icalerror_check_arg_rv( (v!=0),"v");
+   icalerror_check_arg_rv( (param!=0), "param");
+   icalerror_clear_errno();
+   
+   ((struct icalparameter_impl*)param)->string = icalmemory_strdup(v);
+}
+
+/* X-LIC-ERRORTYPE */
+icalparameter* icalparameter_new_xlicerrortype(icalparameter_xlicerrortype v)
+{
+   struct icalparameter_impl *impl;
+   icalerror_clear_errno();
+   icalerror_check_arg_rz(v >= ICAL_XLICERRORTYPE_X,"v");
+    icalerror_check_arg_rz(v < ICAL_XLICERRORTYPE_NONE,"v");
+   impl = icalparameter_new_impl(ICAL_XLICERRORTYPE_PARAMETER);
+   if (impl == 0) {
+      return 0;
+   }
+
+   icalparameter_set_xlicerrortype((icalparameter*) impl,v);
+   if (icalerrno != ICAL_NO_ERROR) {
+      icalparameter_free((icalparameter*) impl);
+      return 0;
+   }
+
+   return (icalparameter*) impl;
+}
+
+icalparameter_xlicerrortype icalparameter_get_xlicerrortype(icalparameter* param)
+{
+   icalerror_clear_errno();
+icalerror_check_arg( (param!=0), "param");
+
+return (icalparameter_xlicerrortype)((struct icalparameter_impl*)param)->data;
+}
+
+void icalparameter_set_xlicerrortype(icalparameter* param, icalparameter_xlicerrortype v)
+{
+   icalerror_check_arg_rv(v >= ICAL_XLICERRORTYPE_X,"v");
+    icalerror_check_arg_rv(v < ICAL_XLICERRORTYPE_NONE,"v");
+   icalerror_check_arg_rv( (param!=0), "param");
+   icalerror_clear_errno();
+   
+   ((struct icalparameter_impl*)param)->data = (int)v;
+}
+
+/* X */
+icalparameter* icalparameter_new_x(const char* v)
+{
+   struct icalparameter_impl *impl;
+   icalerror_clear_errno();
+   icalerror_check_arg_rz( (v!=0),"v");
+   impl = icalparameter_new_impl(ICAL_X_PARAMETER);
+   if (impl == 0) {
+      return 0;
+   }
+
+   icalparameter_set_x((icalparameter*) impl,v);
+   if (icalerrno != ICAL_NO_ERROR) {
+      icalparameter_free((icalparameter*) impl);
+      return 0;
+   }
+
+   return (icalparameter*) impl;
+}
+
+const char* icalparameter_get_x(icalparameter* param)
+{
+   icalerror_clear_errno();
+    icalerror_check_arg_rz( (param!=0), "param");
+    return (const char*)((struct icalparameter_impl*)param)->string;
+}
+
+void icalparameter_set_x(icalparameter* param, const char* v)
+{
+   icalerror_check_arg_rv( (v!=0),"v");
+   icalerror_check_arg_rv( (param!=0), "param");
+   icalerror_clear_errno();
+   
+   ((struct icalparameter_impl*)param)->string = icalmemory_strdup(v);
+}
+
+/* LANGUAGE */
+icalparameter* icalparameter_new_language(const char* v)
+{
+   struct icalparameter_impl *impl;
+   icalerror_clear_errno();
+   icalerror_check_arg_rz( (v!=0),"v");
+   impl = icalparameter_new_impl(ICAL_LANGUAGE_PARAMETER);
+   if (impl == 0) {
+      return 0;
+   }
+
+   icalparameter_set_language((icalparameter*) impl,v);
+   if (icalerrno != ICAL_NO_ERROR) {
+      icalparameter_free((icalparameter*) impl);
+      return 0;
+   }
+
+   return (icalparameter*) impl;
+}
+
+const char* icalparameter_get_language(icalparameter* param)
+{
+   icalerror_clear_errno();
+    icalerror_check_arg_rz( (param!=0), "param");
+    return (const char*)((struct icalparameter_impl*)param)->string;
+}
+
+void icalparameter_set_language(icalparameter* param, const char* v)
+{
+   icalerror_check_arg_rv( (v!=0),"v");
+   icalerror_check_arg_rv( (param!=0), "param");
+   icalerror_clear_errno();
+   
+   ((struct icalparameter_impl*)param)->string = icalmemory_strdup(v);
+}
+
+/* ROLE */
+icalparameter* icalparameter_new_role(icalparameter_role v)
+{
+   struct icalparameter_impl *impl;
+   icalerror_clear_errno();
+   icalerror_check_arg_rz(v >= ICAL_ROLE_X,"v");
+    icalerror_check_arg_rz(v < ICAL_ROLE_NONE,"v");
+   impl = icalparameter_new_impl(ICAL_ROLE_PARAMETER);
+   if (impl == 0) {
+      return 0;
+   }
+
+   icalparameter_set_role((icalparameter*) impl,v);
+   if (icalerrno != ICAL_NO_ERROR) {
+      icalparameter_free((icalparameter*) impl);
+      return 0;
+   }
+
+   return (icalparameter*) impl;
+}
+
+icalparameter_role icalparameter_get_role(icalparameter* param)
+{
+   icalerror_clear_errno();
+icalerror_check_arg( (param!=0), "param");
+     if ( ((struct icalparameter_impl*)param)->string != 0){
+        return ICAL_ROLE_X;
+        }
+
+return (icalparameter_role)((struct icalparameter_impl*)param)->data;
+}
+
+void icalparameter_set_role(icalparameter* param, icalparameter_role v)
+{
+   icalerror_check_arg_rv(v >= ICAL_ROLE_X,"v");
+    icalerror_check_arg_rv(v < ICAL_ROLE_NONE,"v");
+   icalerror_check_arg_rv( (param!=0), "param");
+   icalerror_clear_errno();
+   
+   ((struct icalparameter_impl*)param)->data = (int)v;
+}
+
+/* X-LIC-COMPARETYPE */
+icalparameter* icalparameter_new_xliccomparetype(icalparameter_xliccomparetype v)
+{
+   struct icalparameter_impl *impl;
+   icalerror_clear_errno();
+   icalerror_check_arg_rz(v >= ICAL_XLICCOMPARETYPE_X,"v");
+    icalerror_check_arg_rz(v < ICAL_XLICCOMPARETYPE_NONE,"v");
+   impl = icalparameter_new_impl(ICAL_XLICCOMPARETYPE_PARAMETER);
+   if (impl == 0) {
+      return 0;
+   }
+
+   icalparameter_set_xliccomparetype((icalparameter*) impl,v);
+   if (icalerrno != ICAL_NO_ERROR) {
+      icalparameter_free((icalparameter*) impl);
+      return 0;
+   }
+
+   return (icalparameter*) impl;
+}
+
+icalparameter_xliccomparetype icalparameter_get_xliccomparetype(icalparameter* param)
+{
+   icalerror_clear_errno();
+icalerror_check_arg( (param!=0), "param");
+
+return (icalparameter_xliccomparetype)((struct icalparameter_impl*)param)->data;
+}
+
+void icalparameter_set_xliccomparetype(icalparameter* param, icalparameter_xliccomparetype v)
+{
+   icalerror_check_arg_rv(v >= ICAL_XLICCOMPARETYPE_X,"v");
+    icalerror_check_arg_rv(v < ICAL_XLICCOMPARETYPE_NONE,"v");
+   icalerror_check_arg_rv( (param!=0), "param");
+   icalerror_clear_errno();
+   
+   ((struct icalparameter_impl*)param)->data = (int)v;
+}
+
+/* FBTYPE */
+icalparameter* icalparameter_new_fbtype(icalparameter_fbtype v)
+{
+   struct icalparameter_impl *impl;
+   icalerror_clear_errno();
+   icalerror_check_arg_rz(v >= ICAL_FBTYPE_X,"v");
+    icalerror_check_arg_rz(v < ICAL_FBTYPE_NONE,"v");
+   impl = icalparameter_new_impl(ICAL_FBTYPE_PARAMETER);
+   if (impl == 0) {
+      return 0;
+   }
+
+   icalparameter_set_fbtype((icalparameter*) impl,v);
+   if (icalerrno != ICAL_NO_ERROR) {
+      icalparameter_free((icalparameter*) impl);
+      return 0;
+   }
+
+   return (icalparameter*) impl;
+}
+
+icalparameter_fbtype icalparameter_get_fbtype(icalparameter* param)
+{
+   icalerror_clear_errno();
+icalerror_check_arg( (param!=0), "param");
+     if ( ((struct icalparameter_impl*)param)->string != 0){
+        return ICAL_FBTYPE_X;
+        }
+
+return (icalparameter_fbtype)((struct icalparameter_impl*)param)->data;
+}
+
+void icalparameter_set_fbtype(icalparameter* param, icalparameter_fbtype v)
+{
+   icalerror_check_arg_rv(v >= ICAL_FBTYPE_X,"v");
+    icalerror_check_arg_rv(v < ICAL_FBTYPE_NONE,"v");
+   icalerror_check_arg_rv( (param!=0), "param");
+   icalerror_clear_errno();
+   
+   ((struct icalparameter_impl*)param)->data = (int)v;
+}
+
+/* TZID */
+icalparameter* icalparameter_new_tzid(const char* v)
+{
+   struct icalparameter_impl *impl;
+   icalerror_clear_errno();
+   icalerror_check_arg_rz( (v!=0),"v");
+   impl = icalparameter_new_impl(ICAL_TZID_PARAMETER);
+   if (impl == 0) {
+      return 0;
+   }
+
+   icalparameter_set_tzid((icalparameter*) impl,v);
+   if (icalerrno != ICAL_NO_ERROR) {
+      icalparameter_free((icalparameter*) impl);
+      return 0;
+   }
+
+   return (icalparameter*) impl;
+}
+
+const char* icalparameter_get_tzid(icalparameter* param)
+{
+   icalerror_clear_errno();
+    icalerror_check_arg_rz( (param!=0), "param");
+    return (const char*)((struct icalparameter_impl*)param)->string;
+}
+
+void icalparameter_set_tzid(icalparameter* param, const char* v)
+{
+   icalerror_check_arg_rv( (v!=0),"v");
+   icalerror_check_arg_rv( (param!=0), "param");
+   icalerror_clear_errno();
+   
+   ((struct icalparameter_impl*)param)->string = icalmemory_strdup(v);
+}
+
diff --git a/libical/src/libical/icalderivedparameter.h b/libical/src/libical/icalderivedparameter.h
new file mode 100644
index 0000000..adf4724
--- a/dev/null
+++ b/libical/src/libical/icalderivedparameter.h
@@ -0,0 +1,307 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+  FILE: icalparam.h
+  CREATOR: eric 20 March 1999
+
+
+  $Id$
+  $Locker$
+
+  
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalparam.h
+
+  ======================================================================*/
+
+#ifndef ICALDERIVEDPARAMETER_H
+#define ICALDERIVEDPARAMETER_H
+
+
+typedef void icalparameter;
+
+const char* icalparameter_enum_to_string(int e);
+int icalparameter_string_to_enum(const char* str); 
+
+/* Everything below this line is machine generated. Do not edit. */
+typedef enum icalparameter_kind {
+    ICAL_ANY_PARAMETER = 0,
+    ICAL_ALTREP_PARAMETER, 
+    ICAL_CN_PARAMETER, 
+    ICAL_CUTYPE_PARAMETER, 
+    ICAL_DELEGATEDFROM_PARAMETER, 
+    ICAL_DELEGATEDTO_PARAMETER, 
+    ICAL_DIR_PARAMETER, 
+    ICAL_ENCODING_PARAMETER, 
+    ICAL_FBTYPE_PARAMETER, 
+    ICAL_FMTTYPE_PARAMETER, 
+    ICAL_LANGUAGE_PARAMETER, 
+    ICAL_MEMBER_PARAMETER, 
+    ICAL_PARTSTAT_PARAMETER, 
+    ICAL_RANGE_PARAMETER, 
+    ICAL_RELATED_PARAMETER, 
+    ICAL_RELTYPE_PARAMETER, 
+    ICAL_ROLE_PARAMETER, 
+    ICAL_RSVP_PARAMETER, 
+    ICAL_SENTBY_PARAMETER, 
+    ICAL_TZID_PARAMETER, 
+    ICAL_VALUE_PARAMETER, 
+    ICAL_X_PARAMETER, 
+    ICAL_XLICCOMPARETYPE_PARAMETER, 
+    ICAL_XLICERRORTYPE_PARAMETER, 
+    ICAL_NO_PARAMETER
+} icalparameter_kind;
+
+#define ICALPARAMETER_FIRST_ENUM 20000
+
+typedef enum icalparameter_cutype {
+    ICAL_CUTYPE_X = 20000,
+    ICAL_CUTYPE_INDIVIDUAL = 20001,
+    ICAL_CUTYPE_GROUP = 20002,
+    ICAL_CUTYPE_RESOURCE = 20003,
+    ICAL_CUTYPE_ROOM = 20004,
+    ICAL_CUTYPE_UNKNOWN = 20005,
+    ICAL_CUTYPE_NONE = 20006
+} icalparameter_cutype;
+
+typedef enum icalparameter_encoding {
+    ICAL_ENCODING_X = 20007,
+    ICAL_ENCODING_8BIT = 20008,
+    ICAL_ENCODING_BASE64 = 20009,
+    ICAL_ENCODING_NONE = 20010
+} icalparameter_encoding;
+
+typedef enum icalparameter_fbtype {
+    ICAL_FBTYPE_X = 20011,
+    ICAL_FBTYPE_FREE = 20012,
+    ICAL_FBTYPE_BUSY = 20013,
+    ICAL_FBTYPE_BUSYUNAVAILABLE = 20014,
+    ICAL_FBTYPE_BUSYTENTATIVE = 20015,
+    ICAL_FBTYPE_NONE = 20016
+} icalparameter_fbtype;
+
+typedef enum icalparameter_partstat {
+    ICAL_PARTSTAT_X = 20017,
+    ICAL_PARTSTAT_NEEDSACTION = 20018,
+    ICAL_PARTSTAT_ACCEPTED = 20019,
+    ICAL_PARTSTAT_DECLINED = 20020,
+    ICAL_PARTSTAT_TENTATIVE = 20021,
+    ICAL_PARTSTAT_DELEGATED = 20022,
+    ICAL_PARTSTAT_COMPLETED = 20023,
+    ICAL_PARTSTAT_INPROCESS = 20024,
+    ICAL_PARTSTAT_NONE = 20025
+} icalparameter_partstat;
+
+typedef enum icalparameter_range {
+    ICAL_RANGE_X = 20026,
+    ICAL_RANGE_THISANDPRIOR = 20027,
+    ICAL_RANGE_THISANDFUTURE = 20028,
+    ICAL_RANGE_NONE = 20029
+} icalparameter_range;
+
+typedef enum icalparameter_related {
+    ICAL_RELATED_X = 20030,
+    ICAL_RELATED_START = 20031,
+    ICAL_RELATED_END  = 20032,
+    ICAL_RELATED_NONE = 20033
+} icalparameter_related;
+
+typedef enum icalparameter_reltype {
+    ICAL_RELTYPE_X = 20034,
+    ICAL_RELTYPE_PARENT = 20035,
+    ICAL_RELTYPE_CHILD = 20036,
+    ICAL_RELTYPE_SIBLING = 20037,
+    ICAL_RELTYPE_NONE = 20038
+} icalparameter_reltype;
+
+typedef enum icalparameter_role {
+    ICAL_ROLE_X = 20039,
+    ICAL_ROLE_CHAIR = 20040,
+    ICAL_ROLE_REQPARTICIPANT = 20041,
+    ICAL_ROLE_OPTPARTICIPANT = 20042,
+    ICAL_ROLE_NONPARTICIPANT = 20043,
+    ICAL_ROLE_NONE = 20044
+} icalparameter_role;
+
+typedef enum icalparameter_rsvp {
+    ICAL_RSVP_X = 20045,
+    ICAL_RSVP_TRUE = 20046,
+    ICAL_RSVP_FALSE = 20047,
+    ICAL_RSVP_NONE = 20048
+} icalparameter_rsvp;
+
+typedef enum icalparameter_value {
+    ICAL_VALUE_X = 20049,
+    ICAL_VALUE_BINARY = 20050,
+    ICAL_VALUE_BOOLEAN = 20051,
+    ICAL_VALUE_DATE = 20052,
+    ICAL_VALUE_DURATION = 20053,
+    ICAL_VALUE_FLOAT = 20054,
+    ICAL_VALUE_INTEGER = 20055,
+    ICAL_VALUE_PERIOD = 20056,
+    ICAL_VALUE_RECUR = 20057,
+    ICAL_VALUE_TEXT = 20058,
+    ICAL_VALUE_URI = 20059,
+    ICAL_VALUE_ERROR = 20060,
+    ICAL_VALUE_DATETIME = 20061,
+    ICAL_VALUE_UTCOFFSET = 20062,
+    ICAL_VALUE_CALADDRESS = 20063,
+    ICAL_VALUE_NONE = 20064
+} icalparameter_value;
+
+typedef enum icalparameter_xliccomparetype {
+    ICAL_XLICCOMPARETYPE_X = 20065,
+    ICAL_XLICCOMPARETYPE_EQUAL = 20066,
+    ICAL_XLICCOMPARETYPE_NOTEQUAL = 20067,
+    ICAL_XLICCOMPARETYPE_LESS = 20068,
+    ICAL_XLICCOMPARETYPE_GREATER = 20069,
+    ICAL_XLICCOMPARETYPE_LESSEQUAL = 20070,
+    ICAL_XLICCOMPARETYPE_GREATEREQUAL = 20071,
+    ICAL_XLICCOMPARETYPE_REGEX = 20072,
+    ICAL_XLICCOMPARETYPE_NONE = 20073
+} icalparameter_xliccomparetype;
+
+typedef enum icalparameter_xlicerrortype {
+    ICAL_XLICERRORTYPE_X = 20074,
+    ICAL_XLICERRORTYPE_COMPONENTPARSEERROR = 20075,
+    ICAL_XLICERRORTYPE_PROPERTYPARSEERROR = 20076,
+    ICAL_XLICERRORTYPE_PARAMETERNAMEPARSEERROR = 20077,
+    ICAL_XLICERRORTYPE_PARAMETERVALUEPARSEERROR = 20078,
+    ICAL_XLICERRORTYPE_VALUEPARSEERROR = 20079,
+    ICAL_XLICERRORTYPE_INVALIDITIP = 20080,
+    ICAL_XLICERRORTYPE_UNKNOWNVCALPROPERROR = 20081,
+    ICAL_XLICERRORTYPE_MIMEPARSEERROR = 20082,
+    ICAL_XLICERRORTYPE_NONE = 20083
+} icalparameter_xlicerrortype;
+
+#define ICALPARAMETER_LAST_ENUM 20084
+
+/* DELEGATED-FROM */
+icalparameter* icalparameter_new_delegatedfrom(const char* v);
+const char* icalparameter_get_delegatedfrom(icalparameter* value);
+void icalparameter_set_delegatedfrom(icalparameter* value, const char* v);
+
+/* DELEGATED-TO */
+icalparameter* icalparameter_new_delegatedto(const char* v);
+const char* icalparameter_get_delegatedto(icalparameter* value);
+void icalparameter_set_delegatedto(icalparameter* value, const char* v);
+
+/* RANGE */
+icalparameter* icalparameter_new_range(icalparameter_range v);
+icalparameter_range icalparameter_get_range(icalparameter* value);
+void icalparameter_set_range(icalparameter* value, icalparameter_range v);
+
+/* ENCODING */
+icalparameter* icalparameter_new_encoding(icalparameter_encoding v);
+icalparameter_encoding icalparameter_get_encoding(icalparameter* value);
+void icalparameter_set_encoding(icalparameter* value, icalparameter_encoding v);
+
+/* RSVP */
+icalparameter* icalparameter_new_rsvp(icalparameter_rsvp v);
+icalparameter_rsvp icalparameter_get_rsvp(icalparameter* value);
+void icalparameter_set_rsvp(icalparameter* value, icalparameter_rsvp v);
+
+/* PARTSTAT */
+icalparameter* icalparameter_new_partstat(icalparameter_partstat v);
+icalparameter_partstat icalparameter_get_partstat(icalparameter* value);
+void icalparameter_set_partstat(icalparameter* value, icalparameter_partstat v);
+
+/* RELTYPE */
+icalparameter* icalparameter_new_reltype(icalparameter_reltype v);
+icalparameter_reltype icalparameter_get_reltype(icalparameter* value);
+void icalparameter_set_reltype(icalparameter* value, icalparameter_reltype v);
+
+/* CUTYPE */
+icalparameter* icalparameter_new_cutype(icalparameter_cutype v);
+icalparameter_cutype icalparameter_get_cutype(icalparameter* value);
+void icalparameter_set_cutype(icalparameter* value, icalparameter_cutype v);
+
+/* MEMBER */
+icalparameter* icalparameter_new_member(const char* v);
+const char* icalparameter_get_member(icalparameter* value);
+void icalparameter_set_member(icalparameter* value, const char* v);
+
+/* FMTTYPE */
+icalparameter* icalparameter_new_fmttype(const char* v);
+const char* icalparameter_get_fmttype(icalparameter* value);
+void icalparameter_set_fmttype(icalparameter* value, const char* v);
+
+/* SENT-BY */
+icalparameter* icalparameter_new_sentby(const char* v);
+const char* icalparameter_get_sentby(icalparameter* value);
+void icalparameter_set_sentby(icalparameter* value, const char* v);
+
+/* VALUE */
+icalparameter* icalparameter_new_value(icalparameter_value v);
+icalparameter_value icalparameter_get_value(icalparameter* value);
+void icalparameter_set_value(icalparameter* value, icalparameter_value v);
+
+/* ALTREP */
+icalparameter* icalparameter_new_altrep(const char* v);
+const char* icalparameter_get_altrep(icalparameter* value);
+void icalparameter_set_altrep(icalparameter* value, const char* v);
+
+/* DIR */
+icalparameter* icalparameter_new_dir(const char* v);
+const char* icalparameter_get_dir(icalparameter* value);
+void icalparameter_set_dir(icalparameter* value, const char* v);
+
+/* RELATED */
+icalparameter* icalparameter_new_related(icalparameter_related v);
+icalparameter_related icalparameter_get_related(icalparameter* value);
+void icalparameter_set_related(icalparameter* value, icalparameter_related v);
+
+/* CN */
+icalparameter* icalparameter_new_cn(const char* v);
+const char* icalparameter_get_cn(icalparameter* value);
+void icalparameter_set_cn(icalparameter* value, const char* v);
+
+/* X-LIC-ERRORTYPE */
+icalparameter* icalparameter_new_xlicerrortype(icalparameter_xlicerrortype v);
+icalparameter_xlicerrortype icalparameter_get_xlicerrortype(icalparameter* value);
+void icalparameter_set_xlicerrortype(icalparameter* value, icalparameter_xlicerrortype v);
+
+/* X */
+icalparameter* icalparameter_new_x(const char* v);
+const char* icalparameter_get_x(icalparameter* value);
+void icalparameter_set_x(icalparameter* value, const char* v);
+
+/* LANGUAGE */
+icalparameter* icalparameter_new_language(const char* v);
+const char* icalparameter_get_language(icalparameter* value);
+void icalparameter_set_language(icalparameter* value, const char* v);
+
+/* ROLE */
+icalparameter* icalparameter_new_role(icalparameter_role v);
+icalparameter_role icalparameter_get_role(icalparameter* value);
+void icalparameter_set_role(icalparameter* value, icalparameter_role v);
+
+/* X-LIC-COMPARETYPE */
+icalparameter* icalparameter_new_xliccomparetype(icalparameter_xliccomparetype v);
+icalparameter_xliccomparetype icalparameter_get_xliccomparetype(icalparameter* value);
+void icalparameter_set_xliccomparetype(icalparameter* value, icalparameter_xliccomparetype v);
+
+/* FBTYPE */
+icalparameter* icalparameter_new_fbtype(icalparameter_fbtype v);
+icalparameter_fbtype icalparameter_get_fbtype(icalparameter* value);
+void icalparameter_set_fbtype(icalparameter* value, icalparameter_fbtype v);
+
+/* TZID */
+icalparameter* icalparameter_new_tzid(const char* v);
+const char* icalparameter_get_tzid(icalparameter* value);
+void icalparameter_set_tzid(icalparameter* value, const char* v);
+
+#endif /*ICALPARAMETER_H*/
+
diff --git a/libical/src/libical/icalderivedproperty.c b/libical/src/libical/icalderivedproperty.c
new file mode 100644
index 0000000..b41562b
--- a/dev/null
+++ b/libical/src/libical/icalderivedproperty.c
@@ -0,0 +1,2014 @@
+/* -*- Mode: C -*- */
+
+/*======================================================================
+  FILE: icalderivedproperty.c
+  CREATOR: eric 15 Feb 2001
+  
+  $Id$
+
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalproperty.c
+
+======================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "icalproperty.h"
+#include "icalcomponent.h"
+#include "pvl.h"
+#include "icalenums.h"
+#include "icalerror.h"
+#include "icalmemory.h"
+#include "icalparser.h"
+
+#include <string.h> /* For icalmemory_strdup, rindex */
+#include <assert.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <stdio.h> /* for printf */
+#include <stdarg.h> /* for va_list, va_start, etc. */
+                                               
+#define TMP_BUF_SIZE 1024
+
+struct icalproperty_impl*
+icalproperty_new_impl (icalproperty_kind kind);
+
+/* This map associates the property kinds with the string
+   representation of the property name and the kind of VALUE that the
+   property uses as a default */
+
+struct  icalproperty_map {
+        icalproperty_kind kind;
+        const char *name;
+        icalvalue_kind value;
+
+};
+
+extern struct icalproperty_map property_map[];
+extern void icalproperty_add_parameters(struct icalproperty_impl *prop,va_list args);
+const char* icalproperty_kind_to_string(icalproperty_kind kind)
+{
+    int i;
+
+    for (i=0; property_map[i].kind != ICAL_NO_PROPERTY; i++) {
+        if (property_map[i].kind == kind) {
+            return property_map[i].name;
+        }
+    }
+
+    return 0;
+
+}
+
+
+icalproperty_kind icalproperty_string_to_kind(const char* string)
+{
+    int i;
+
+    if (string ==0 ) { 
+        return ICAL_NO_PROPERTY;
+    }
+
+
+    for (i=0; property_map[i].kind  != ICAL_NO_PROPERTY; i++) {
+        if (strcmp(property_map[i].name, string) == 0) {
+            return property_map[i].kind;
+        }
+    }
+
+    if(strncmp(string,"X-",2)==0){
+        return ICAL_X_PROPERTY;
+    }
+
+
+    return ICAL_NO_PROPERTY;
+}
+
+
+icalvalue_kind icalproperty_value_kind_to_kind(icalvalue_kind kind)
+{
+    int i;
+
+    for (i=0; property_map[i].kind  != ICAL_NO_PROPERTY; i++) {
+        if ( property_map[i].value == kind ) {
+            return property_map[i].kind;
+        }
+    }
+
+    return ICAL_NO_VALUE;
+}
+
+
+
+icalvalue_kind icalproperty_kind_to_value_kind(icalproperty_kind kind)
+{
+    int i;
+
+    for (i=0; property_map[i].kind  != ICAL_NO_PROPERTY; i++) {
+        if ( property_map[i].kind == kind ) {
+            return property_map[i].value;
+        }
+    }
+
+    return ICAL_NO_VALUE;
+}
+
+
+/* This map associates the property enumerations with the king of
+   property that they are used in and the string representation of the
+   enumeration */
+
+struct icalproperty_enum_map {
+    icalproperty_kind prop;
+    int prop_enum;
+    const char* str;
+}; 
+
+extern struct icalproperty_enum_map enum_map[];
+
+
+const char* icalproperty_enum_to_string(int e)
+{
+    icalerror_check_arg_rz(e >= ICALPROPERTY_FIRST_ENUM,"e");
+    icalerror_check_arg_rz(e <= ICALPROPERTY_LAST_ENUM,"e");
+
+    return enum_map[e-ICALPROPERTY_FIRST_ENUM].str;
+}
+
+int icalproperty_string_to_enum(const char* str)
+{
+    int i;
+
+    icalerror_check_arg_rz(str!=0,"str")
+
+    while(*str == ' '){
+        str++;
+    }
+
+    for (i=ICALPROPERTY_FIRST_ENUM; i != ICALPROPERTY_LAST_ENUM; i++) {
+        if ( strcmp(enum_map[i-ICALPROPERTY_FIRST_ENUM].str, str) == 0) {
+            return enum_map[i-ICALPROPERTY_FIRST_ENUM].prop_enum;
+        }
+    }
+
+    return 0;
+}
+
+int icalproperty_enum_belongs_to_property(icalproperty_kind kind, int e)
+{
+    int i;
+
+
+    for (i=ICALPROPERTY_FIRST_ENUM; i != ICALPROPERTY_LAST_ENUM; i++) {
+        if(enum_map[i-ICALPROPERTY_FIRST_ENUM].prop_enum == e && 
+           enum_map[i-ICALPROPERTY_FIRST_ENUM].prop == kind ){
+            return 1;
+        }
+    }
+
+    return 0;
+}
+
+
+const char* icalproperty_method_to_string(icalproperty_method method)
+{
+    icalerror_check_arg_rz(method >= ICAL_METHOD_X,"method");
+    icalerror_check_arg_rz(method <= ICAL_METHOD_NONE,"method");
+
+    return enum_map[method-ICALPROPERTY_FIRST_ENUM].str;
+}
+
+icalproperty_method icalproperty_string_to_method(const char* str)
+{
+    int i;
+
+    icalerror_check_arg_rx(str!=0,"str",ICAL_METHOD_NONE)
+
+    while(*str == ' '){
+        str++;
+    }
+
+    for (i=ICAL_METHOD_X-ICALPROPERTY_FIRST_ENUM; 
+         i != ICAL_METHOD_NONE-ICALPROPERTY_FIRST_ENUM;
+         i++) {
+        if ( strcmp(enum_map[i].str, str) == 0) {
+            return (icalproperty_method)enum_map[i].prop_enum;
+        }
+    }
+
+    return ICAL_METHOD_NONE;
+}
+
+
+const char* icalenum_status_to_string(icalproperty_status status)
+{
+    icalerror_check_arg_rz(status >= ICAL_STATUS_X,"status");
+    icalerror_check_arg_rz(status <= ICAL_STATUS_NONE,"status");
+
+    return enum_map[status-ICALPROPERTY_FIRST_ENUM].str;
+}
+
+icalproperty_status icalenum_string_to_status(const char* str)
+{
+    int i;
+
+    icalerror_check_arg_rx(str!=0,"str",ICAL_STATUS_NONE)
+
+    while(*str == ' '){
+        str++;
+    }
+
+    for (i=ICAL_STATUS_X-ICALPROPERTY_FIRST_ENUM; 
+         i != ICAL_STATUS_NONE-ICALPROPERTY_FIRST_ENUM;
+         i++) {
+        if ( strcmp(enum_map[i].str, str) == 0) {
+            return (icalproperty_method)enum_map[i].prop_enum;
+        }
+    }
+
+    return ICAL_STATUS_NONE;
+
+}
+
+
+
+/* Everything below this line is machine generated. Do not edit. */
+static struct icalproperty_map property_map[] = {
+{ICAL_ACTION_PROPERTY,"ACTION",ICAL_ACTION_VALUE},
+{ICAL_ANY_PROPERTY,"ANY",ICAL_NO_VALUE},
+{ICAL_ATTACH_PROPERTY,"ATTACH",ICAL_ATTACH_VALUE},
+{ICAL_ATTENDEE_PROPERTY,"ATTENDEE",ICAL_CALADDRESS_VALUE},
+{ICAL_CALSCALE_PROPERTY,"CALSCALE",ICAL_TEXT_VALUE},
+{ICAL_CATEGORIES_PROPERTY,"CATEGORIES",ICAL_TEXT_VALUE},
+{ICAL_CLASS_PROPERTY,"CLASS",ICAL_TEXT_VALUE},
+{ICAL_COMMENT_PROPERTY,"COMMENT",ICAL_TEXT_VALUE},
+{ICAL_COMPLETED_PROPERTY,"COMPLETED",ICAL_DATETIME_VALUE},
+{ICAL_CONTACT_PROPERTY,"CONTACT",ICAL_TEXT_VALUE},
+{ICAL_CREATED_PROPERTY,"CREATED",ICAL_DATETIME_VALUE},
+{ICAL_DESCRIPTION_PROPERTY,"DESCRIPTION",ICAL_TEXT_VALUE},
+{ICAL_DTEND_PROPERTY,"DTEND",ICAL_DATETIME_VALUE},
+{ICAL_DTSTAMP_PROPERTY,"DTSTAMP",ICAL_DATETIME_VALUE},
+{ICAL_DTSTART_PROPERTY,"DTSTART",ICAL_DATETIME_VALUE},
+{ICAL_DUE_PROPERTY,"DUE",ICAL_DATETIME_VALUE},
+{ICAL_DURATION_PROPERTY,"DURATION",ICAL_DURATION_VALUE},
+{ICAL_EXDATE_PROPERTY,"EXDATE",ICAL_DATETIME_VALUE},
+{ICAL_EXRULE_PROPERTY,"EXRULE",ICAL_RECUR_VALUE},
+{ICAL_FREEBUSY_PROPERTY,"FREEBUSY",ICAL_PERIOD_VALUE},
+{ICAL_GEO_PROPERTY,"GEO",ICAL_GEO_VALUE},
+{ICAL_LASTMODIFIED_PROPERTY,"LAST-MODIFIED",ICAL_DATETIME_VALUE},
+{ICAL_LOCATION_PROPERTY,"LOCATION",ICAL_TEXT_VALUE},
+{ICAL_MAXRESULTS_PROPERTY,"MAXRESULTS",ICAL_INTEGER_VALUE},
+{ICAL_MAXRESULTSSIZE_PROPERTY,"MAXRESULTSSIZE",ICAL_INTEGER_VALUE},
+{ICAL_METHOD_PROPERTY,"METHOD",ICAL_METHOD_VALUE},
+{ICAL_ORGANIZER_PROPERTY,"ORGANIZER",ICAL_CALADDRESS_VALUE},
+{ICAL_PERCENTCOMPLETE_PROPERTY,"PERCENT-COMPLETE",ICAL_INTEGER_VALUE},
+{ICAL_PRIORITY_PROPERTY,"PRIORITY",ICAL_INTEGER_VALUE},
+{ICAL_PRODID_PROPERTY,"PRODID",ICAL_TEXT_VALUE},
+{ICAL_QUERY_PROPERTY,"QUERY",ICAL_QUERY_VALUE},
+{ICAL_QUERYNAME_PROPERTY,"QUERYNAME",ICAL_TEXT_VALUE},
+{ICAL_RDATE_PROPERTY,"RDATE",ICAL_DATETIMEPERIOD_VALUE},
+{ICAL_RECURRENCEID_PROPERTY,"RECURRENCE-ID",ICAL_DATETIME_VALUE},
+{ICAL_RELATEDTO_PROPERTY,"RELATED-TO",ICAL_TEXT_VALUE},
+{ICAL_REPEAT_PROPERTY,"REPEAT",ICAL_INTEGER_VALUE},
+{ICAL_REQUESTSTATUS_PROPERTY,"REQUEST-STATUS",ICAL_REQUESTSTATUS_VALUE},
+{ICAL_RESOURCES_PROPERTY,"RESOURCES",ICAL_TEXT_VALUE},
+{ICAL_RRULE_PROPERTY,"RRULE",ICAL_RECUR_VALUE},
+{ICAL_SCOPE_PROPERTY,"SCOPE",ICAL_TEXT_VALUE},
+{ICAL_SEQUENCE_PROPERTY,"SEQUENCE",ICAL_INTEGER_VALUE},
+{ICAL_STATUS_PROPERTY,"STATUS",ICAL_STATUS_VALUE},
+{ICAL_SUMMARY_PROPERTY,"SUMMARY",ICAL_TEXT_VALUE},
+{ICAL_TARGET_PROPERTY,"TARGET",ICAL_CALADDRESS_VALUE},
+{ICAL_TRANSP_PROPERTY,"TRANSP",ICAL_TEXT_VALUE},
+{ICAL_TRIGGER_PROPERTY,"TRIGGER",ICAL_TRIGGER_VALUE},
+{ICAL_TZID_PROPERTY,"TZID",ICAL_TEXT_VALUE},
+{ICAL_TZNAME_PROPERTY,"TZNAME",ICAL_TEXT_VALUE},
+{ICAL_TZOFFSETFROM_PROPERTY,"TZOFFSETFROM",ICAL_UTCOFFSET_VALUE},
+{ICAL_TZOFFSETTO_PROPERTY,"TZOFFSETTO",ICAL_UTCOFFSET_VALUE},
+{ICAL_TZURL_PROPERTY,"TZURL",ICAL_URI_VALUE},
+{ICAL_UID_PROPERTY,"UID",ICAL_TEXT_VALUE},
+{ICAL_URL_PROPERTY,"URL",ICAL_URI_VALUE},
+{ICAL_VERSION_PROPERTY,"VERSION",ICAL_TEXT_VALUE},
+{ICAL_X_PROPERTY,"X",ICAL_TEXT_VALUE},
+{ICAL_XLICCLUSTERCOUNT_PROPERTY,"X-LIC-CLUSTERCOUNT",ICAL_STRING_VALUE},
+{ICAL_XLICERROR_PROPERTY,"X-LIC-ERROR",ICAL_TEXT_VALUE},
+{ICAL_XLICMIMECHARSET_PROPERTY,"X-LIC-MIMECHARSET",ICAL_STRING_VALUE},
+{ICAL_XLICMIMECID_PROPERTY,"X-LIC-MIMECID",ICAL_STRING_VALUE},
+{ICAL_XLICMIMECONTENTTYPE_PROPERTY,"X-LIC-MIMECONTENTTYPE",ICAL_STRING_VALUE},
+{ICAL_XLICMIMEENCODING_PROPERTY,"X-LIC-MIMEENCODING",ICAL_STRING_VALUE},
+{ICAL_XLICMIMEFILENAME_PROPERTY,"X-LIC-MIMEFILENAME",ICAL_STRING_VALUE},
+{ICAL_XLICMIMEOPTINFO_PROPERTY,"X-LIC-MIMEOPTINFO",ICAL_STRING_VALUE},
+{ICAL_NO_PROPERTY,"",ICAL_NO_VALUE}};
+
+static struct icalproperty_enum_map enum_map[] = {
+    {ICAL_ACTION_PROPERTY,ICAL_ACTION_X,"" }, /*10000*/
+    {ICAL_ACTION_PROPERTY,ICAL_ACTION_AUDIO,"AUDIO" }, /*10001*/
+    {ICAL_ACTION_PROPERTY,ICAL_ACTION_DISPLAY,"DISPLAY" }, /*10002*/
+    {ICAL_ACTION_PROPERTY,ICAL_ACTION_EMAIL,"EMAIL" }, /*10003*/
+    {ICAL_ACTION_PROPERTY,ICAL_ACTION_PROCEDURE,"PROCEDURE" }, /*10004*/
+    {ICAL_ACTION_PROPERTY,ICAL_ACTION_NONE,"" }, /*10005*/
+    {ICAL_CLASS_PROPERTY,ICAL_CLASS_X,"" }, /*10006*/
+    {ICAL_CLASS_PROPERTY,ICAL_CLASS_PUBLIC,"PUBLIC" }, /*10007*/
+    {ICAL_CLASS_PROPERTY,ICAL_CLASS_PRIVATE,"PRIVATE" }, /*10008*/
+    {ICAL_CLASS_PROPERTY,ICAL_CLASS_CONFIDENTIAL,"CONFIDENTIAL" }, /*10009*/
+    {ICAL_CLASS_PROPERTY,ICAL_CLASS_NONE,"" }, /*10010*/
+    {ICAL_METHOD_PROPERTY,ICAL_METHOD_X,"" }, /*10011*/
+    {ICAL_METHOD_PROPERTY,ICAL_METHOD_PUBLISH,"PUBLISH" }, /*10012*/
+    {ICAL_METHOD_PROPERTY,ICAL_METHOD_REQUEST,"REQUEST" }, /*10013*/
+    {ICAL_METHOD_PROPERTY,ICAL_METHOD_REPLY,"REPLY" }, /*10014*/
+    {ICAL_METHOD_PROPERTY,ICAL_METHOD_ADD,"ADD" }, /*10015*/
+    {ICAL_METHOD_PROPERTY,ICAL_METHOD_CANCEL,"CANCEL" }, /*10016*/
+    {ICAL_METHOD_PROPERTY,ICAL_METHOD_REFRESH,"REFRESH" }, /*10017*/
+    {ICAL_METHOD_PROPERTY,ICAL_METHOD_COUNTER,"COUNTER" }, /*10018*/
+    {ICAL_METHOD_PROPERTY,ICAL_METHOD_DECLINECOUNTER,"DECLINECOUNTER" }, /*10019*/
+    {ICAL_METHOD_PROPERTY,ICAL_METHOD_CREATE,"CREATE" }, /*10020*/
+    {ICAL_METHOD_PROPERTY,ICAL_METHOD_READ,"READ" }, /*10021*/
+    {ICAL_METHOD_PROPERTY,ICAL_METHOD_RESPONSE,"RESPONSE" }, /*10022*/
+    {ICAL_METHOD_PROPERTY,ICAL_METHOD_MOVE,"MOVE" }, /*10023*/
+    {ICAL_METHOD_PROPERTY,ICAL_METHOD_MODIFY,"MODIFY" }, /*10024*/
+    {ICAL_METHOD_PROPERTY,ICAL_METHOD_GENERATEUID,"GENERATEUID" }, /*10025*/
+    {ICAL_METHOD_PROPERTY,ICAL_METHOD_DELETE,"DELETE" }, /*10026*/
+    {ICAL_METHOD_PROPERTY,ICAL_METHOD_NONE,"" }, /*10027*/
+    {ICAL_STATUS_PROPERTY,ICAL_STATUS_X,"" }, /*10028*/
+    {ICAL_STATUS_PROPERTY,ICAL_STATUS_TENTATIVE,"TENTATIVE" }, /*10029*/
+    {ICAL_STATUS_PROPERTY,ICAL_STATUS_CONFIRMED,"CONFIRMED" }, /*10030*/
+    {ICAL_STATUS_PROPERTY,ICAL_STATUS_COMPLETED,"COMPLETED" }, /*10031*/
+    {ICAL_STATUS_PROPERTY,ICAL_STATUS_NEEDSACTION,"NEEDS-ACTION" }, /*10032*/
+    {ICAL_STATUS_PROPERTY,ICAL_STATUS_CANCELLED,"CANCELLED" }, /*10033*/
+    {ICAL_STATUS_PROPERTY,ICAL_STATUS_INPROCESS,"IN-PROCESS" }, /*10034*/
+    {ICAL_STATUS_PROPERTY,ICAL_STATUS_DRAFT,"DRAFT" }, /*10035*/
+    {ICAL_STATUS_PROPERTY,ICAL_STATUS_FINAL,"FINAL" }, /*10036*/
+    {ICAL_STATUS_PROPERTY,ICAL_STATUS_NONE,"" }, /*10037*/
+    {ICAL_TRANSP_PROPERTY,ICAL_TRANSP_X,"" }, /*10038*/
+    {ICAL_TRANSP_PROPERTY,ICAL_TRANSP_OPAQUE,"OPAQUE" }, /*10039*/
+    {ICAL_TRANSP_PROPERTY,ICAL_TRANSP_TRANSPARENT,"TRANSPARENT" }, /*10040*/
+    {ICAL_TRANSP_PROPERTY,ICAL_TRANSP_NONE,"" }, /*10041*/
+    {ICAL_NO_PROPERTY,0,""}
+};
+
+icalproperty* icalproperty_vanew_action(enum icalproperty_action v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_ACTION_PROPERTY);   
+   icalproperty_set_action((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* ACTION */
+icalproperty* icalproperty_new_action(enum icalproperty_action v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_ACTION_PROPERTY);   
+   icalproperty_set_action((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_action(icalproperty* prop, enum icalproperty_action v){
+    
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_action(v));
+}
+enum icalproperty_action icalproperty_get_action(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_action(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_attach(struct icalattachtype* v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_ATTACH_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_attach((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* ATTACH */
+icalproperty* icalproperty_new_attach(struct icalattachtype* v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_ATTACH_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_attach((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_attach(icalproperty* prop, struct icalattachtype* v){
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_attach(v));
+}
+struct icalattachtype* icalproperty_get_attach(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_attach(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_attendee(const char* v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_ATTENDEE_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_attendee((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* ATTENDEE */
+icalproperty* icalproperty_new_attendee(const char* v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_ATTENDEE_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_attendee((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_attendee(icalproperty* prop, const char* v){
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_caladdress(v));
+}
+const char* icalproperty_get_attendee(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_caladdress(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_calscale(const char* v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_CALSCALE_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_calscale((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* CALSCALE */
+icalproperty* icalproperty_new_calscale(const char* v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_CALSCALE_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_calscale((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_calscale(icalproperty* prop, const char* v){
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_text(v));
+}
+const char* icalproperty_get_calscale(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_text(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_categories(const char* v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_CATEGORIES_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_categories((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* CATEGORIES */
+icalproperty* icalproperty_new_categories(const char* v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_CATEGORIES_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_categories((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_categories(icalproperty* prop, const char* v){
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_text(v));
+}
+const char* icalproperty_get_categories(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_text(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_class(const char* v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_CLASS_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_class((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* CLASS */
+icalproperty* icalproperty_new_class(const char* v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_CLASS_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_class((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_class(icalproperty* prop, const char* v){
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_text(v));
+}
+const char* icalproperty_get_class(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_text(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_comment(const char* v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_COMMENT_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_comment((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* COMMENT */
+icalproperty* icalproperty_new_comment(const char* v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_COMMENT_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_comment((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_comment(icalproperty* prop, const char* v){
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_text(v));
+}
+const char* icalproperty_get_comment(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_text(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_completed(struct icaltimetype v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_COMPLETED_PROPERTY);   
+   icalproperty_set_completed((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* COMPLETED */
+icalproperty* icalproperty_new_completed(struct icaltimetype v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_COMPLETED_PROPERTY);   
+   icalproperty_set_completed((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_completed(icalproperty* prop, struct icaltimetype v){
+    
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_datetime(v));
+}
+struct icaltimetype icalproperty_get_completed(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_datetime(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_contact(const char* v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_CONTACT_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_contact((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* CONTACT */
+icalproperty* icalproperty_new_contact(const char* v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_CONTACT_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_contact((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_contact(icalproperty* prop, const char* v){
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_text(v));
+}
+const char* icalproperty_get_contact(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_text(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_created(struct icaltimetype v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_CREATED_PROPERTY);   
+   icalproperty_set_created((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* CREATED */
+icalproperty* icalproperty_new_created(struct icaltimetype v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_CREATED_PROPERTY);   
+   icalproperty_set_created((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_created(icalproperty* prop, struct icaltimetype v){
+    
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_datetime(v));
+}
+struct icaltimetype icalproperty_get_created(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_datetime(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_description(const char* v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_DESCRIPTION_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_description((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* DESCRIPTION */
+icalproperty* icalproperty_new_description(const char* v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_DESCRIPTION_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_description((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_description(icalproperty* prop, const char* v){
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_text(v));
+}
+const char* icalproperty_get_description(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_text(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_dtend(struct icaltimetype v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_DTEND_PROPERTY);   
+   icalproperty_set_dtend((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* DTEND */
+icalproperty* icalproperty_new_dtend(struct icaltimetype v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_DTEND_PROPERTY);   
+   icalproperty_set_dtend((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_dtend(icalproperty* prop, struct icaltimetype v){
+    
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_datetime(v));
+}
+struct icaltimetype icalproperty_get_dtend(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_datetime(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_dtstamp(struct icaltimetype v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_DTSTAMP_PROPERTY);   
+   icalproperty_set_dtstamp((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* DTSTAMP */
+icalproperty* icalproperty_new_dtstamp(struct icaltimetype v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_DTSTAMP_PROPERTY);   
+   icalproperty_set_dtstamp((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_dtstamp(icalproperty* prop, struct icaltimetype v){
+    
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_datetime(v));
+}
+struct icaltimetype icalproperty_get_dtstamp(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_datetime(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_dtstart(struct icaltimetype v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_DTSTART_PROPERTY);   
+   icalproperty_set_dtstart((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* DTSTART */
+icalproperty* icalproperty_new_dtstart(struct icaltimetype v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_DTSTART_PROPERTY);   
+   icalproperty_set_dtstart((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_dtstart(icalproperty* prop, struct icaltimetype v){
+    
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_datetime(v));
+}
+struct icaltimetype icalproperty_get_dtstart(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_datetime(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_due(struct icaltimetype v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_DUE_PROPERTY);   
+   icalproperty_set_due((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* DUE */
+icalproperty* icalproperty_new_due(struct icaltimetype v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_DUE_PROPERTY);   
+   icalproperty_set_due((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_due(icalproperty* prop, struct icaltimetype v){
+    
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_datetime(v));
+}
+struct icaltimetype icalproperty_get_due(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_datetime(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_duration(struct icaldurationtype v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_DURATION_PROPERTY);   
+   icalproperty_set_duration((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* DURATION */
+icalproperty* icalproperty_new_duration(struct icaldurationtype v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_DURATION_PROPERTY);   
+   icalproperty_set_duration((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_duration(icalproperty* prop, struct icaldurationtype v){
+    
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_duration(v));
+}
+struct icaldurationtype icalproperty_get_duration(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_duration(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_exdate(struct icaltimetype v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_EXDATE_PROPERTY);   
+   icalproperty_set_exdate((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* EXDATE */
+icalproperty* icalproperty_new_exdate(struct icaltimetype v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_EXDATE_PROPERTY);   
+   icalproperty_set_exdate((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_exdate(icalproperty* prop, struct icaltimetype v){
+    
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_datetime(v));
+}
+struct icaltimetype icalproperty_get_exdate(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_datetime(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_exrule(struct icalrecurrencetype v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_EXRULE_PROPERTY);   
+   icalproperty_set_exrule((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* EXRULE */
+icalproperty* icalproperty_new_exrule(struct icalrecurrencetype v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_EXRULE_PROPERTY);   
+   icalproperty_set_exrule((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_exrule(icalproperty* prop, struct icalrecurrencetype v){
+    
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_recur(v));
+}
+struct icalrecurrencetype icalproperty_get_exrule(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_recur(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_freebusy(struct icalperiodtype v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_FREEBUSY_PROPERTY);   
+   icalproperty_set_freebusy((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* FREEBUSY */
+icalproperty* icalproperty_new_freebusy(struct icalperiodtype v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_FREEBUSY_PROPERTY);   
+   icalproperty_set_freebusy((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_freebusy(icalproperty* prop, struct icalperiodtype v){
+    
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_period(v));
+}
+struct icalperiodtype icalproperty_get_freebusy(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_period(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_geo(struct icalgeotype v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_GEO_PROPERTY);   
+   icalproperty_set_geo((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* GEO */
+icalproperty* icalproperty_new_geo(struct icalgeotype v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_GEO_PROPERTY);   
+   icalproperty_set_geo((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_geo(icalproperty* prop, struct icalgeotype v){
+    
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_geo(v));
+}
+struct icalgeotype icalproperty_get_geo(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_geo(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_lastmodified(struct icaltimetype v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_LASTMODIFIED_PROPERTY);   
+   icalproperty_set_lastmodified((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* LAST-MODIFIED */
+icalproperty* icalproperty_new_lastmodified(struct icaltimetype v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_LASTMODIFIED_PROPERTY);   
+   icalproperty_set_lastmodified((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_lastmodified(icalproperty* prop, struct icaltimetype v){
+    
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_datetime(v));
+}
+struct icaltimetype icalproperty_get_lastmodified(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_datetime(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_location(const char* v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_LOCATION_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_location((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* LOCATION */
+icalproperty* icalproperty_new_location(const char* v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_LOCATION_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_location((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_location(icalproperty* prop, const char* v){
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_text(v));
+}
+const char* icalproperty_get_location(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_text(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_maxresults(int v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_MAXRESULTS_PROPERTY);   
+   icalproperty_set_maxresults((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* MAXRESULTS */
+icalproperty* icalproperty_new_maxresults(int v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_MAXRESULTS_PROPERTY);   
+   icalproperty_set_maxresults((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_maxresults(icalproperty* prop, int v){
+    
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_integer(v));
+}
+int icalproperty_get_maxresults(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_integer(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_maxresultssize(int v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_MAXRESULTSSIZE_PROPERTY);   
+   icalproperty_set_maxresultssize((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* MAXRESULTSSIZE */
+icalproperty* icalproperty_new_maxresultssize(int v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_MAXRESULTSSIZE_PROPERTY);   
+   icalproperty_set_maxresultssize((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_maxresultssize(icalproperty* prop, int v){
+    
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_integer(v));
+}
+int icalproperty_get_maxresultssize(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_integer(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_method(enum icalproperty_method v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_METHOD_PROPERTY);   
+   icalproperty_set_method((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* METHOD */
+icalproperty* icalproperty_new_method(enum icalproperty_method v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_METHOD_PROPERTY);   
+   icalproperty_set_method((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_method(icalproperty* prop, enum icalproperty_method v){
+    
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_method(v));
+}
+enum icalproperty_method icalproperty_get_method(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_method(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_organizer(const char* v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_ORGANIZER_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_organizer((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* ORGANIZER */
+icalproperty* icalproperty_new_organizer(const char* v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_ORGANIZER_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_organizer((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_organizer(icalproperty* prop, const char* v){
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_caladdress(v));
+}
+const char* icalproperty_get_organizer(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_caladdress(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_percentcomplete(int v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_PERCENTCOMPLETE_PROPERTY);   
+   icalproperty_set_percentcomplete((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* PERCENT-COMPLETE */
+icalproperty* icalproperty_new_percentcomplete(int v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_PERCENTCOMPLETE_PROPERTY);   
+   icalproperty_set_percentcomplete((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_percentcomplete(icalproperty* prop, int v){
+    
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_integer(v));
+}
+int icalproperty_get_percentcomplete(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_integer(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_priority(int v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_PRIORITY_PROPERTY);   
+   icalproperty_set_priority((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* PRIORITY */
+icalproperty* icalproperty_new_priority(int v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_PRIORITY_PROPERTY);   
+   icalproperty_set_priority((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_priority(icalproperty* prop, int v){
+    
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_integer(v));
+}
+int icalproperty_get_priority(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_integer(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_prodid(const char* v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_PRODID_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_prodid((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* PRODID */
+icalproperty* icalproperty_new_prodid(const char* v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_PRODID_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_prodid((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_prodid(icalproperty* prop, const char* v){
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_text(v));
+}
+const char* icalproperty_get_prodid(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_text(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_query(const char* v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_QUERY_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_query((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* QUERY */
+icalproperty* icalproperty_new_query(const char* v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_QUERY_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_query((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_query(icalproperty* prop, const char* v){
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_query(v));
+}
+const char* icalproperty_get_query(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_query(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_queryname(const char* v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_QUERYNAME_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_queryname((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* QUERYNAME */
+icalproperty* icalproperty_new_queryname(const char* v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_QUERYNAME_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_queryname((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_queryname(icalproperty* prop, const char* v){
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_text(v));
+}
+const char* icalproperty_get_queryname(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_text(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_rdate(struct icaldatetimeperiodtype v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_RDATE_PROPERTY);   
+   icalproperty_set_rdate((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* RDATE */
+icalproperty* icalproperty_new_rdate(struct icaldatetimeperiodtype v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_RDATE_PROPERTY);   
+   icalproperty_set_rdate((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_rdate(icalproperty* prop, struct icaldatetimeperiodtype v){
+    
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_datetimeperiod(v));
+}
+struct icaldatetimeperiodtype icalproperty_get_rdate(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_datetimeperiod(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_recurrenceid(struct icaltimetype v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_RECURRENCEID_PROPERTY);   
+   icalproperty_set_recurrenceid((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* RECURRENCE-ID */
+icalproperty* icalproperty_new_recurrenceid(struct icaltimetype v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_RECURRENCEID_PROPERTY);   
+   icalproperty_set_recurrenceid((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_recurrenceid(icalproperty* prop, struct icaltimetype v){
+    
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_datetime(v));
+}
+struct icaltimetype icalproperty_get_recurrenceid(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_datetime(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_relatedto(const char* v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_RELATEDTO_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_relatedto((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* RELATED-TO */
+icalproperty* icalproperty_new_relatedto(const char* v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_RELATEDTO_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_relatedto((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_relatedto(icalproperty* prop, const char* v){
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_text(v));
+}
+const char* icalproperty_get_relatedto(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_text(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_repeat(int v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_REPEAT_PROPERTY);   
+   icalproperty_set_repeat((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* REPEAT */
+icalproperty* icalproperty_new_repeat(int v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_REPEAT_PROPERTY);   
+   icalproperty_set_repeat((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_repeat(icalproperty* prop, int v){
+    
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_integer(v));
+}
+int icalproperty_get_repeat(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_integer(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_requeststatus(struct icalreqstattype v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_REQUESTSTATUS_PROPERTY);   
+   icalproperty_set_requeststatus((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* REQUEST-STATUS */
+icalproperty* icalproperty_new_requeststatus(struct icalreqstattype v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_REQUESTSTATUS_PROPERTY);   
+   icalproperty_set_requeststatus((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_requeststatus(icalproperty* prop, struct icalreqstattype v){
+    
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_requeststatus(v));
+}
+struct icalreqstattype icalproperty_get_requeststatus(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_requeststatus(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_resources(const char* v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_RESOURCES_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_resources((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* RESOURCES */
+icalproperty* icalproperty_new_resources(const char* v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_RESOURCES_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_resources((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_resources(icalproperty* prop, const char* v){
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_text(v));
+}
+const char* icalproperty_get_resources(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_text(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_rrule(struct icalrecurrencetype v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_RRULE_PROPERTY);   
+   icalproperty_set_rrule((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* RRULE */
+icalproperty* icalproperty_new_rrule(struct icalrecurrencetype v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_RRULE_PROPERTY);   
+   icalproperty_set_rrule((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_rrule(icalproperty* prop, struct icalrecurrencetype v){
+    
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_recur(v));
+}
+struct icalrecurrencetype icalproperty_get_rrule(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_recur(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_scope(const char* v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_SCOPE_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_scope((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* SCOPE */
+icalproperty* icalproperty_new_scope(const char* v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_SCOPE_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_scope((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_scope(icalproperty* prop, const char* v){
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_text(v));
+}
+const char* icalproperty_get_scope(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_text(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_sequence(int v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_SEQUENCE_PROPERTY);   
+   icalproperty_set_sequence((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* SEQUENCE */
+icalproperty* icalproperty_new_sequence(int v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_SEQUENCE_PROPERTY);   
+   icalproperty_set_sequence((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_sequence(icalproperty* prop, int v){
+    
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_integer(v));
+}
+int icalproperty_get_sequence(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_integer(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_status(enum icalproperty_status v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_STATUS_PROPERTY);   
+   icalproperty_set_status((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* STATUS */
+icalproperty* icalproperty_new_status(enum icalproperty_status v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_STATUS_PROPERTY);   
+   icalproperty_set_status((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_status(icalproperty* prop, enum icalproperty_status v){
+    
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_status(v));
+}
+enum icalproperty_status icalproperty_get_status(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_status(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_summary(const char* v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_SUMMARY_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_summary((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* SUMMARY */
+icalproperty* icalproperty_new_summary(const char* v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_SUMMARY_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_summary((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_summary(icalproperty* prop, const char* v){
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_text(v));
+}
+const char* icalproperty_get_summary(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_text(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_target(const char* v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TARGET_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_target((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* TARGET */
+icalproperty* icalproperty_new_target(const char* v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TARGET_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_target((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_target(icalproperty* prop, const char* v){
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_caladdress(v));
+}
+const char* icalproperty_get_target(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_caladdress(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_transp(const char* v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TRANSP_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_transp((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* TRANSP */
+icalproperty* icalproperty_new_transp(const char* v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TRANSP_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_transp((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_transp(icalproperty* prop, const char* v){
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_text(v));
+}
+const char* icalproperty_get_transp(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_text(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_trigger(struct icaltriggertype v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TRIGGER_PROPERTY);   
+   icalproperty_set_trigger((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* TRIGGER */
+icalproperty* icalproperty_new_trigger(struct icaltriggertype v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TRIGGER_PROPERTY);   
+   icalproperty_set_trigger((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_trigger(icalproperty* prop, struct icaltriggertype v){
+    
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_trigger(v));
+}
+struct icaltriggertype icalproperty_get_trigger(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_trigger(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_tzid(const char* v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TZID_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_tzid((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* TZID */
+icalproperty* icalproperty_new_tzid(const char* v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TZID_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_tzid((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_tzid(icalproperty* prop, const char* v){
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_text(v));
+}
+const char* icalproperty_get_tzid(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_text(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_tzname(const char* v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TZNAME_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_tzname((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* TZNAME */
+icalproperty* icalproperty_new_tzname(const char* v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TZNAME_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_tzname((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_tzname(icalproperty* prop, const char* v){
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_text(v));
+}
+const char* icalproperty_get_tzname(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_text(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_tzoffsetfrom(int v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TZOFFSETFROM_PROPERTY);   
+   icalproperty_set_tzoffsetfrom((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* TZOFFSETFROM */
+icalproperty* icalproperty_new_tzoffsetfrom(int v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TZOFFSETFROM_PROPERTY);   
+   icalproperty_set_tzoffsetfrom((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_tzoffsetfrom(icalproperty* prop, int v){
+    
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_utcoffset(v));
+}
+int icalproperty_get_tzoffsetfrom(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_utcoffset(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_tzoffsetto(int v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TZOFFSETTO_PROPERTY);   
+   icalproperty_set_tzoffsetto((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* TZOFFSETTO */
+icalproperty* icalproperty_new_tzoffsetto(int v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TZOFFSETTO_PROPERTY);   
+   icalproperty_set_tzoffsetto((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_tzoffsetto(icalproperty* prop, int v){
+    
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_utcoffset(v));
+}
+int icalproperty_get_tzoffsetto(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_utcoffset(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_tzurl(const char* v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TZURL_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_tzurl((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* TZURL */
+icalproperty* icalproperty_new_tzurl(const char* v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TZURL_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_tzurl((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_tzurl(icalproperty* prop, const char* v){
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_uri(v));
+}
+const char* icalproperty_get_tzurl(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_uri(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_uid(const char* v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_UID_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_uid((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* UID */
+icalproperty* icalproperty_new_uid(const char* v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_UID_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_uid((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_uid(icalproperty* prop, const char* v){
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_text(v));
+}
+const char* icalproperty_get_uid(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_text(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_url(const char* v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_URL_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_url((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* URL */
+icalproperty* icalproperty_new_url(const char* v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_URL_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_url((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_url(icalproperty* prop, const char* v){
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_uri(v));
+}
+const char* icalproperty_get_url(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_uri(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_version(const char* v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_VERSION_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_version((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* VERSION */
+icalproperty* icalproperty_new_version(const char* v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_VERSION_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_version((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_version(icalproperty* prop, const char* v){
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_text(v));
+}
+const char* icalproperty_get_version(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_text(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_x(const char* v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_X_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_x((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* X */
+icalproperty* icalproperty_new_x(const char* v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_X_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_x((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_x(icalproperty* prop, const char* v){
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_text(v));
+}
+const char* icalproperty_get_x(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_text(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_xlicclustercount(const char* v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICCLUSTERCOUNT_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_xlicclustercount((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* X-LIC-CLUSTERCOUNT */
+icalproperty* icalproperty_new_xlicclustercount(const char* v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICCLUSTERCOUNT_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_xlicclustercount((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_xlicclustercount(icalproperty* prop, const char* v){
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_string(v));
+}
+const char* icalproperty_get_xlicclustercount(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_string(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_xlicerror(const char* v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICERROR_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_xlicerror((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* X-LIC-ERROR */
+icalproperty* icalproperty_new_xlicerror(const char* v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICERROR_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_xlicerror((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_xlicerror(icalproperty* prop, const char* v){
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_text(v));
+}
+const char* icalproperty_get_xlicerror(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_text(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_xlicmimecharset(const char* v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICMIMECHARSET_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_xlicmimecharset((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* X-LIC-MIMECHARSET */
+icalproperty* icalproperty_new_xlicmimecharset(const char* v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICMIMECHARSET_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_xlicmimecharset((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_xlicmimecharset(icalproperty* prop, const char* v){
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_string(v));
+}
+const char* icalproperty_get_xlicmimecharset(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_string(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_xlicmimecid(const char* v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICMIMECID_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_xlicmimecid((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* X-LIC-MIMECID */
+icalproperty* icalproperty_new_xlicmimecid(const char* v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICMIMECID_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_xlicmimecid((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_xlicmimecid(icalproperty* prop, const char* v){
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_string(v));
+}
+const char* icalproperty_get_xlicmimecid(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_string(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_xlicmimecontenttype(const char* v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICMIMECONTENTTYPE_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_xlicmimecontenttype((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* X-LIC-MIMECONTENTTYPE */
+icalproperty* icalproperty_new_xlicmimecontenttype(const char* v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICMIMECONTENTTYPE_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_xlicmimecontenttype((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_xlicmimecontenttype(icalproperty* prop, const char* v){
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_string(v));
+}
+const char* icalproperty_get_xlicmimecontenttype(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_string(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_xlicmimeencoding(const char* v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICMIMEENCODING_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_xlicmimeencoding((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* X-LIC-MIMEENCODING */
+icalproperty* icalproperty_new_xlicmimeencoding(const char* v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICMIMEENCODING_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_xlicmimeencoding((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_xlicmimeencoding(icalproperty* prop, const char* v){
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_string(v));
+}
+const char* icalproperty_get_xlicmimeencoding(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_string(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_xlicmimefilename(const char* v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICMIMEFILENAME_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_xlicmimefilename((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* X-LIC-MIMEFILENAME */
+icalproperty* icalproperty_new_xlicmimefilename(const char* v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICMIMEFILENAME_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_xlicmimefilename((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_xlicmimefilename(icalproperty* prop, const char* v){
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_string(v));
+}
+const char* icalproperty_get_xlicmimefilename(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_string(icalproperty_get_value(prop));
+}
+icalproperty* icalproperty_vanew_xlicmimeoptinfo(const char* v, ...){
+   va_list args;
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICMIMEOPTINFO_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_xlicmimeoptinfo((icalproperty*)impl,v);
+   va_start(args,v);
+   icalproperty_add_parameters(impl, args);
+   va_end(args);
+   return (icalproperty*)impl;
+}
+/* X-LIC-MIMEOPTINFO */
+icalproperty* icalproperty_new_xlicmimeoptinfo(const char* v) {
+   struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICMIMEOPTINFO_PROPERTY);   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalproperty_set_xlicmimeoptinfo((icalproperty*)impl,v);
+   return (icalproperty*)impl;
+}
+
+void icalproperty_set_xlicmimeoptinfo(icalproperty* prop, const char* v){
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalproperty_set_value(prop,icalvalue_new_string(v));
+}
+const char* icalproperty_get_xlicmimeoptinfo(icalproperty* prop){
+    icalerror_check_arg( (prop!=0),"prop");
+    return icalvalue_get_string(icalproperty_get_value(prop));
+}
diff --git a/libical/src/libical/icalderivedproperty.h b/libical/src/libical/icalderivedproperty.h
new file mode 100644
index 0000000..07e01b0
--- a/dev/null
+++ b/libical/src/libical/icalderivedproperty.h
@@ -0,0 +1,403 @@
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: icalderivedproperties.{c,h}
+  CREATOR: eric 09 May 1999
+  
+  $Id$
+    
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+ ======================================================================*/
+
+
+#ifndef ICALDERIVEDPROPERTY_H
+#define ICALDERIVEDPROPERTY_H
+
+#include <time.h>
+#include "icalparameter.h"
+#include "icalderivedvalue.h"  
+#include "icalrecur.h"
+
+typedef void icalproperty;
+
+
+/* Everything below this line is machine generated. Do not edit. */
+typedef enum icalproperty_kind {
+    ICAL_ANY_PROPERTY = 0,
+    ICAL_ACTION_PROPERTY, 
+    ICAL_ATTACH_PROPERTY, 
+    ICAL_ATTENDEE_PROPERTY, 
+    ICAL_CALSCALE_PROPERTY, 
+    ICAL_CATEGORIES_PROPERTY, 
+    ICAL_CLASS_PROPERTY, 
+    ICAL_COMMENT_PROPERTY, 
+    ICAL_COMPLETED_PROPERTY, 
+    ICAL_CONTACT_PROPERTY, 
+    ICAL_CREATED_PROPERTY, 
+    ICAL_DESCRIPTION_PROPERTY, 
+    ICAL_DTEND_PROPERTY, 
+    ICAL_DTSTAMP_PROPERTY, 
+    ICAL_DTSTART_PROPERTY, 
+    ICAL_DUE_PROPERTY, 
+    ICAL_DURATION_PROPERTY, 
+    ICAL_EXDATE_PROPERTY, 
+    ICAL_EXRULE_PROPERTY, 
+    ICAL_FREEBUSY_PROPERTY, 
+    ICAL_GEO_PROPERTY, 
+    ICAL_LASTMODIFIED_PROPERTY, 
+    ICAL_LOCATION_PROPERTY, 
+    ICAL_MAXRESULTS_PROPERTY, 
+    ICAL_MAXRESULTSSIZE_PROPERTY, 
+    ICAL_METHOD_PROPERTY, 
+    ICAL_ORGANIZER_PROPERTY, 
+    ICAL_PERCENTCOMPLETE_PROPERTY, 
+    ICAL_PRIORITY_PROPERTY, 
+    ICAL_PRODID_PROPERTY, 
+    ICAL_QUERY_PROPERTY, 
+    ICAL_QUERYNAME_PROPERTY, 
+    ICAL_RDATE_PROPERTY, 
+    ICAL_RECURRENCEID_PROPERTY, 
+    ICAL_RELATEDTO_PROPERTY, 
+    ICAL_REPEAT_PROPERTY, 
+    ICAL_REQUESTSTATUS_PROPERTY, 
+    ICAL_RESOURCES_PROPERTY, 
+    ICAL_RRULE_PROPERTY, 
+    ICAL_SCOPE_PROPERTY, 
+    ICAL_SEQUENCE_PROPERTY, 
+    ICAL_STATUS_PROPERTY, 
+    ICAL_SUMMARY_PROPERTY, 
+    ICAL_TARGET_PROPERTY, 
+    ICAL_TRANSP_PROPERTY, 
+    ICAL_TRIGGER_PROPERTY, 
+    ICAL_TZID_PROPERTY, 
+    ICAL_TZNAME_PROPERTY, 
+    ICAL_TZOFFSETFROM_PROPERTY, 
+    ICAL_TZOFFSETTO_PROPERTY, 
+    ICAL_TZURL_PROPERTY, 
+    ICAL_UID_PROPERTY, 
+    ICAL_URL_PROPERTY, 
+    ICAL_VERSION_PROPERTY, 
+    ICAL_X_PROPERTY, 
+    ICAL_XLICCLUSTERCOUNT_PROPERTY, 
+    ICAL_XLICERROR_PROPERTY, 
+    ICAL_XLICMIMECHARSET_PROPERTY, 
+    ICAL_XLICMIMECID_PROPERTY, 
+    ICAL_XLICMIMECONTENTTYPE_PROPERTY, 
+    ICAL_XLICMIMEENCODING_PROPERTY, 
+    ICAL_XLICMIMEFILENAME_PROPERTY, 
+    ICAL_XLICMIMEOPTINFO_PROPERTY, 
+    ICAL_NO_PROPERTY
+} icalproperty_kind;
+
+icalproperty* icalproperty_vanew_action(enum icalproperty_action v, ...);
+
+/* ACTION */
+icalproperty* icalproperty_new_action(enum icalproperty_action v);
+void icalproperty_set_action(icalproperty* prop, enum icalproperty_action v);
+enum icalproperty_action icalproperty_get_action(icalproperty* prop);icalproperty* icalproperty_vanew_attach(struct icalattachtype* v, ...);
+
+/* ATTACH */
+icalproperty* icalproperty_new_attach(struct icalattachtype* v);
+void icalproperty_set_attach(icalproperty* prop, struct icalattachtype* v);
+struct icalattachtype* icalproperty_get_attach(icalproperty* prop);icalproperty* icalproperty_vanew_attendee(const char* v, ...);
+
+/* ATTENDEE */
+icalproperty* icalproperty_new_attendee(const char* v);
+void icalproperty_set_attendee(icalproperty* prop, const char* v);
+const char* icalproperty_get_attendee(icalproperty* prop);icalproperty* icalproperty_vanew_calscale(const char* v, ...);
+
+/* CALSCALE */
+icalproperty* icalproperty_new_calscale(const char* v);
+void icalproperty_set_calscale(icalproperty* prop, const char* v);
+const char* icalproperty_get_calscale(icalproperty* prop);icalproperty* icalproperty_vanew_categories(const char* v, ...);
+
+/* CATEGORIES */
+icalproperty* icalproperty_new_categories(const char* v);
+void icalproperty_set_categories(icalproperty* prop, const char* v);
+const char* icalproperty_get_categories(icalproperty* prop);icalproperty* icalproperty_vanew_class(const char* v, ...);
+
+/* CLASS */
+icalproperty* icalproperty_new_class(const char* v);
+void icalproperty_set_class(icalproperty* prop, const char* v);
+const char* icalproperty_get_class(icalproperty* prop);icalproperty* icalproperty_vanew_comment(const char* v, ...);
+
+/* COMMENT */
+icalproperty* icalproperty_new_comment(const char* v);
+void icalproperty_set_comment(icalproperty* prop, const char* v);
+const char* icalproperty_get_comment(icalproperty* prop);icalproperty* icalproperty_vanew_completed(struct icaltimetype v, ...);
+
+/* COMPLETED */
+icalproperty* icalproperty_new_completed(struct icaltimetype v);
+void icalproperty_set_completed(icalproperty* prop, struct icaltimetype v);
+struct icaltimetype icalproperty_get_completed(icalproperty* prop);icalproperty* icalproperty_vanew_contact(const char* v, ...);
+
+/* CONTACT */
+icalproperty* icalproperty_new_contact(const char* v);
+void icalproperty_set_contact(icalproperty* prop, const char* v);
+const char* icalproperty_get_contact(icalproperty* prop);icalproperty* icalproperty_vanew_created(struct icaltimetype v, ...);
+
+/* CREATED */
+icalproperty* icalproperty_new_created(struct icaltimetype v);
+void icalproperty_set_created(icalproperty* prop, struct icaltimetype v);
+struct icaltimetype icalproperty_get_created(icalproperty* prop);icalproperty* icalproperty_vanew_description(const char* v, ...);
+
+/* DESCRIPTION */
+icalproperty* icalproperty_new_description(const char* v);
+void icalproperty_set_description(icalproperty* prop, const char* v);
+const char* icalproperty_get_description(icalproperty* prop);icalproperty* icalproperty_vanew_dtend(struct icaltimetype v, ...);
+
+/* DTEND */
+icalproperty* icalproperty_new_dtend(struct icaltimetype v);
+void icalproperty_set_dtend(icalproperty* prop, struct icaltimetype v);
+struct icaltimetype icalproperty_get_dtend(icalproperty* prop);icalproperty* icalproperty_vanew_dtstamp(struct icaltimetype v, ...);
+
+/* DTSTAMP */
+icalproperty* icalproperty_new_dtstamp(struct icaltimetype v);
+void icalproperty_set_dtstamp(icalproperty* prop, struct icaltimetype v);
+struct icaltimetype icalproperty_get_dtstamp(icalproperty* prop);icalproperty* icalproperty_vanew_dtstart(struct icaltimetype v, ...);
+
+/* DTSTART */
+icalproperty* icalproperty_new_dtstart(struct icaltimetype v);
+void icalproperty_set_dtstart(icalproperty* prop, struct icaltimetype v);
+struct icaltimetype icalproperty_get_dtstart(icalproperty* prop);icalproperty* icalproperty_vanew_due(struct icaltimetype v, ...);
+
+/* DUE */
+icalproperty* icalproperty_new_due(struct icaltimetype v);
+void icalproperty_set_due(icalproperty* prop, struct icaltimetype v);
+struct icaltimetype icalproperty_get_due(icalproperty* prop);icalproperty* icalproperty_vanew_duration(struct icaldurationtype v, ...);
+
+/* DURATION */
+icalproperty* icalproperty_new_duration(struct icaldurationtype v);
+void icalproperty_set_duration(icalproperty* prop, struct icaldurationtype v);
+struct icaldurationtype icalproperty_get_duration(icalproperty* prop);icalproperty* icalproperty_vanew_exdate(struct icaltimetype v, ...);
+
+/* EXDATE */
+icalproperty* icalproperty_new_exdate(struct icaltimetype v);
+void icalproperty_set_exdate(icalproperty* prop, struct icaltimetype v);
+struct icaltimetype icalproperty_get_exdate(icalproperty* prop);icalproperty* icalproperty_vanew_exrule(struct icalrecurrencetype v, ...);
+
+/* EXRULE */
+icalproperty* icalproperty_new_exrule(struct icalrecurrencetype v);
+void icalproperty_set_exrule(icalproperty* prop, struct icalrecurrencetype v);
+struct icalrecurrencetype icalproperty_get_exrule(icalproperty* prop);icalproperty* icalproperty_vanew_freebusy(struct icalperiodtype v, ...);
+
+/* FREEBUSY */
+icalproperty* icalproperty_new_freebusy(struct icalperiodtype v);
+void icalproperty_set_freebusy(icalproperty* prop, struct icalperiodtype v);
+struct icalperiodtype icalproperty_get_freebusy(icalproperty* prop);icalproperty* icalproperty_vanew_geo(struct icalgeotype v, ...);
+
+/* GEO */
+icalproperty* icalproperty_new_geo(struct icalgeotype v);
+void icalproperty_set_geo(icalproperty* prop, struct icalgeotype v);
+struct icalgeotype icalproperty_get_geo(icalproperty* prop);icalproperty* icalproperty_vanew_lastmodified(struct icaltimetype v, ...);
+
+/* LAST-MODIFIED */
+icalproperty* icalproperty_new_lastmodified(struct icaltimetype v);
+void icalproperty_set_lastmodified(icalproperty* prop, struct icaltimetype v);
+struct icaltimetype icalproperty_get_lastmodified(icalproperty* prop);icalproperty* icalproperty_vanew_location(const char* v, ...);
+
+/* LOCATION */
+icalproperty* icalproperty_new_location(const char* v);
+void icalproperty_set_location(icalproperty* prop, const char* v);
+const char* icalproperty_get_location(icalproperty* prop);icalproperty* icalproperty_vanew_maxresults(int v, ...);
+
+/* MAXRESULTS */
+icalproperty* icalproperty_new_maxresults(int v);
+void icalproperty_set_maxresults(icalproperty* prop, int v);
+int icalproperty_get_maxresults(icalproperty* prop);icalproperty* icalproperty_vanew_maxresultssize(int v, ...);
+
+/* MAXRESULTSSIZE */
+icalproperty* icalproperty_new_maxresultssize(int v);
+void icalproperty_set_maxresultssize(icalproperty* prop, int v);
+int icalproperty_get_maxresultssize(icalproperty* prop);icalproperty* icalproperty_vanew_method(enum icalproperty_method v, ...);
+
+/* METHOD */
+icalproperty* icalproperty_new_method(enum icalproperty_method v);
+void icalproperty_set_method(icalproperty* prop, enum icalproperty_method v);
+enum icalproperty_method icalproperty_get_method(icalproperty* prop);icalproperty* icalproperty_vanew_organizer(const char* v, ...);
+
+/* ORGANIZER */
+icalproperty* icalproperty_new_organizer(const char* v);
+void icalproperty_set_organizer(icalproperty* prop, const char* v);
+const char* icalproperty_get_organizer(icalproperty* prop);icalproperty* icalproperty_vanew_percentcomplete(int v, ...);
+
+/* PERCENT-COMPLETE */
+icalproperty* icalproperty_new_percentcomplete(int v);
+void icalproperty_set_percentcomplete(icalproperty* prop, int v);
+int icalproperty_get_percentcomplete(icalproperty* prop);icalproperty* icalproperty_vanew_priority(int v, ...);
+
+/* PRIORITY */
+icalproperty* icalproperty_new_priority(int v);
+void icalproperty_set_priority(icalproperty* prop, int v);
+int icalproperty_get_priority(icalproperty* prop);icalproperty* icalproperty_vanew_prodid(const char* v, ...);
+
+/* PRODID */
+icalproperty* icalproperty_new_prodid(const char* v);
+void icalproperty_set_prodid(icalproperty* prop, const char* v);
+const char* icalproperty_get_prodid(icalproperty* prop);icalproperty* icalproperty_vanew_query(const char* v, ...);
+
+/* QUERY */
+icalproperty* icalproperty_new_query(const char* v);
+void icalproperty_set_query(icalproperty* prop, const char* v);
+const char* icalproperty_get_query(icalproperty* prop);icalproperty* icalproperty_vanew_queryname(const char* v, ...);
+
+/* QUERYNAME */
+icalproperty* icalproperty_new_queryname(const char* v);
+void icalproperty_set_queryname(icalproperty* prop, const char* v);
+const char* icalproperty_get_queryname(icalproperty* prop);icalproperty* icalproperty_vanew_rdate(struct icaldatetimeperiodtype v, ...);
+
+/* RDATE */
+icalproperty* icalproperty_new_rdate(struct icaldatetimeperiodtype v);
+void icalproperty_set_rdate(icalproperty* prop, struct icaldatetimeperiodtype v);
+struct icaldatetimeperiodtype icalproperty_get_rdate(icalproperty* prop);icalproperty* icalproperty_vanew_recurrenceid(struct icaltimetype v, ...);
+
+/* RECURRENCE-ID */
+icalproperty* icalproperty_new_recurrenceid(struct icaltimetype v);
+void icalproperty_set_recurrenceid(icalproperty* prop, struct icaltimetype v);
+struct icaltimetype icalproperty_get_recurrenceid(icalproperty* prop);icalproperty* icalproperty_vanew_relatedto(const char* v, ...);
+
+/* RELATED-TO */
+icalproperty* icalproperty_new_relatedto(const char* v);
+void icalproperty_set_relatedto(icalproperty* prop, const char* v);
+const char* icalproperty_get_relatedto(icalproperty* prop);icalproperty* icalproperty_vanew_repeat(int v, ...);
+
+/* REPEAT */
+icalproperty* icalproperty_new_repeat(int v);
+void icalproperty_set_repeat(icalproperty* prop, int v);
+int icalproperty_get_repeat(icalproperty* prop);icalproperty* icalproperty_vanew_requeststatus(struct icalreqstattype v, ...);
+
+/* REQUEST-STATUS */
+icalproperty* icalproperty_new_requeststatus(struct icalreqstattype v);
+void icalproperty_set_requeststatus(icalproperty* prop, struct icalreqstattype v);
+struct icalreqstattype icalproperty_get_requeststatus(icalproperty* prop);icalproperty* icalproperty_vanew_resources(const char* v, ...);
+
+/* RESOURCES */
+icalproperty* icalproperty_new_resources(const char* v);
+void icalproperty_set_resources(icalproperty* prop, const char* v);
+const char* icalproperty_get_resources(icalproperty* prop);icalproperty* icalproperty_vanew_rrule(struct icalrecurrencetype v, ...);
+
+/* RRULE */
+icalproperty* icalproperty_new_rrule(struct icalrecurrencetype v);
+void icalproperty_set_rrule(icalproperty* prop, struct icalrecurrencetype v);
+struct icalrecurrencetype icalproperty_get_rrule(icalproperty* prop);icalproperty* icalproperty_vanew_scope(const char* v, ...);
+
+/* SCOPE */
+icalproperty* icalproperty_new_scope(const char* v);
+void icalproperty_set_scope(icalproperty* prop, const char* v);
+const char* icalproperty_get_scope(icalproperty* prop);icalproperty* icalproperty_vanew_sequence(int v, ...);
+
+/* SEQUENCE */
+icalproperty* icalproperty_new_sequence(int v);
+void icalproperty_set_sequence(icalproperty* prop, int v);
+int icalproperty_get_sequence(icalproperty* prop);icalproperty* icalproperty_vanew_status(enum icalproperty_status v, ...);
+
+/* STATUS */
+icalproperty* icalproperty_new_status(enum icalproperty_status v);
+void icalproperty_set_status(icalproperty* prop, enum icalproperty_status v);
+enum icalproperty_status icalproperty_get_status(icalproperty* prop);icalproperty* icalproperty_vanew_summary(const char* v, ...);
+
+/* SUMMARY */
+icalproperty* icalproperty_new_summary(const char* v);
+void icalproperty_set_summary(icalproperty* prop, const char* v);
+const char* icalproperty_get_summary(icalproperty* prop);icalproperty* icalproperty_vanew_target(const char* v, ...);
+
+/* TARGET */
+icalproperty* icalproperty_new_target(const char* v);
+void icalproperty_set_target(icalproperty* prop, const char* v);
+const char* icalproperty_get_target(icalproperty* prop);icalproperty* icalproperty_vanew_transp(const char* v, ...);
+
+/* TRANSP */
+icalproperty* icalproperty_new_transp(const char* v);
+void icalproperty_set_transp(icalproperty* prop, const char* v);
+const char* icalproperty_get_transp(icalproperty* prop);icalproperty* icalproperty_vanew_trigger(struct icaltriggertype v, ...);
+
+/* TRIGGER */
+icalproperty* icalproperty_new_trigger(struct icaltriggertype v);
+void icalproperty_set_trigger(icalproperty* prop, struct icaltriggertype v);
+struct icaltriggertype icalproperty_get_trigger(icalproperty* prop);icalproperty* icalproperty_vanew_tzid(const char* v, ...);
+
+/* TZID */
+icalproperty* icalproperty_new_tzid(const char* v);
+void icalproperty_set_tzid(icalproperty* prop, const char* v);
+const char* icalproperty_get_tzid(icalproperty* prop);icalproperty* icalproperty_vanew_tzname(const char* v, ...);
+
+/* TZNAME */
+icalproperty* icalproperty_new_tzname(const char* v);
+void icalproperty_set_tzname(icalproperty* prop, const char* v);
+const char* icalproperty_get_tzname(icalproperty* prop);icalproperty* icalproperty_vanew_tzoffsetfrom(int v, ...);
+
+/* TZOFFSETFROM */
+icalproperty* icalproperty_new_tzoffsetfrom(int v);
+void icalproperty_set_tzoffsetfrom(icalproperty* prop, int v);
+int icalproperty_get_tzoffsetfrom(icalproperty* prop);icalproperty* icalproperty_vanew_tzoffsetto(int v, ...);
+
+/* TZOFFSETTO */
+icalproperty* icalproperty_new_tzoffsetto(int v);
+void icalproperty_set_tzoffsetto(icalproperty* prop, int v);
+int icalproperty_get_tzoffsetto(icalproperty* prop);icalproperty* icalproperty_vanew_tzurl(const char* v, ...);
+
+/* TZURL */
+icalproperty* icalproperty_new_tzurl(const char* v);
+void icalproperty_set_tzurl(icalproperty* prop, const char* v);
+const char* icalproperty_get_tzurl(icalproperty* prop);icalproperty* icalproperty_vanew_uid(const char* v, ...);
+
+/* UID */
+icalproperty* icalproperty_new_uid(const char* v);
+void icalproperty_set_uid(icalproperty* prop, const char* v);
+const char* icalproperty_get_uid(icalproperty* prop);icalproperty* icalproperty_vanew_url(const char* v, ...);
+
+/* URL */
+icalproperty* icalproperty_new_url(const char* v);
+void icalproperty_set_url(icalproperty* prop, const char* v);
+const char* icalproperty_get_url(icalproperty* prop);icalproperty* icalproperty_vanew_version(const char* v, ...);
+
+/* VERSION */
+icalproperty* icalproperty_new_version(const char* v);
+void icalproperty_set_version(icalproperty* prop, const char* v);
+const char* icalproperty_get_version(icalproperty* prop);icalproperty* icalproperty_vanew_x(const char* v, ...);
+
+/* X */
+icalproperty* icalproperty_new_x(const char* v);
+void icalproperty_set_x(icalproperty* prop, const char* v);
+const char* icalproperty_get_x(icalproperty* prop);icalproperty* icalproperty_vanew_xlicclustercount(const char* v, ...);
+
+/* X-LIC-CLUSTERCOUNT */
+icalproperty* icalproperty_new_xlicclustercount(const char* v);
+void icalproperty_set_xlicclustercount(icalproperty* prop, const char* v);
+const char* icalproperty_get_xlicclustercount(icalproperty* prop);icalproperty* icalproperty_vanew_xlicerror(const char* v, ...);
+
+/* X-LIC-ERROR */
+icalproperty* icalproperty_new_xlicerror(const char* v);
+void icalproperty_set_xlicerror(icalproperty* prop, const char* v);
+const char* icalproperty_get_xlicerror(icalproperty* prop);icalproperty* icalproperty_vanew_xlicmimecharset(const char* v, ...);
+
+/* X-LIC-MIMECHARSET */
+icalproperty* icalproperty_new_xlicmimecharset(const char* v);
+void icalproperty_set_xlicmimecharset(icalproperty* prop, const char* v);
+const char* icalproperty_get_xlicmimecharset(icalproperty* prop);icalproperty* icalproperty_vanew_xlicmimecid(const char* v, ...);
+
+/* X-LIC-MIMECID */
+icalproperty* icalproperty_new_xlicmimecid(const char* v);
+void icalproperty_set_xlicmimecid(icalproperty* prop, const char* v);
+const char* icalproperty_get_xlicmimecid(icalproperty* prop);icalproperty* icalproperty_vanew_xlicmimecontenttype(const char* v, ...);
+
+/* X-LIC-MIMECONTENTTYPE */
+icalproperty* icalproperty_new_xlicmimecontenttype(const char* v);
+void icalproperty_set_xlicmimecontenttype(icalproperty* prop, const char* v);
+const char* icalproperty_get_xlicmimecontenttype(icalproperty* prop);icalproperty* icalproperty_vanew_xlicmimeencoding(const char* v, ...);
+
+/* X-LIC-MIMEENCODING */
+icalproperty* icalproperty_new_xlicmimeencoding(const char* v);
+void icalproperty_set_xlicmimeencoding(icalproperty* prop, const char* v);
+const char* icalproperty_get_xlicmimeencoding(icalproperty* prop);icalproperty* icalproperty_vanew_xlicmimefilename(const char* v, ...);
+
+/* X-LIC-MIMEFILENAME */
+icalproperty* icalproperty_new_xlicmimefilename(const char* v);
+void icalproperty_set_xlicmimefilename(icalproperty* prop, const char* v);
+const char* icalproperty_get_xlicmimefilename(icalproperty* prop);icalproperty* icalproperty_vanew_xlicmimeoptinfo(const char* v, ...);
+
+/* X-LIC-MIMEOPTINFO */
+icalproperty* icalproperty_new_xlicmimeoptinfo(const char* v);
+void icalproperty_set_xlicmimeoptinfo(icalproperty* prop, const char* v);
+const char* icalproperty_get_xlicmimeoptinfo(icalproperty* prop);
+
+#endif /*ICALPROPERTY_H*/
diff --git a/libical/src/libical/icalderivedvalue.c b/libical/src/libical/icalderivedvalue.c
new file mode 100644
index 0000000..db762ea
--- a/dev/null
+++ b/libical/src/libical/icalderivedvalue.c
@@ -0,0 +1,981 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+  FILE: icalvalue.c
+  CREATOR: eric 02 May 1999
+  
+  $Id$
+
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalvalue.c
+
+  Contributions from:
+     Graham Davison (g.m.davison@computer.org)
+
+
+======================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "icalerror.h"
+#include "icalmemory.h"
+#include "icalparser.h"
+#include "icalenums.h"
+
+#include "icalvalueimpl.h"
+
+#include <stdlib.h> /* for malloc */
+#include <stdio.h> /* for sprintf */
+#include <string.h> /* For memset, others */
+#include <stddef.h> /* For offsetof() macro */
+#include <errno.h>
+#include <time.h> /* for mktime */
+#include <stdlib.h> /* for atoi and atof */
+#include <limits.h> /* for SHRT_MAX */         
+
+
+
+#define TMP_BUF_SIZE 1024
+
+struct icalvalue_impl*  icalvalue_new_impl(icalvalue_kind kind);
+
+/* This map associates each of the value types with its string
+   representation */
+struct icalvalue_kind_map {
+        icalvalue_kind kind;
+        char name[20];
+};
+
+extern struct icalvalue_kind_map value_map[]; 
+
+const char* icalvalue_kind_to_string(icalvalue_kind kind)
+{
+    int i;
+
+    for (i=0; value_map[i].kind != ICAL_NO_VALUE; i++) {
+        if (value_map[i].kind == kind) {
+            return value_map[i].name;
+        }
+    }
+
+    return 0;
+}
+
+icalvalue_kind icalvalue_string_to_kind(const char* str)
+{
+    int i;
+
+    for (i=0; value_map[i].kind != ICAL_NO_VALUE; i++) {
+        if (strcmp(value_map[i].name,str) == 0) {
+            return value_map[i].kind;
+        }
+    }
+
+    return  value_map[i].kind;
+
+}
+
+icalvalue* icalvalue_new_x (const char* v){
+   struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_X_VALUE);
+   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalvalue_set_x((icalvalue*)impl,v);
+   return (icalvalue*)impl;
+}
+void icalvalue_set_x(icalvalue* value, const char* v) {
+    struct icalvalue_impl* impl; 
+    icalerror_check_arg_rv( (value!=0),"value");
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    impl = (struct icalvalue_impl*)value;
+    if(impl->x_value!=0) {free((void*)impl->x_value);}
+
+    impl->x_value = icalmemory_strdup(v);
+
+    if (impl->x_value == 0){
+      errno = ENOMEM;
+    }
+ 
+ }
+const char* icalvalue_get_x(icalvalue* value) {
+
+    icalerror_check_arg( (value!=0),"value");
+    icalerror_check_value_type(value, ICAL_X_VALUE);
+    return ((struct icalvalue_impl*)value)->x_value;
+}
+
+/* Attachment is a special case, so it is not auto generated. */
+icalvalue*
+icalvalue_new_attach (struct icalattachtype *v)
+{
+   struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_ATTACH_VALUE);
+    
+   icalvalue_set_attach((icalvalue*)impl,v);
+
+   return (icalvalue*)impl;
+}
+
+void
+icalvalue_set_attach(icalvalue* value, struct icalattachtype *v)
+{
+    struct icalvalue_impl* impl; 
+    
+    icalerror_check_arg_rv( (value!=0),"value");
+    icalerror_check_value_type(value, ICAL_ATTACH_VALUE);
+
+    impl = (struct icalvalue_impl*)value;
+
+    if (impl->data.v_attach != 0){
+        icalattachtype_free(impl->data.v_attach);
+    }
+
+    impl->data.v_attach = v;
+    icalattachtype_add_reference(v);
+}
+
+struct icalattachtype*
+icalvalue_get_attach(icalvalue* value)
+{
+    icalerror_check_arg( (value!=0),"value");
+    icalerror_check_value_type(value, ICAL_ATTACH_VALUE);
+  
+    return ((struct icalvalue_impl*)value)->data.v_attach;
+}
+
+
+/* Recur is a special case, so it is not auto generated. */
+icalvalue*
+icalvalue_new_recur (struct icalrecurrencetype v)
+{
+   struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_RECUR_VALUE);
+    
+   icalvalue_set_recur((icalvalue*)impl,v);
+
+   return (icalvalue*)impl;
+}
+
+void
+icalvalue_set_recur(icalvalue* value, struct icalrecurrencetype v)
+{
+    struct icalvalue_impl* impl; 
+    
+    icalerror_check_arg_rv( (value!=0),"value");
+    icalerror_check_value_type(value, ICAL_RECUR_VALUE);
+
+    impl = (struct icalvalue_impl*)value;
+
+    if (impl->data.v_recur != 0){
+        free(impl->data.v_recur);
+        impl->data.v_recur = 0;
+    }
+
+    impl->data.v_recur = malloc(sizeof(struct icalrecurrencetype));
+
+    if (impl->data.v_recur == 0){
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        return;
+    } else {
+        memcpy(impl->data.v_recur, &v, sizeof(struct icalrecurrencetype));
+    }
+               
+}
+
+struct icalrecurrencetype
+icalvalue_get_recur(icalvalue* value)
+{
+    icalerror_check_arg( (value!=0),"value");
+    icalerror_check_value_type(value, ICAL_RECUR_VALUE);
+  
+    return *(((struct icalvalue_impl*)value)->data.v_recur);
+}
+
+
+
+
+icalvalue*
+icalvalue_new_trigger (struct icaltriggertype v)
+{
+   struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_TRIGGER_VALUE);
+ 
+   icalvalue_set_trigger((icalvalue*)impl,v);
+
+   return (icalvalue*)impl;
+}
+
+void
+icalvalue_set_trigger(icalvalue* value, struct icaltriggertype v)
+{
+    struct icalvalue_impl* impl; 
+    
+    icalerror_check_arg_rv( (value!=0),"value");
+    
+    impl = (struct icalvalue_impl*)value;
+
+   if(!icaltime_is_null_time(v.time)){
+       icalvalue_set_datetime((icalvalue*)impl,v.time);
+       impl->kind = ICAL_DATETIME_VALUE;
+   } else {
+       icalvalue_set_duration((icalvalue*)impl,v.duration);
+       impl->kind = ICAL_DURATION_VALUE;
+   }
+
+}
+
+struct icaltriggertype
+icalvalue_get_trigger(icalvalue* value)
+{
+    struct icalvalue_impl *impl = (struct icalvalue_impl*)value;
+    struct icaltriggertype tr;
+
+    icalerror_check_arg( (value!=0),"value");
+    icalerror_check_arg( (value!=0),"value");
+
+    if(impl->kind == ICAL_DATETIME_VALUE){
+         tr.duration = icaldurationtype_from_int(0);
+         tr.time = impl->data.v_time;
+    } else if(impl->kind == ICAL_DURATION_VALUE){
+        tr.time = icaltime_null_time();
+        tr.duration = impl->data.v_duration;
+    } else {
+        tr.duration = icaldurationtype_from_int(0);
+        tr.time = icaltime_null_time();
+        icalerror_set_errno(ICAL_BADARG_ERROR);
+    }
+
+    return tr;
+}
+
+/* DATE-TIME-PERIOD is a special case, and is not auto generated */
+
+icalvalue*
+icalvalue_new_datetimeperiod (struct icaldatetimeperiodtype v)
+{
+   struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_DATETIMEPERIOD_VALUE);
+
+   icalvalue_set_datetimeperiod((icalvalue*)impl,v);
+
+   return (icalvalue*)impl;
+}
+
+void
+icalvalue_set_datetimeperiod(icalvalue* value, struct icaldatetimeperiodtype v)
+{
+    struct icalvalue_impl* impl = (struct icalvalue_impl*)value;
+    
+    icalerror_check_arg_rv( (value!=0),"value");
+    
+    icalerror_check_value_type(value, ICAL_DATETIMEPERIOD_VALUE);
+
+    if(!icaltime_is_null_time(v.time)){
+        if(!icaltime_is_valid_time(v.time)){
+            icalerror_set_errno(ICAL_BADARG_ERROR);
+            return;
+        }
+        impl->kind = ICAL_DATETIME_VALUE;
+        icalvalue_set_datetime(impl,v.time);
+    } else if (!icalperiodtype_is_null_period(v.period)) {
+        if(!icalperiodtype_is_valid_period(v.period)){
+            icalerror_set_errno(ICAL_BADARG_ERROR);
+            return;
+        }
+        impl->kind = ICAL_PERIOD_VALUE;
+        icalvalue_set_period(impl,v.period);
+    } else {
+        icalerror_set_errno(ICAL_BADARG_ERROR);
+    }
+}
+
+struct icaldatetimeperiodtype
+icalvalue_get_datetimeperiod(icalvalue* value)
+{
+  struct icaldatetimeperiodtype dtp;
+  
+  struct icalvalue_impl* impl = (struct icalvalue_impl*)value;
+  icalerror_check_arg( (value!=0),"value");
+  icalerror_check_value_type(value, ICAL_DATETIMEPERIOD_VALUE);
+  
+  if(impl->kind == ICAL_DATETIME_VALUE){
+      dtp.period = icalperiodtype_null_period();
+      dtp.time = impl->data.v_time;
+  } else if(impl->kind == ICAL_PERIOD_VALUE) {
+      dtp.period = impl->data.v_period;
+      dtp.time = icaltime_null_time();
+  } else {
+      dtp.period = icalperiodtype_null_period();
+      dtp.time = icaltime_null_time();
+      icalerror_set_errno(ICAL_BADARG_ERROR);
+          }
+
+  return dtp;
+}
+
+
+
+
+
+
+
+
+
+/* The remaining interfaces are 'new', 'set' and 'get' for each of the value
+   types */
+
+
+/* Everything below this line is machine generated. Do not edit. */
+static struct icalvalue_kind_map value_map[]={
+    {ICAL_QUERY_VALUE,"QUERY"},
+    {ICAL_TRIGGER_VALUE,"TRIGGER"},
+    {ICAL_STATUS_VALUE,"STATUS"},
+    {ICAL_TRANSP_VALUE,"TRANSP"},
+    {ICAL_CLASS_VALUE,"CLASS"},
+    {ICAL_DATE_VALUE,"DATE"},
+    {ICAL_STRING_VALUE,"STRING"},
+    {ICAL_INTEGER_VALUE,"INTEGER"},
+    {ICAL_PERIOD_VALUE,"PERIOD"},
+    {ICAL_TEXT_VALUE,"TEXT"},
+    {ICAL_DURATION_VALUE,"DURATION"},
+    {ICAL_BOOLEAN_VALUE,"BOOLEAN"},
+    {ICAL_URI_VALUE,"URI"},
+    {ICAL_DATETIMEPERIOD_VALUE,"DATE-TIME-PERIOD"},
+    {ICAL_GEO_VALUE,"GEO"},
+    {ICAL_DATETIME_VALUE,"DATE-TIME"},
+    {ICAL_UTCOFFSET_VALUE,"UTC-OFFSET"},
+    {ICAL_ATTACH_VALUE,"ATTACH"},
+    {ICAL_ACTION_VALUE,"ACTION"},
+    {ICAL_CALADDRESS_VALUE,"CAL-ADDRESS"},
+    {ICAL_X_VALUE,"X"},
+    {ICAL_FLOAT_VALUE,"FLOAT"},
+    {ICAL_REQUESTSTATUS_VALUE,"REQUEST-STATUS"},
+    {ICAL_METHOD_VALUE,"METHOD"},
+    {ICAL_BINARY_VALUE,"BINARY"},
+    {ICAL_RECUR_VALUE,"RECUR"},
+    {ICAL_NO_VALUE,""}
+};
+
+
+icalvalue* icalvalue_new_query (const char* v){
+   struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_QUERY_VALUE);
+   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalvalue_set_query((icalvalue*)impl,v);
+   return (icalvalue*)impl;
+}
+void icalvalue_set_query(icalvalue* value, const char* v) {
+    struct icalvalue_impl* impl; 
+    icalerror_check_arg_rv( (value!=0),"value");
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    icalerror_check_value_type(value, ICAL_QUERY_VALUE);
+    impl = (struct icalvalue_impl*)value;
+    if(impl->data.v_string!=0) {free((void*)impl->data.v_string);}
+
+
+    impl->data.v_string = icalmemory_strdup(v);
+
+    if (impl->data.v_string == 0){
+      errno = ENOMEM;
+    }
+ 
+
+    icalvalue_reset_kind(impl);
+}
+const char* icalvalue_get_query(icalvalue* value) {
+
+    icalerror_check_arg( (value!=0),"value");
+    icalerror_check_value_type(value, ICAL_QUERY_VALUE);
+    return ((struct icalvalue_impl*)value)->data.v_string;
+}
+
+
+
+icalvalue* icalvalue_new_status (enum icalproperty_status v){
+   struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_STATUS_VALUE);
+   
+   icalvalue_set_status((icalvalue*)impl,v);
+   return (icalvalue*)impl;
+}
+void icalvalue_set_status(icalvalue* value, enum icalproperty_status v) {
+    struct icalvalue_impl* impl; 
+    icalerror_check_arg_rv( (value!=0),"value");
+    
+    icalerror_check_value_type(value, ICAL_STATUS_VALUE);
+    impl = (struct icalvalue_impl*)value;
+
+
+    impl->data.v_enum = v; 
+
+    icalvalue_reset_kind(impl);
+}
+enum icalproperty_status icalvalue_get_status(icalvalue* value) {
+
+    icalerror_check_arg( (value!=0),"value");
+    icalerror_check_value_type(value, ICAL_STATUS_VALUE);
+    return ((struct icalvalue_impl*)value)->data.v_enum;
+}
+
+
+
+icalvalue* icalvalue_new_transp (enum icalproperty_transp v){
+   struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_TRANSP_VALUE);
+   
+   icalvalue_set_transp((icalvalue*)impl,v);
+   return (icalvalue*)impl;
+}
+void icalvalue_set_transp(icalvalue* value, enum icalproperty_transp v) {
+    struct icalvalue_impl* impl; 
+    icalerror_check_arg_rv( (value!=0),"value");
+    
+    icalerror_check_value_type(value, ICAL_TRANSP_VALUE);
+    impl = (struct icalvalue_impl*)value;
+
+
+    impl->data.v_enum = v; 
+
+    icalvalue_reset_kind(impl);
+}
+enum icalproperty_transp icalvalue_get_transp(icalvalue* value) {
+
+    icalerror_check_arg( (value!=0),"value");
+    icalerror_check_value_type(value, ICAL_TRANSP_VALUE);
+    return ((struct icalvalue_impl*)value)->data.v_enum;
+}
+
+
+
+icalvalue* icalvalue_new_class (enum icalproperty_class v){
+   struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_CLASS_VALUE);
+   
+   icalvalue_set_class((icalvalue*)impl,v);
+   return (icalvalue*)impl;
+}
+void icalvalue_set_class(icalvalue* value, enum icalproperty_class v) {
+    struct icalvalue_impl* impl; 
+    icalerror_check_arg_rv( (value!=0),"value");
+    
+    icalerror_check_value_type(value, ICAL_CLASS_VALUE);
+    impl = (struct icalvalue_impl*)value;
+
+
+    impl->data.v_enum = v; 
+
+    icalvalue_reset_kind(impl);
+}
+enum icalproperty_class icalvalue_get_class(icalvalue* value) {
+
+    icalerror_check_arg( (value!=0),"value");
+    icalerror_check_value_type(value, ICAL_CLASS_VALUE);
+    return ((struct icalvalue_impl*)value)->data.v_enum;
+}
+
+
+
+icalvalue* icalvalue_new_date (struct icaltimetype v){
+   struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_DATE_VALUE);
+   
+   icalvalue_set_date((icalvalue*)impl,v);
+   return (icalvalue*)impl;
+}
+void icalvalue_set_date(icalvalue* value, struct icaltimetype v) {
+    struct icalvalue_impl* impl; 
+    icalerror_check_arg_rv( (value!=0),"value");
+    
+    icalerror_check_value_type(value, ICAL_DATE_VALUE);
+    impl = (struct icalvalue_impl*)value;
+
+
+    impl->data.v_time = v; 
+
+    icalvalue_reset_kind(impl);
+}
+struct icaltimetype icalvalue_get_date(icalvalue* value) {
+
+    icalerror_check_arg( (value!=0),"value");
+    icalerror_check_value_type(value, ICAL_DATE_VALUE);
+    return ((struct icalvalue_impl*)value)->data.v_time;
+}
+
+
+
+icalvalue* icalvalue_new_string (const char* v){
+   struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_STRING_VALUE);
+   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalvalue_set_string((icalvalue*)impl,v);
+   return (icalvalue*)impl;
+}
+void icalvalue_set_string(icalvalue* value, const char* v) {
+    struct icalvalue_impl* impl; 
+    icalerror_check_arg_rv( (value!=0),"value");
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    icalerror_check_value_type(value, ICAL_STRING_VALUE);
+    impl = (struct icalvalue_impl*)value;
+    if(impl->data.v_string!=0) {free((void*)impl->data.v_string);}
+
+
+    impl->data.v_string = icalmemory_strdup(v);
+
+    if (impl->data.v_string == 0){
+      errno = ENOMEM;
+    }
+ 
+
+    icalvalue_reset_kind(impl);
+}
+const char* icalvalue_get_string(icalvalue* value) {
+
+    icalerror_check_arg( (value!=0),"value");
+    icalerror_check_value_type(value, ICAL_STRING_VALUE);
+    return ((struct icalvalue_impl*)value)->data.v_string;
+}
+
+
+
+icalvalue* icalvalue_new_integer (int v){
+   struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_INTEGER_VALUE);
+   
+   icalvalue_set_integer((icalvalue*)impl,v);
+   return (icalvalue*)impl;
+}
+void icalvalue_set_integer(icalvalue* value, int v) {
+    struct icalvalue_impl* impl; 
+    icalerror_check_arg_rv( (value!=0),"value");
+    
+    icalerror_check_value_type(value, ICAL_INTEGER_VALUE);
+    impl = (struct icalvalue_impl*)value;
+
+
+    impl->data.v_int = v; 
+
+    icalvalue_reset_kind(impl);
+}
+int icalvalue_get_integer(icalvalue* value) {
+
+    icalerror_check_arg( (value!=0),"value");
+    icalerror_check_value_type(value, ICAL_INTEGER_VALUE);
+    return ((struct icalvalue_impl*)value)->data.v_int;
+}
+
+
+
+icalvalue* icalvalue_new_period (struct icalperiodtype v){
+   struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_PERIOD_VALUE);
+   
+   icalvalue_set_period((icalvalue*)impl,v);
+   return (icalvalue*)impl;
+}
+void icalvalue_set_period(icalvalue* value, struct icalperiodtype v) {
+    struct icalvalue_impl* impl; 
+    icalerror_check_arg_rv( (value!=0),"value");
+    
+    icalerror_check_value_type(value, ICAL_PERIOD_VALUE);
+    impl = (struct icalvalue_impl*)value;
+
+
+    impl->data.v_period = v; 
+
+    icalvalue_reset_kind(impl);
+}
+struct icalperiodtype icalvalue_get_period(icalvalue* value) {
+
+    icalerror_check_arg( (value!=0),"value");
+    icalerror_check_value_type(value, ICAL_PERIOD_VALUE);
+    return ((struct icalvalue_impl*)value)->data.v_period;
+}
+
+
+
+icalvalue* icalvalue_new_text (const char* v){
+   struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_TEXT_VALUE);
+   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalvalue_set_text((icalvalue*)impl,v);
+   return (icalvalue*)impl;
+}
+void icalvalue_set_text(icalvalue* value, const char* v) {
+    struct icalvalue_impl* impl; 
+    icalerror_check_arg_rv( (value!=0),"value");
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    icalerror_check_value_type(value, ICAL_TEXT_VALUE);
+    impl = (struct icalvalue_impl*)value;
+    if(impl->data.v_string!=0) {free((void*)impl->data.v_string);}
+
+
+    impl->data.v_string = icalmemory_strdup(v);
+
+    if (impl->data.v_string == 0){
+      errno = ENOMEM;
+    }
+ 
+
+    icalvalue_reset_kind(impl);
+}
+const char* icalvalue_get_text(icalvalue* value) {
+
+    icalerror_check_arg( (value!=0),"value");
+    icalerror_check_value_type(value, ICAL_TEXT_VALUE);
+    return ((struct icalvalue_impl*)value)->data.v_string;
+}
+
+
+
+icalvalue* icalvalue_new_duration (struct icaldurationtype v){
+   struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_DURATION_VALUE);
+   
+   icalvalue_set_duration((icalvalue*)impl,v);
+   return (icalvalue*)impl;
+}
+void icalvalue_set_duration(icalvalue* value, struct icaldurationtype v) {
+    struct icalvalue_impl* impl; 
+    icalerror_check_arg_rv( (value!=0),"value");
+    
+    icalerror_check_value_type(value, ICAL_DURATION_VALUE);
+    impl = (struct icalvalue_impl*)value;
+
+
+    impl->data.v_duration = v; 
+
+    icalvalue_reset_kind(impl);
+}
+struct icaldurationtype icalvalue_get_duration(icalvalue* value) {
+
+    icalerror_check_arg( (value!=0),"value");
+    icalerror_check_value_type(value, ICAL_DURATION_VALUE);
+    return ((struct icalvalue_impl*)value)->data.v_duration;
+}
+
+
+
+icalvalue* icalvalue_new_boolean (int v){
+   struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_BOOLEAN_VALUE);
+   
+   icalvalue_set_boolean((icalvalue*)impl,v);
+   return (icalvalue*)impl;
+}
+void icalvalue_set_boolean(icalvalue* value, int v) {
+    struct icalvalue_impl* impl; 
+    icalerror_check_arg_rv( (value!=0),"value");
+    
+    icalerror_check_value_type(value, ICAL_BOOLEAN_VALUE);
+    impl = (struct icalvalue_impl*)value;
+
+
+    impl->data.v_int = v; 
+
+    icalvalue_reset_kind(impl);
+}
+int icalvalue_get_boolean(icalvalue* value) {
+
+    icalerror_check_arg( (value!=0),"value");
+    icalerror_check_value_type(value, ICAL_BOOLEAN_VALUE);
+    return ((struct icalvalue_impl*)value)->data.v_int;
+}
+
+
+
+icalvalue* icalvalue_new_uri (const char* v){
+   struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_URI_VALUE);
+   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalvalue_set_uri((icalvalue*)impl,v);
+   return (icalvalue*)impl;
+}
+void icalvalue_set_uri(icalvalue* value, const char* v) {
+    struct icalvalue_impl* impl; 
+    icalerror_check_arg_rv( (value!=0),"value");
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    icalerror_check_value_type(value, ICAL_URI_VALUE);
+    impl = (struct icalvalue_impl*)value;
+    if(impl->data.v_string!=0) {free((void*)impl->data.v_string);}
+
+
+    impl->data.v_string = icalmemory_strdup(v);
+
+    if (impl->data.v_string == 0){
+      errno = ENOMEM;
+    }
+ 
+
+    icalvalue_reset_kind(impl);
+}
+const char* icalvalue_get_uri(icalvalue* value) {
+
+    icalerror_check_arg( (value!=0),"value");
+    icalerror_check_value_type(value, ICAL_URI_VALUE);
+    return ((struct icalvalue_impl*)value)->data.v_string;
+}
+
+
+
+icalvalue* icalvalue_new_geo (struct icalgeotype v){
+   struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_GEO_VALUE);
+   
+   icalvalue_set_geo((icalvalue*)impl,v);
+   return (icalvalue*)impl;
+}
+void icalvalue_set_geo(icalvalue* value, struct icalgeotype v) {
+    struct icalvalue_impl* impl; 
+    icalerror_check_arg_rv( (value!=0),"value");
+    
+    icalerror_check_value_type(value, ICAL_GEO_VALUE);
+    impl = (struct icalvalue_impl*)value;
+
+
+    impl->data.v_geo = v; 
+
+    icalvalue_reset_kind(impl);
+}
+struct icalgeotype icalvalue_get_geo(icalvalue* value) {
+
+    icalerror_check_arg( (value!=0),"value");
+    icalerror_check_value_type(value, ICAL_GEO_VALUE);
+    return ((struct icalvalue_impl*)value)->data.v_geo;
+}
+
+
+
+icalvalue* icalvalue_new_datetime (struct icaltimetype v){
+   struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_DATETIME_VALUE);
+   
+   icalvalue_set_datetime((icalvalue*)impl,v);
+   return (icalvalue*)impl;
+}
+void icalvalue_set_datetime(icalvalue* value, struct icaltimetype v) {
+    struct icalvalue_impl* impl; 
+    icalerror_check_arg_rv( (value!=0),"value");
+    
+    icalerror_check_value_type(value, ICAL_DATETIME_VALUE);
+    impl = (struct icalvalue_impl*)value;
+
+
+    impl->data.v_time = v; 
+
+    icalvalue_reset_kind(impl);
+}
+struct icaltimetype icalvalue_get_datetime(icalvalue* value) {
+
+    icalerror_check_arg( (value!=0),"value");
+    icalerror_check_value_type(value, ICAL_DATETIME_VALUE);
+    return ((struct icalvalue_impl*)value)->data.v_time;
+}
+
+
+
+icalvalue* icalvalue_new_utcoffset (int v){
+   struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_UTCOFFSET_VALUE);
+   
+   icalvalue_set_utcoffset((icalvalue*)impl,v);
+   return (icalvalue*)impl;
+}
+void icalvalue_set_utcoffset(icalvalue* value, int v) {
+    struct icalvalue_impl* impl; 
+    icalerror_check_arg_rv( (value!=0),"value");
+    
+    icalerror_check_value_type(value, ICAL_UTCOFFSET_VALUE);
+    impl = (struct icalvalue_impl*)value;
+
+
+    impl->data.v_int = v; 
+
+    icalvalue_reset_kind(impl);
+}
+int icalvalue_get_utcoffset(icalvalue* value) {
+
+    icalerror_check_arg( (value!=0),"value");
+    icalerror_check_value_type(value, ICAL_UTCOFFSET_VALUE);
+    return ((struct icalvalue_impl*)value)->data.v_int;
+}
+
+
+
+icalvalue* icalvalue_new_action (enum icalproperty_action v){
+   struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_ACTION_VALUE);
+   
+   icalvalue_set_action((icalvalue*)impl,v);
+   return (icalvalue*)impl;
+}
+void icalvalue_set_action(icalvalue* value, enum icalproperty_action v) {
+    struct icalvalue_impl* impl; 
+    icalerror_check_arg_rv( (value!=0),"value");
+    
+    icalerror_check_value_type(value, ICAL_ACTION_VALUE);
+    impl = (struct icalvalue_impl*)value;
+
+
+    impl->data.v_enum = v; 
+
+    icalvalue_reset_kind(impl);
+}
+enum icalproperty_action icalvalue_get_action(icalvalue* value) {
+
+    icalerror_check_arg( (value!=0),"value");
+    icalerror_check_value_type(value, ICAL_ACTION_VALUE);
+    return ((struct icalvalue_impl*)value)->data.v_enum;
+}
+
+
+
+icalvalue* icalvalue_new_caladdress (const char* v){
+   struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_CALADDRESS_VALUE);
+   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalvalue_set_caladdress((icalvalue*)impl,v);
+   return (icalvalue*)impl;
+}
+void icalvalue_set_caladdress(icalvalue* value, const char* v) {
+    struct icalvalue_impl* impl; 
+    icalerror_check_arg_rv( (value!=0),"value");
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    icalerror_check_value_type(value, ICAL_CALADDRESS_VALUE);
+    impl = (struct icalvalue_impl*)value;
+    if(impl->data.v_string!=0) {free((void*)impl->data.v_string);}
+
+
+    impl->data.v_string = icalmemory_strdup(v);
+
+    if (impl->data.v_string == 0){
+      errno = ENOMEM;
+    }
+ 
+
+    icalvalue_reset_kind(impl);
+}
+const char* icalvalue_get_caladdress(icalvalue* value) {
+
+    icalerror_check_arg( (value!=0),"value");
+    icalerror_check_value_type(value, ICAL_CALADDRESS_VALUE);
+    return ((struct icalvalue_impl*)value)->data.v_string;
+}
+
+
+
+icalvalue* icalvalue_new_float (float v){
+   struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_FLOAT_VALUE);
+   
+   icalvalue_set_float((icalvalue*)impl,v);
+   return (icalvalue*)impl;
+}
+void icalvalue_set_float(icalvalue* value, float v) {
+    struct icalvalue_impl* impl; 
+    icalerror_check_arg_rv( (value!=0),"value");
+    
+    icalerror_check_value_type(value, ICAL_FLOAT_VALUE);
+    impl = (struct icalvalue_impl*)value;
+
+
+    impl->data.v_float = v; 
+
+    icalvalue_reset_kind(impl);
+}
+float icalvalue_get_float(icalvalue* value) {
+
+    icalerror_check_arg( (value!=0),"value");
+    icalerror_check_value_type(value, ICAL_FLOAT_VALUE);
+    return ((struct icalvalue_impl*)value)->data.v_float;
+}
+
+
+
+icalvalue* icalvalue_new_requeststatus (struct icalreqstattype v){
+   struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_REQUESTSTATUS_VALUE);
+   
+   icalvalue_set_requeststatus((icalvalue*)impl,v);
+   return (icalvalue*)impl;
+}
+void icalvalue_set_requeststatus(icalvalue* value, struct icalreqstattype v) {
+    struct icalvalue_impl* impl; 
+    icalerror_check_arg_rv( (value!=0),"value");
+    
+    icalerror_check_value_type(value, ICAL_REQUESTSTATUS_VALUE);
+    impl = (struct icalvalue_impl*)value;
+
+
+    impl->data.v_requeststatus = v; 
+
+    icalvalue_reset_kind(impl);
+}
+struct icalreqstattype icalvalue_get_requeststatus(icalvalue* value) {
+
+    icalerror_check_arg( (value!=0),"value");
+    icalerror_check_value_type(value, ICAL_REQUESTSTATUS_VALUE);
+    return ((struct icalvalue_impl*)value)->data.v_requeststatus;
+}
+
+
+
+icalvalue* icalvalue_new_method (enum icalproperty_method v){
+   struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_METHOD_VALUE);
+   
+   icalvalue_set_method((icalvalue*)impl,v);
+   return (icalvalue*)impl;
+}
+void icalvalue_set_method(icalvalue* value, enum icalproperty_method v) {
+    struct icalvalue_impl* impl; 
+    icalerror_check_arg_rv( (value!=0),"value");
+    
+    icalerror_check_value_type(value, ICAL_METHOD_VALUE);
+    impl = (struct icalvalue_impl*)value;
+
+
+    impl->data.v_enum = v; 
+
+    icalvalue_reset_kind(impl);
+}
+enum icalproperty_method icalvalue_get_method(icalvalue* value) {
+
+    icalerror_check_arg( (value!=0),"value");
+    icalerror_check_value_type(value, ICAL_METHOD_VALUE);
+    return ((struct icalvalue_impl*)value)->data.v_enum;
+}
+
+
+
+icalvalue* icalvalue_new_binary (const char* v){
+   struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_BINARY_VALUE);
+   icalerror_check_arg_rz( (v!=0),"v");
+
+   icalvalue_set_binary((icalvalue*)impl,v);
+   return (icalvalue*)impl;
+}
+void icalvalue_set_binary(icalvalue* value, const char* v) {
+    struct icalvalue_impl* impl; 
+    icalerror_check_arg_rv( (value!=0),"value");
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    icalerror_check_value_type(value, ICAL_BINARY_VALUE);
+    impl = (struct icalvalue_impl*)value;
+    if(impl->data.v_string!=0) {free((void*)impl->data.v_string);}
+
+
+    impl->data.v_string = icalmemory_strdup(v);
+
+    if (impl->data.v_string == 0){
+      errno = ENOMEM;
+    }
+ 
+
+    icalvalue_reset_kind(impl);
+}
+const char* icalvalue_get_binary(icalvalue* value) {
+
+    icalerror_check_arg( (value!=0),"value");
+    icalerror_check_value_type(value, ICAL_BINARY_VALUE);
+    return ((struct icalvalue_impl*)value)->data.v_string;
+}
diff --git a/libical/src/libical/icalderivedvalue.h b/libical/src/libical/icalderivedvalue.h
new file mode 100644
index 0000000..8324f04
--- a/dev/null
+++ b/libical/src/libical/icalderivedvalue.h
@@ -0,0 +1,283 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+  FILE: icalvalue.h
+  CREATOR: eric 20 March 1999
+
+
+  $Id$
+  $Locker$
+
+  
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalvalue.h
+
+  ======================================================================*/
+
+#ifndef ICALDERIVEDVALUE_H
+#define ICALDERIVEDVALUE_H
+
+#include "icaltypes.h"
+#include "icalrecur.h"
+#include "icaltime.h"
+#include "icalduration.h"
+#include "icalperiod.h"
+     
+typedef void icalvalue;
+
+
+
+void icalvalue_set_x(icalvalue* value, const char* v);
+icalvalue* icalvalue_new_x(const char* v);
+const char* icalvalue_get_x(icalvalue* value);
+
+icalvalue* icalvalue_new_attach (struct icalattachtype* v);
+void icalvalue_set_attach(icalvalue* value, struct icalattachtype* v);
+struct icalattachtype* icalvalue_get_attach(icalvalue* value);
+
+icalvalue* icalvalue_new_recur (struct icalrecurrencetype v);
+void icalvalue_set_recur(icalvalue* value, struct icalrecurrencetype v);
+struct icalrecurrencetype icalvalue_get_recur(icalvalue* value);
+
+icalvalue* icalvalue_new_trigger (struct icaltriggertype v);
+void icalvalue_set_trigger(icalvalue* value, struct icaltriggertype v);
+struct icaltriggertype icalvalue_get_trigger(icalvalue* value);
+
+icalvalue* icalvalue_new_datetimeperiod (struct icaldatetimeperiodtype v);
+void icalvalue_set_datetimeperiod(icalvalue* value, struct icaldatetimeperiodtype v);
+struct icaldatetimeperiodtype icalvalue_get_datetimeperiod(icalvalue* value);
+
+void icalvalue_reset_kind(icalvalue* value);
+
+/* Everything below this line is machine generated. Do not edit. */
+typedef enum icalvalue_kind {
+   ICAL_ANY_VALUE=5000,
+    ICAL_QUERY_VALUE=5001,
+    ICAL_TRIGGER_VALUE=5002,
+    ICAL_STATUS_VALUE=5003,
+    ICAL_TRANSP_VALUE=5004,
+    ICAL_CLASS_VALUE=5005,
+    ICAL_DATE_VALUE=5006,
+    ICAL_STRING_VALUE=5007,
+    ICAL_INTEGER_VALUE=5008,
+    ICAL_PERIOD_VALUE=5009,
+    ICAL_TEXT_VALUE=5010,
+    ICAL_DURATION_VALUE=5011,
+    ICAL_BOOLEAN_VALUE=5012,
+    ICAL_URI_VALUE=5013,
+    ICAL_DATETIMEPERIOD_VALUE=5014,
+    ICAL_GEO_VALUE=5015,
+    ICAL_DATETIME_VALUE=5016,
+    ICAL_UTCOFFSET_VALUE=5017,
+    ICAL_ATTACH_VALUE=5018,
+    ICAL_ACTION_VALUE=5019,
+    ICAL_CALADDRESS_VALUE=5020,
+    ICAL_X_VALUE=5021,
+    ICAL_FLOAT_VALUE=5022,
+    ICAL_REQUESTSTATUS_VALUE=5023,
+    ICAL_METHOD_VALUE=5024,
+    ICAL_BINARY_VALUE=5025,
+    ICAL_RECUR_VALUE=5026,
+   ICAL_NO_VALUE=5027
+} icalvalue_kind ;
+
+#define ICALPROPERTY_FIRST_ENUM 10000
+
+typedef enum icalproperty_action {
+    ICAL_ACTION_X = 10000,
+    ICAL_ACTION_AUDIO = 10001,
+    ICAL_ACTION_DISPLAY = 10002,
+    ICAL_ACTION_EMAIL = 10003,
+    ICAL_ACTION_PROCEDURE = 10004,
+    ICAL_ACTION_NONE = 10005
+} icalproperty_action;
+
+typedef enum icalproperty_class {
+    ICAL_CLASS_X = 10006,
+    ICAL_CLASS_PUBLIC = 10007,
+    ICAL_CLASS_PRIVATE = 10008,
+    ICAL_CLASS_CONFIDENTIAL = 10009,
+    ICAL_CLASS_NONE = 10010
+} icalproperty_class;
+
+typedef enum icalproperty_method {
+    ICAL_METHOD_X = 10011,
+    ICAL_METHOD_PUBLISH = 10012,
+    ICAL_METHOD_REQUEST = 10013,
+    ICAL_METHOD_REPLY = 10014,
+    ICAL_METHOD_ADD = 10015,
+    ICAL_METHOD_CANCEL = 10016,
+    ICAL_METHOD_REFRESH = 10017,
+    ICAL_METHOD_COUNTER = 10018,
+    ICAL_METHOD_DECLINECOUNTER = 10019,
+    ICAL_METHOD_CREATE = 10020,
+    ICAL_METHOD_READ = 10021,
+    ICAL_METHOD_RESPONSE = 10022,
+    ICAL_METHOD_MOVE = 10023,
+    ICAL_METHOD_MODIFY = 10024,
+    ICAL_METHOD_GENERATEUID = 10025,
+    ICAL_METHOD_DELETE = 10026,
+    ICAL_METHOD_NONE = 10027
+} icalproperty_method;
+
+typedef enum icalproperty_status {
+    ICAL_STATUS_X = 10028,
+    ICAL_STATUS_TENTATIVE = 10029,
+    ICAL_STATUS_CONFIRMED = 10030,
+    ICAL_STATUS_COMPLETED = 10031,
+    ICAL_STATUS_NEEDSACTION = 10032,
+    ICAL_STATUS_CANCELLED = 10033,
+    ICAL_STATUS_INPROCESS = 10034,
+    ICAL_STATUS_DRAFT = 10035,
+    ICAL_STATUS_FINAL = 10036,
+    ICAL_STATUS_NONE = 10037
+} icalproperty_status;
+
+typedef enum icalproperty_transp {
+    ICAL_TRANSP_X = 10038,
+    ICAL_TRANSP_OPAQUE = 10039,
+    ICAL_TRANSP_TRANSPARENT = 10040,
+    ICAL_TRANSP_NONE = 10041
+} icalproperty_transp;
+
+#define ICALPROPERTY_LAST_ENUM 10042
+
+
+ /* QUERY */ 
+icalvalue* icalvalue_new_query(const char* v); 
+const char* icalvalue_get_query(icalvalue* value); 
+void icalvalue_set_query(icalvalue* value, const char* v);
+
+
+ /* STATUS */ 
+icalvalue* icalvalue_new_status(enum icalproperty_status v); 
+enum icalproperty_status icalvalue_get_status(icalvalue* value); 
+void icalvalue_set_status(icalvalue* value, enum icalproperty_status v);
+
+
+ /* TRANSP */ 
+icalvalue* icalvalue_new_transp(enum icalproperty_transp v); 
+enum icalproperty_transp icalvalue_get_transp(icalvalue* value); 
+void icalvalue_set_transp(icalvalue* value, enum icalproperty_transp v);
+
+
+ /* CLASS */ 
+icalvalue* icalvalue_new_class(enum icalproperty_class v); 
+enum icalproperty_class icalvalue_get_class(icalvalue* value); 
+void icalvalue_set_class(icalvalue* value, enum icalproperty_class v);
+
+
+ /* DATE */ 
+icalvalue* icalvalue_new_date(struct icaltimetype v); 
+struct icaltimetype icalvalue_get_date(icalvalue* value); 
+void icalvalue_set_date(icalvalue* value, struct icaltimetype v);
+
+
+ /* STRING */ 
+icalvalue* icalvalue_new_string(const char* v); 
+const char* icalvalue_get_string(icalvalue* value); 
+void icalvalue_set_string(icalvalue* value, const char* v);
+
+
+ /* INTEGER */ 
+icalvalue* icalvalue_new_integer(int v); 
+int icalvalue_get_integer(icalvalue* value); 
+void icalvalue_set_integer(icalvalue* value, int v);
+
+
+ /* PERIOD */ 
+icalvalue* icalvalue_new_period(struct icalperiodtype v); 
+struct icalperiodtype icalvalue_get_period(icalvalue* value); 
+void icalvalue_set_period(icalvalue* value, struct icalperiodtype v);
+
+
+ /* TEXT */ 
+icalvalue* icalvalue_new_text(const char* v); 
+const char* icalvalue_get_text(icalvalue* value); 
+void icalvalue_set_text(icalvalue* value, const char* v);
+
+
+ /* DURATION */ 
+icalvalue* icalvalue_new_duration(struct icaldurationtype v); 
+struct icaldurationtype icalvalue_get_duration(icalvalue* value); 
+void icalvalue_set_duration(icalvalue* value, struct icaldurationtype v);
+
+
+ /* BOOLEAN */ 
+icalvalue* icalvalue_new_boolean(int v); 
+int icalvalue_get_boolean(icalvalue* value); 
+void icalvalue_set_boolean(icalvalue* value, int v);
+
+
+ /* URI */ 
+icalvalue* icalvalue_new_uri(const char* v); 
+const char* icalvalue_get_uri(icalvalue* value); 
+void icalvalue_set_uri(icalvalue* value, const char* v);
+
+
+ /* GEO */ 
+icalvalue* icalvalue_new_geo(struct icalgeotype v); 
+struct icalgeotype icalvalue_get_geo(icalvalue* value); 
+void icalvalue_set_geo(icalvalue* value, struct icalgeotype v);
+
+
+ /* DATE-TIME */ 
+icalvalue* icalvalue_new_datetime(struct icaltimetype v); 
+struct icaltimetype icalvalue_get_datetime(icalvalue* value); 
+void icalvalue_set_datetime(icalvalue* value, struct icaltimetype v);
+
+
+ /* UTC-OFFSET */ 
+icalvalue* icalvalue_new_utcoffset(int v); 
+int icalvalue_get_utcoffset(icalvalue* value); 
+void icalvalue_set_utcoffset(icalvalue* value, int v);
+
+
+ /* ACTION */ 
+icalvalue* icalvalue_new_action(enum icalproperty_action v); 
+enum icalproperty_action icalvalue_get_action(icalvalue* value); 
+void icalvalue_set_action(icalvalue* value, enum icalproperty_action v);
+
+
+ /* CAL-ADDRESS */ 
+icalvalue* icalvalue_new_caladdress(const char* v); 
+const char* icalvalue_get_caladdress(icalvalue* value); 
+void icalvalue_set_caladdress(icalvalue* value, const char* v);
+
+
+ /* FLOAT */ 
+icalvalue* icalvalue_new_float(float v); 
+float icalvalue_get_float(icalvalue* value); 
+void icalvalue_set_float(icalvalue* value, float v);
+
+
+ /* REQUEST-STATUS */ 
+icalvalue* icalvalue_new_requeststatus(struct icalreqstattype v); 
+struct icalreqstattype icalvalue_get_requeststatus(icalvalue* value); 
+void icalvalue_set_requeststatus(icalvalue* value, struct icalreqstattype v);
+
+
+ /* METHOD */ 
+icalvalue* icalvalue_new_method(enum icalproperty_method v); 
+enum icalproperty_method icalvalue_get_method(icalvalue* value); 
+void icalvalue_set_method(icalvalue* value, enum icalproperty_method v);
+
+
+ /* BINARY */ 
+icalvalue* icalvalue_new_binary(const char* v); 
+const char* icalvalue_get_binary(icalvalue* value); 
+void icalvalue_set_binary(icalvalue* value, const char* v);
+
+#endif /*ICALVALUE_H*/
diff --git a/libical/src/libical/icalduration.c b/libical/src/libical/icalduration.c
new file mode 100644
index 0000000..4468e0f
--- a/dev/null
+++ b/libical/src/libical/icalduration.c
@@ -0,0 +1,323 @@
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: icaltime.c
+  CREATOR: eric 02 June 2000
+  
+  $Id$
+  $Locker$
+    
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+ ======================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "icalduration.h"
+
+#include <assert.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#ifdef ICAL_NO_LIBICAL
+#define icalerror_set_errno(x)
+#define  icalerror_check_arg_rv(x,y)
+#define  icalerror_check_arg_re(x,y,z)
+#else
+#include "icalerror.h"
+#include "icalmemory.h"
+#endif
+
+
+
+
+/* From Seth Alves,  <alves@hungry.com>   */
+struct icaldurationtype icaldurationtype_from_int(int t)
+{
+        struct icaldurationtype dur;
+        int used = 0;
+
+        dur = icaldurationtype_null_duration();
+
+        if(t < 0){
+            dur.is_neg = 1;
+            t = -t;
+        }
+
+        if (t % (60 * 60 * 24 * 7) == 0) {
+            dur.weeks = t / (60 * 60 * 24 * 7);
+        } else {
+            used += dur.weeks * (60 * 60 * 24 * 7);
+            dur.days = (t - used) / (60 * 60 * 24);
+            used += dur.days * (60 * 60 * 24);
+            dur.hours = (t - used) / (60 * 60);
+            used += dur.hours * (60 * 60);
+            dur.minutes = (t - used) / (60);
+            used += dur.minutes * (60);
+            dur.seconds = (t - used);
+        }
+ 
+        return dur;
+}
+
+#ifndef ICAL_NO_LIBICAL
+#include "icalvalue.h"
+struct icaldurationtype icaldurationtype_from_string(const char* str)
+{
+
+    int i;
+    int begin_flag = 0;
+    int time_flag = 0;
+    int date_flag = 0;
+    int week_flag = 0;
+    int digits=-1;
+    int scan_size = -1;
+    int size = strlen(str);
+    char p;
+    struct icaldurationtype d;
+
+    memset(&d, 0, sizeof(struct icaldurationtype));
+
+    for(i=0;i != size;i++){
+        p = str[i];
+        
+        switch(p) 
+            {
+            case '-': {
+                if(i != 0 || begin_flag == 1) goto error;
+
+                d.is_neg = 1;
+                break;
+            }
+
+            case 'P': {
+                if (i != 0 && i !=1 ) goto error;
+                begin_flag = 1;
+                break;
+            }
+
+            case 'T': {
+                time_flag = 1;
+                break;
+            }
+
+            case '0':
+            case '1':
+            case '2':
+            case '3':
+            case '4':
+            case '5':
+            case '6':
+            case '7':
+            case '8':
+            case '9':
+                { 
+                    
+                    /* HACK. Skip any more digits if the l;ast one
+                       read has not been assigned */
+                    if(digits != -1){
+                        break;
+                    }
+
+                    if (begin_flag == 0) goto error;
+                    /* Get all of the digits, not one at a time */
+                    scan_size = sscanf((char*)(str+i),"%d",&digits);
+                    if(scan_size == 0) goto error;
+                    break;
+                }
+
+                    case 'H': {
+                if (time_flag == 0||week_flag == 1||d.hours !=0||digits ==-1) 
+                    goto error;
+                d.hours = digits; digits = -1;
+                break;
+            }
+            case 'M': {
+                if (time_flag == 0||week_flag==1||d.minutes != 0||digits ==-1) 
+                    goto error;
+                        d.minutes = digits; digits = -1;    
+                break;
+            }
+            case 'S': {
+                if (time_flag == 0||week_flag==1||d.seconds!=0||digits ==-1) 
+                    goto error;
+                        d.seconds = digits; digits = -1;    
+                break;
+            }
+            case 'W': {
+                if (time_flag==1||date_flag==1||d.weeks!=0||digits ==-1) 
+                    goto error;
+                        week_flag = 1;
+                        d.weeks = digits; digits = -1;    
+                break;
+            }
+            case 'D': {
+                if (time_flag==1||week_flag==1||d.days!=0||digits ==-1) 
+                    goto error;
+                date_flag = 1;
+                        d.days = digits; digits = -1;    
+                break;
+            }
+            default: {
+                goto error;
+            }
+
+            }
+    }
+
+    return d;
+        
+
+ error:
+    icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+    memset(&d, 0, sizeof(struct icaldurationtype));
+    return d;
+
+}
+
+#define TMP_BUF_SIZE 1024
+void append_duration_segment(char** buf, char** buf_ptr, size_t* buf_size, 
+                             char* sep, unsigned int value) {
+
+    char temp[TMP_BUF_SIZE];
+
+    sprintf(temp,"%d",value);
+
+    icalmemory_append_string(buf, buf_ptr, buf_size, temp);
+    icalmemory_append_string(buf, buf_ptr, buf_size, sep);
+    
+}
+
+char* icaldurationtype_as_ical_string(struct icaldurationtype d) 
+{
+
+    char *buf, *output_line;
+    size_t buf_size = 256;
+    char* buf_ptr = 0;
+    int seconds;
+
+    buf = (char*)icalmemory_new_buffer(buf_size);
+    buf_ptr = buf;
+    
+
+    seconds = icaldurationtype_as_int(d);
+
+    if(seconds !=0){
+        
+        if(d.is_neg == 1){
+            icalmemory_append_char(&buf, &buf_ptr, &buf_size, '-'); 
+        }
+
+        icalmemory_append_char(&buf, &buf_ptr, &buf_size, 'P');
+    
+        if (d.weeks != 0 ) {
+            append_duration_segment(&buf, &buf_ptr, &buf_size, "W", d.weeks);
+        }
+        
+        if (d.days != 0 ) {
+            append_duration_segment(&buf, &buf_ptr, &buf_size, "D", d.days);
+        }
+        
+        if (d.hours != 0 || d.minutes != 0 || d.seconds != 0) {
+            
+            icalmemory_append_string(&buf, &buf_ptr, &buf_size, "T");
+            
+            if (d.hours != 0 ) {
+                append_duration_segment(&buf, &buf_ptr, &buf_size, "H", d.hours);
+            }
+            if (d.minutes != 0 ) {
+                append_duration_segment(&buf, &buf_ptr, &buf_size, "M", 
+                                        d.minutes);
+            }
+            if (d.seconds != 0 ) {
+                append_duration_segment(&buf, &buf_ptr, &buf_size, "S", 
+                                        d.seconds);
+            }
+            
+        }
+    } else {
+        icalmemory_append_string(&buf, &buf_ptr, &buf_size, "PTS0");
+    }
+ 
+    output_line = icalmemory_tmp_copy(buf);
+    icalmemory_free_buffer(buf);
+
+    return output_line;
+    
+}
+
+#endif
+
+
+/* From Russel Steinthal */
+int icaldurationtype_as_int(struct icaldurationtype dur)
+{
+    return (int)( (dur.seconds +
+                   (60 * dur.minutes) +
+                   (60 * 60 * dur.hours) +
+                   (60 * 60 * 24 * dur.days) +
+                   (60 * 60 * 24 * 7 * dur.weeks))
+                  * (dur.is_neg==1? -1 : 1) ) ;
+} 
+
+struct icaldurationtype icaldurationtype_null_duration()
+{
+    struct icaldurationtype d;
+    
+    memset(&d,0,sizeof(struct icaldurationtype));
+    
+    return d;
+}
+
+int icaldurationtype_is_null_duration(struct icaldurationtype d)
+{
+    if(icaldurationtype_as_int(d) == 0){
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+
+
+struct icaltimetype  icaltime_add(struct icaltimetype t,
+                                  struct icaldurationtype  d)
+{
+    int dt = icaldurationtype_as_int(d);
+    
+    t.second += dt;
+    
+    t = icaltime_normalize(t);
+    
+    return t;
+}
+
+struct icaldurationtype  icaltime_subtract(struct icaltimetype t1,
+                                           struct icaltimetype t2)
+{
+
+    time_t t1t = icaltime_as_timet(t1);
+    time_t t2t = icaltime_as_timet(t2);
+
+    return icaldurationtype_from_int(t1t-t2t);
+
+
+}
+
diff --git a/libical/src/libical/icalduration.h b/libical/src/libical/icalduration.h
new file mode 100644
index 0000000..dd6e311
--- a/dev/null
+++ b/libical/src/libical/icalduration.h
@@ -0,0 +1,60 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalduration.h
+ CREATOR: eric 26 Jan 2001
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+======================================================================*/
+
+#ifndef ICALDURATION_H
+#define ICALDURATION_H
+
+#include "icaltime.h"
+
+struct icaldurationtype
+{
+        int is_neg;
+        unsigned int days;
+        unsigned int weeks;
+        unsigned int hours;
+        unsigned int minutes;
+        unsigned int seconds;
+};
+
+struct icaldurationtype icaldurationtype_from_int(int t);
+struct icaldurationtype icaldurationtype_from_string(const char*);
+int icaldurationtype_as_int(struct icaldurationtype duration);
+char* icaldurationtype_as_ical_string(struct icaldurationtype d);
+struct icaldurationtype icaldurationtype_null_duration();
+int icaldurationtype_is_null_duration(struct icaldurationtype d);
+
+struct icaltimetype  icaltime_add(struct icaltimetype t,
+                                  struct icaldurationtype  d);
+
+struct icaldurationtype  icaltime_subtract(struct icaltimetype t1,
+                                           struct icaltimetype t2);
+
+#endif /* !ICALDURATION_H */
+
+
+
diff --git a/libical/src/libical/icalenums.c b/libical/src/libical/icalenums.c
new file mode 100644
index 0000000..6751933
--- a/dev/null
+++ b/libical/src/libical/icalenums.c
@@ -0,0 +1,135 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+  FILE: icalenum.c
+  CREATOR: eric 29 April 1999
+  
+  $Id$
+
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalenum.c
+
+  ======================================================================*/
+
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "icalenums.h"
+
+#include <stdio.h> /* For fprintf */
+#include <stdio.h> /* For stderr */
+#include <string.h> /* For strncmp */
+#include <assert.h>
+
+
+
+struct {
+         enum icalrequeststatus kind;
+        int major;
+        int minor;
+        const char* str;
+} request_status_map[] = {
+    {ICAL_2_0_SUCCESS_STATUS, 2,0,"Success."},
+    {ICAL_2_1_FALLBACK_STATUS, 2,1,"Success but fallback taken  on one or more property  values."},
+    {ICAL_2_2_IGPROP_STATUS, 2,2,"Success, invalid property ignored."},
+    {ICAL_2_3_IGPARAM_STATUS, 2,3,"Success, invalid property parameter ignored."},
+    {ICAL_2_4_IGXPROP_STATUS, 2,4,"Success, unknown non-standard property ignored."},
+    {ICAL_2_5_IGXPARAM_STATUS, 2,5,"Success, unknown non standard property value  ignored."},
+    {ICAL_2_6_IGCOMP_STATUS, 2,6,"Success, invalid calendar component ignored."},
+    {ICAL_2_7_FORWARD_STATUS, 2,7,"Success, request forwarded to Calendar User."},
+    {ICAL_2_8_ONEEVENT_STATUS, 2,8,"Success, repeating event ignored. Scheduled as a  single component."},
+    {ICAL_2_9_TRUNC_STATUS, 2,9,"Success, truncated end date time to date boundary."},
+    {ICAL_2_10_ONETODO_STATUS, 2,10,"Success, repeating VTODO ignored. Scheduled as a  single VTODO."},
+    {ICAL_2_11_TRUNCRRULE_STATUS, 2,11,"Success, unbounded RRULE clipped at some finite  number of instances  "},
+    {ICAL_3_0_INVPROPNAME_STATUS, 3,0,"Invalid property name."},
+    {ICAL_3_1_INVPROPVAL_STATUS, 3,1,"Invalid property value."},
+    {ICAL_3_2_INVPARAM_STATUS, 3,2,"Invalid property parameter."},
+    {ICAL_3_3_INVPARAMVAL_STATUS, 3,3,"Invalid property parameter  value."},
+    {ICAL_3_4_INVCOMP_STATUS, 3,4,"Invalid calendar component."},
+    {ICAL_3_5_INVTIME_STATUS, 3,5,"Invalid date or time."},
+    {ICAL_3_6_INVRULE_STATUS, 3,6,"Invalid rule."},
+    {ICAL_3_7_INVCU_STATUS, 3,7,"Invalid Calendar User."},
+    {ICAL_3_8_NOAUTH_STATUS, 3,8,"No authority."},
+    {ICAL_3_9_BADVERSION_STATUS, 3,9,"Unsupported version."},
+    {ICAL_3_10_TOOBIG_STATUS, 3,10,"Request entity too large."},
+    {ICAL_3_11_MISSREQCOMP_STATUS, 3,11,"Required component or property missing."},
+    {ICAL_3_12_UNKCOMP_STATUS, 3,12,"Unknown component or property found."},
+    {ICAL_3_13_BADCOMP_STATUS, 3,13,"Unsupported component or property found"},
+    {ICAL_3_14_NOCAP_STATUS, 3,14,"Unsupported capability."},
+    {ICAL_4_0_BUSY_STATUS, 4,0,"Event conflict. Date/time  is busy."},
+    {ICAL_5_0_MAYBE_STATUS, 5,0,"Request MAY supported."},
+    {ICAL_5_1_UNAVAIL_STATUS, 5,1,"Service unavailable."},
+    {ICAL_5_2_NOSERVICE_STATUS, 5,2,"Invalid calendar service."},
+    {ICAL_5_3_NOSCHED_STATUS, 5,3,"No scheduling support for  user."},
+    {ICAL_UNKNOWN_STATUS, 0,0,"Error: Unknown request status"}
+};
+
+
+const char* icalenum_reqstat_desc(icalrequeststatus stat)
+{
+
+    int i;
+
+    for (i=0; request_status_map[i].kind  != ICAL_UNKNOWN_STATUS; i++) {
+        if ( request_status_map[i].kind ==  stat) {
+            return request_status_map[i].str;
+        }
+    }
+
+    return 0;
+}
+
+
+short icalenum_reqstat_major(icalrequeststatus stat)
+{
+    int i;
+
+    for (i=0; request_status_map[i].kind  != ICAL_UNKNOWN_STATUS; i++) {
+        if ( request_status_map[i].kind ==  stat) {
+            return request_status_map[i].major;
+        }
+    }
+    return -1;
+}
+
+short icalenum_reqstat_minor(icalrequeststatus stat)
+{
+    int i;
+
+    for (i=0; request_status_map[i].kind  != ICAL_UNKNOWN_STATUS; i++) {
+        if ( request_status_map[i].kind ==  stat) {
+            return request_status_map[i].minor;
+        }
+    }
+    return -1;
+}
+
+
+icalrequeststatus icalenum_num_to_reqstat(short major, short minor)
+{
+    int i;
+
+    for (i=0; request_status_map[i].kind  != ICAL_UNKNOWN_STATUS; i++) {
+        if ( request_status_map[i].major ==  major && request_status_map[i].minor ==  minor) {
+            return request_status_map[i].kind;
+        }
+    }
+    return 0;
+}
+
+
+
diff --git a/libical/src/libical/icalenums.h b/libical/src/libical/icalenums.h
new file mode 100644
index 0000000..21031dd
--- a/dev/null
+++ b/libical/src/libical/icalenums.h
@@ -0,0 +1,157 @@
+
+/* -*- Mode: C -*-*/
+/*======================================================================
+ FILE: icalenums.h
+
+ 
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalenums.h
+
+  Contributions from:
+     Graham Davison (g.m.davison@computer.org)
+
+======================================================================*/
+
+#ifndef ICALENUMS_H
+#define ICALENUMS_H
+
+
+
+/***********************************************************************
+ * Component enumerations
+**********************************************************************/
+
+typedef enum icalcomponent_kind {
+    ICAL_NO_COMPONENT,
+            ICAL_ANY_COMPONENT,/* Used to select all components*/
+    ICAL_XROOT_COMPONENT,
+    ICAL_XATTACH_COMPONENT, /* MIME attached data, returned by parser. */
+    ICAL_VEVENT_COMPONENT,
+    ICAL_VTODO_COMPONENT,
+    ICAL_VJOURNAL_COMPONENT,
+    ICAL_VCALENDAR_COMPONENT,
+    ICAL_VFREEBUSY_COMPONENT,
+    ICAL_VALARM_COMPONENT,
+    ICAL_XAUDIOALARM_COMPONENT,  
+    ICAL_XDISPLAYALARM_COMPONENT,
+    ICAL_XEMAILALARM_COMPONENT,
+    ICAL_XPROCEDUREALARM_COMPONENT,
+    ICAL_VTIMEZONE_COMPONENT,
+    ICAL_XSTANDARD_COMPONENT,
+    ICAL_XDAYLIGHT_COMPONENT,
+    ICAL_X_COMPONENT,
+    ICAL_VSCHEDULE_COMPONENT,
+    ICAL_VQUERY_COMPONENT,
+    ICAL_VCAR_COMPONENT,
+    ICAL_VCOMMAND_COMPONENT,
+    ICAL_XLICINVALID_COMPONENT,
+    ICAL_XLICMIMEPART_COMPONENT /* a non-stardard component that mirrors
+                                structure of MIME data */
+
+} icalcomponent_kind;
+
+
+
+/***********************************************************************
+ * Request Status codes
+ **********************************************************************/
+
+typedef enum icalrequeststatus {
+    ICAL_UNKNOWN_STATUS,
+    ICAL_2_0_SUCCESS_STATUS,
+    ICAL_2_1_FALLBACK_STATUS,
+    ICAL_2_2_IGPROP_STATUS,
+    ICAL_2_3_IGPARAM_STATUS,
+    ICAL_2_4_IGXPROP_STATUS,
+    ICAL_2_5_IGXPARAM_STATUS,
+    ICAL_2_6_IGCOMP_STATUS,
+    ICAL_2_7_FORWARD_STATUS,
+    ICAL_2_8_ONEEVENT_STATUS,
+    ICAL_2_9_TRUNC_STATUS,
+    ICAL_2_10_ONETODO_STATUS,
+    ICAL_2_11_TRUNCRRULE_STATUS,
+    ICAL_3_0_INVPROPNAME_STATUS,
+    ICAL_3_1_INVPROPVAL_STATUS,
+    ICAL_3_2_INVPARAM_STATUS,
+    ICAL_3_3_INVPARAMVAL_STATUS,
+    ICAL_3_4_INVCOMP_STATUS,
+    ICAL_3_5_INVTIME_STATUS,
+    ICAL_3_6_INVRULE_STATUS,
+    ICAL_3_7_INVCU_STATUS,
+    ICAL_3_8_NOAUTH_STATUS,
+    ICAL_3_9_BADVERSION_STATUS,
+    ICAL_3_10_TOOBIG_STATUS,
+    ICAL_3_11_MISSREQCOMP_STATUS,
+    ICAL_3_12_UNKCOMP_STATUS,
+    ICAL_3_13_BADCOMP_STATUS,
+    ICAL_3_14_NOCAP_STATUS,
+    ICAL_4_0_BUSY_STATUS,
+    ICAL_5_0_MAYBE_STATUS,
+    ICAL_5_1_UNAVAIL_STATUS,
+    ICAL_5_2_NOSERVICE_STATUS,
+    ICAL_5_3_NOSCHED_STATUS
+} icalrequeststatus;
+
+
+const char* icalenum_reqstat_desc(icalrequeststatus stat);
+short icalenum_reqstat_major(icalrequeststatus stat);
+short icalenum_reqstat_minor(icalrequeststatus stat);
+icalrequeststatus icalenum_num_to_reqstat(short major, short minor);
+
+/***********************************************************************
+ * Conversion functions
+**********************************************************************/
+
+
+/* Thse routines used to be in icalenums.c, but were moved into the
+   icalproperty, icalparameter, icalvalue, or icalcomponent modules. */
+
+/* const char* icalproperty_kind_to_string(icalproperty_kind kind);*/
+#define icalenum_property_kind_to_string(x) icalproperty_kind_to_string(x)
+
+/*icalproperty_kind icalproperty_string_to_kind(const char* string)*/
+#define icalenum_string_to_property_kind(x) icalproperty_string_to_kind(x)
+
+/*icalvalue_kind icalproperty_kind_to_value_kind(icalproperty_kind kind);*/
+#define icalenum_property_kind_to_value_kind(x) icalproperty_kind_to_value_kind(x)
+
+/*const char* icalenum_method_to_string(icalproperty_method);*/
+#define icalenum_method_to_string(x) icalproperty_method_to_string(x)
+
+/*icalproperty_method icalenum_string_to_method(const char* string);*/
+#define icalenum_string_to_method(x) icalproperty_string_to_method(x)
+
+/*const char* icalenum_status_to_string(icalproperty_status);*/
+#define icalenum_status_to_string(x) icalproperty_status_to_string(x)
+
+/*icalproperty_status icalenum_string_to_status(const char* string);*/
+#define icalenum_string_to_status(x) icalproperty_string_to_status(x)
+
+/*icalvalue_kind icalenum_string_to_value_kind(const char* str);*/
+#define icalenum_string_to_value_kind(x) icalvalue_string_to_kind(x)
+
+/*const char* icalenum_value_kind_to_string(icalvalue_kind kind);*/
+#define icalenum_value_kind_to_string(x) icalvalue_kind_to_string(x)
+
+/*const char* icalenum_component_kind_to_string(icalcomponent_kind kind);*/
+#define icalenum_component_kind_to_string(x) icalcomponent_kind_to_string(x)
+
+/*icalcomponent_kind icalenum_string_to_component_kind(const char* string);*/
+#define icalenum_string_to_component_kind(x) icalcomponent_string_to_kind(x)
+
+
+#endif /* !ICALENUMS_H */
+
diff --git a/libical/src/libical/icalerror.c b/libical/src/libical/icalerror.c
new file mode 100644
index 0000000..d44d37a
--- a/dev/null
+++ b/libical/src/libical/icalerror.c
@@ -0,0 +1,209 @@
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: icalerror.c
+  CREATOR: eric 16 May 1999
+  
+  $Id$
+  $Locker$
+    
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalerror.c
+
+ ======================================================================*/
+
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "icalerror.h"
+
+#include <string.h>
+
+icalerrorenum icalerrno;
+
+int foo;
+void icalerror_stop_here(void)
+{
+    foo++; /* Keep optimizers from removing routine */
+}
+
+void icalerror_crash_here(void)
+{
+    int *p=0;
+    *p = 1;
+
+    assert( *p);
+}
+
+#ifdef ICAL_SETERROR_ISFUNC
+void icalerror_set_errno(icalerrorenum x) 
+{
+    icalerrno = x; 
+    if(icalerror_get_error_state(x)==ICAL_ERROR_FATAL || 
+       (icalerror_get_error_state(x)==ICAL_ERROR_DEFAULT && 
+        icalerror_errors_are_fatal == 1 )){ 
+        icalerror_warn(icalerror_strerror(x)); 
+        assert(0); 
+    } 
+
+}
+#endif 
+
+void icalerror_clear_errno() {
+    
+    icalerrno = ICAL_NO_ERROR;
+}
+
+#ifdef ICAL_ERRORS_ARE_FATAL
+int icalerror_errors_are_fatal = 1;
+#else
+int icalerror_errors_are_fatal = 0;
+#endif
+
+struct icalerror_state {
+    icalerrorenum error;
+    icalerrorstate state; 
+};
+
+struct icalerror_state error_state_map[] = 
+{ 
+    { ICAL_BADARG_ERROR,ICAL_ERROR_DEFAULT},
+    { ICAL_NEWFAILED_ERROR,ICAL_ERROR_DEFAULT},
+    { ICAL_MALFORMEDDATA_ERROR,ICAL_ERROR_DEFAULT}, 
+    { ICAL_PARSE_ERROR,ICAL_ERROR_DEFAULT},
+    { ICAL_INTERNAL_ERROR,ICAL_ERROR_DEFAULT}, 
+    { ICAL_FILE_ERROR,ICAL_ERROR_DEFAULT},
+    { ICAL_USAGE_ERROR,ICAL_ERROR_DEFAULT},
+    { ICAL_UNIMPLEMENTED_ERROR,ICAL_ERROR_DEFAULT},
+    { ICAL_UNKNOWN_ERROR,ICAL_ERROR_DEFAULT},
+    { ICAL_NO_ERROR,ICAL_ERROR_DEFAULT}
+
+};
+
+struct icalerror_string_map {
+    const char* str;
+    icalerrorenum error;
+    char name[160];
+};
+
+static struct icalerror_string_map string_map[] = 
+{
+    {"BADARG",ICAL_BADARG_ERROR,"BADARG: Bad argument to function"},
+    { "NEWFAILED",ICAL_NEWFAILED_ERROR,"NEWFAILED: Failed to create a new object via a *_new() routine"},
+    {"MALFORMEDDATA",ICAL_MALFORMEDDATA_ERROR,"MALFORMEDDATA: An input string was not correctly formed or a component has missing or extra properties"},
+    { "PARSE",ICAL_PARSE_ERROR,"PARSE: Failed to parse a part of an iCal component"},
+    {"INTERNAL",ICAL_INTERNAL_ERROR,"INTERNAL: Random internal error. This indicates an error in the library code, not an error in use"}, 
+    { "FILE",ICAL_FILE_ERROR,"FILE: An operation on a file failed. Check errno for more detail."},
+    { "USAGE",ICAL_USAGE_ERROR,"USAGE: Failed to propertyl sequence calls to a set of interfaces"},
+    { "UNIMPLEMENTED",ICAL_UNIMPLEMENTED_ERROR,"UNIMPLEMENTED: This feature has not been implemented"},
+    { "NO",ICAL_NO_ERROR,"NO: No error"},
+    {"UNKNOWN",ICAL_UNKNOWN_ERROR,"UNKNOWN: Unknown error type -- icalerror_strerror() was probably given bad input"}
+};
+
+
+icalerrorenum icalerror_error_from_string(const char* str){
+ 
+    icalerrorenum e;
+    int i = 0;
+
+    for( i = 0; string_map[i].error != ICAL_NO_ERROR; i++){
+        if (strcmp(string_map[i].str,str) == 0){
+            e = string_map[i].error;
+        }
+    }
+
+    return e;
+}
+
+icalerrorstate icalerror_supress(const char* error){
+
+    icalerrorenum e = icalerror_error_from_string(error);
+    icalerrorstate es;
+
+     if (e == ICAL_NO_ERROR){
+        return ICAL_ERROR_UNKNOWN;
+    }
+
+
+    es = icalerror_get_error_state(e);
+    icalerror_set_error_state(e,ICAL_ERROR_NONFATAL);
+
+    return es;
+}
+
+char* icalerror_perror()
+{
+    return icalerror_strerror(icalerrno);
+}
+
+void icalerror_restore(const char* error, icalerrorstate es){
+
+
+    icalerrorenum e = icalerror_error_from_string(error);
+
+    if (e != ICAL_NO_ERROR){
+        icalerror_set_error_state(e,es);
+    }
+
+}
+
+
+
+void icalerror_set_error_state( icalerrorenum error, 
+                                icalerrorstate state)
+{
+    int i;
+
+    for(i = ICAL_BADARG_ERROR; error_state_map[i].error!= ICAL_NO_ERROR;i++){
+        if(error_state_map[i].error == error){
+                    error_state_map[i].state = state; 
+        }
+    }
+}
+
+icalerrorstate icalerror_get_error_state( icalerrorenum error)
+{
+    int i;
+
+    for(i = ICAL_BADARG_ERROR; error_state_map[i].error!= ICAL_NO_ERROR;i++){
+        if(error_state_map[i].error == error){
+                    return error_state_map[i].state; 
+        }
+    }
+
+            return ICAL_ERROR_UNKNOWN;
+}
+
+
+
+
+char* icalerror_strerror(icalerrorenum e) {
+
+    int i;
+
+    for (i=0; string_map[i].error != ICAL_UNKNOWN_ERROR; i++) {
+        if (string_map[i].error == e) {
+            return string_map[i].name;
+        }
+    }
+
+    return string_map[i].name; /* Return string for ICAL_UNKNOWN_ERROR*/
+    
+}
+
+
+
diff --git a/libical/src/libical/icalerror.h b/libical/src/libical/icalerror.h
new file mode 100644
index 0000000..52f5ba9
--- a/dev/null
+++ b/libical/src/libical/icalerror.h
@@ -0,0 +1,156 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+  FILE: icalerror.h
+  CREATOR: eric 09 May 1999
+  
+  $Id$
+
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalerror.h
+
+======================================================================*/
+
+
+#ifndef ICALERROR_H
+#define ICALERROR_H
+
+#include <assert.h>
+#include <stdio.h> /* For icalerror_warn() */
+
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#define ICAL_SETERROR_ISFUNC
+
+
+/* This routine is called before any error is triggered. It is called
+   by icalerror_set_errno, so it does not appear in all of the macros
+   below */
+void icalerror_stop_here(void);
+
+void icalerror_crash_here(void);
+
+typedef enum icalerrorenum {
+    
+    ICAL_BADARG_ERROR,
+    ICAL_NEWFAILED_ERROR,
+    ICAL_ALLOCATION_ERROR,
+    ICAL_MALFORMEDDATA_ERROR, 
+    ICAL_PARSE_ERROR,
+    ICAL_INTERNAL_ERROR, /* Like assert --internal consist. prob */
+    ICAL_FILE_ERROR,
+    ICAL_USAGE_ERROR,
+    ICAL_UNIMPLEMENTED_ERROR,
+    ICAL_UNKNOWN_ERROR, /* Used for problems in input to icalerror_strerror()*/
+    ICAL_NO_ERROR
+
+} icalerrorenum;
+
+/* The libical error enumeration, like errno*/
+extern icalerrorenum icalerrno;
+
+/* If true, libicl aborts after a call to icalerror_set_error*/
+extern int icalerror_errors_are_fatal;
+
+/* Warning messages */
+
+#ifdef __GNUC__ca
+#define icalerror_warn(message) {fprintf(stderr,"%s(), %s:%d: %s\n",__FUNCTION__,__FILE__,__LINE__,message);}
+#else /* __GNU_C__ */
+#define icalerror_warn(message) {fprintf(stderr,"%s:%d: %s\n",__FILE__,__LINE__,message);}
+#endif /* __GNU_C__ */
+
+
+void icalerror_clear_errno(void);
+
+/* Make an individual error fatal or non-fatal. */
+typedef enum icalerrorstate { 
+    ICAL_ERROR_FATAL,     /* Not fata */
+    ICAL_ERROR_NONFATAL,  /* Fatal */
+    ICAL_ERROR_DEFAULT,   /* Use the value of icalerror_errors_are_fatal*/
+    ICAL_ERROR_UNKNOWN    /* Asked state for an unknown error type */
+} icalerrorstate ;
+
+char* icalerror_strerror(icalerrorenum e);
+char* icalerror_perror();
+void icalerror_set_error_state( icalerrorenum error, icalerrorstate);
+icalerrorstate icalerror_get_error_state( icalerrorenum error);
+
+#ifndef ICAL_SETERROR_ISFUNC
+#define icalerror_set_errno(x) \
+icalerrno = x; \
+if(icalerror_get_error_state(x)==ICAL_ERROR_FATAL || \
+   (icalerror_get_error_state(x)==ICAL_ERROR_DEFAULT && \
+    icalerror_errors_are_fatal == 1 )){ \
+   icalerror_warn(icalerror_strerror(x)); \
+   assert(0); \
+}
+#else
+void icalerror_set_errno(icalerrorenum);
+#endif
+
+#ifdef ICAL_ERRORS_ARE_FATAL
+#undef NDEBUG
+#endif
+
+#define icalerror_check_value_type(value,type);
+#define icalerror_check_property_type(value,type);
+#define icalerror_check_parameter_type(value,type);
+#define icalerror_check_component_type(value,type);
+
+/* Assert with a message */
+#ifdef ICAL_ERRORS_ARE_FATAL
+
+#ifdef __GNUC__
+#define icalerror_assert(test,message) if(!(test)){fprintf(stderr,"%s(), %s:%d: %s\n",__FUNCTION__,__FILE__,__LINE__,message);icalerror_stop_here(); abort();}
+#else /*__GNUC__*/
+#define icalerror_assert(test,message) if(!(test)){fprintf(stderr,"%s:%d: %s\n",__FILE__,__LINE__,message);icalerror_stop_here(); abort();}
+#endif /*__GNUC__*/
+
+#else /* ICAL_ERRORS_ARE_FATAL */
+#define icalerror_assert(test,message) 
+#endif /* ICAL_ERRORS_ARE_FATAL */
+
+/* Check & abort if check fails */
+#define icalerror_check_arg(test,arg) if(!(test)) { icalerror_set_errno(ICAL_BADARG_ERROR); }
+
+/* Check & return void if check fails*/
+#define icalerror_check_arg_rv(test,arg) if(!(test)) {icalerror_set_errno(ICAL_BADARG_ERROR); return; }
+
+/* Check & return 0 if check fails*/
+#define icalerror_check_arg_rz(test,arg) if(!(test)) { icalerror_set_errno(ICAL_BADARG_ERROR); return 0;}
+
+/* Check & return an error if check fails*/
+#define icalerror_check_arg_re(test,arg,error) if(!(test)) { icalerror_stop_here(); assert(0); return error;}
+
+/* Check & return something*/
+#define icalerror_check_arg_rx(test,arg,x) if(!(test)) { icalerror_set_errno(ICAL_BADARG_ERROR); return x;}
+
+
+
+/* String interfaces to set an error to NONFATAL and restore it to its
+   original value */
+
+icalerrorstate icalerror_supress(const char* error);
+void icalerror_restore(const char* error, icalerrorstate es);
+
+
+#endif /* !ICALERROR_H */
+
+
+
diff --git a/libical/src/libical/icallangbind.c b/libical/src/libical/icallangbind.c
new file mode 100644
index 0000000..c079034
--- a/dev/null
+++ b/libical/src/libical/icallangbind.c
@@ -0,0 +1,275 @@
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: icallangbind.c
+  CREATOR: eric 15 dec 2000
+  
+  DESCRIPTION:
+  
+  $Id$
+  $Locker$
+
+  (C) COPYRIGHT 1999 Eric Busboom 
+  http://www.softwarestudio.org
+  
+  This package is free software and is provided "as is" without
+  express or implied warranty.  It may be used, redistributed and/or
+  modified under the same terms as perl itself. ( Either the Artistic
+  License or the GPL. )
+
+  ======================================================================*/
+
+#include "icalcomponent.h"
+#include "icalproperty.h"
+#include "icalerror.h"
+#include "icalmemory.h"
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+int snprintf(char *str, size_t n, char const *fmt, ...);
+
+int* icallangbind_new_array(int size){
+    int* p = (int*)malloc(size*sizeof(int));
+    return p; /* Caller handles failures */
+}
+
+void icallangbind_free_array(int* array){
+    free(array);
+}
+
+int icallangbind_access_array(int* array, int index) {
+    return array[index];
+}                    
+
+
+
+/* LIke icalcomponent_get_first_component, buut takes a string for the
+   kind and can iterate over X properties as if each X name was a
+   seperate kind */
+icalproperty* icallangbind_get_first_property(icalcomponent *c,
+                                              const char* prop)
+{
+    icalproperty_kind kind = icalproperty_string_to_kind(prop);
+    icalproperty *p;
+
+    if (kind == ICAL_NO_PROPERTY){
+        return 0;
+    }
+
+    if(kind == ICAL_X_PROPERTY){
+        for(p = icalcomponent_get_first_property(c,kind);
+            p !=0;
+            p = icalcomponent_get_next_property(c,kind)){
+            
+            if(strcmp(icalproperty_get_x_name(p),prop) == 0){
+                return p;
+            }                
+        }
+    } else {
+        p=icalcomponent_get_first_property(c,kind);
+
+        return p;
+    }
+        
+    return 0;
+
+}
+
+icalproperty* icallangbind_get_next_property(icalcomponent *c,
+                                              const char* prop)
+{
+    icalproperty_kind kind = icalenum_string_to_property_kind(prop);
+    icalproperty *p;
+
+    if (kind == ICAL_NO_PROPERTY){
+        return 0;
+    }
+
+    if(kind == ICAL_X_PROPERTY){
+        for(p = icalcomponent_get_next_property(c,kind);
+            p !=0;
+            p = icalcomponent_get_next_property(c,kind)){
+            
+            if(strcmp(icalproperty_get_x_name(p),prop) == 0){
+                return p;
+            }                
+        }
+    } else {
+        p=icalcomponent_get_next_property(c,kind);
+
+        return p;
+    }
+        
+    return 0;
+
+}
+
+
+icalcomponent* icallangbind_get_first_component(icalcomponent *c,
+                                              const char* comp)
+{
+    icalcomponent_kind kind = icalenum_string_to_component_kind(comp);
+
+    if (kind == ICAL_NO_COMPONENT){
+        return 0;
+    }
+    return icalcomponent_get_first_component(c,kind);
+}
+
+icalcomponent* icallangbind_get_next_component(icalcomponent *c,
+                                              const char* comp)
+{
+    icalcomponent_kind kind = icalenum_string_to_component_kind(comp);
+
+    if (kind == ICAL_NO_COMPONENT){
+        return 0;
+    }
+    return icalcomponent_get_next_component(c,kind);
+}
+
+
+#define APPENDS(x) icalmemory_append_string(&buf, &buf_ptr, &buf_size, x);
+
+#define APPENDC(x) icalmemory_append_char(&buf, &buf_ptr, &buf_size, x);
+
+const char* icallangbind_property_eval_string(icalproperty* prop, char* sep)
+{
+    char tmp[25];
+    size_t buf_size = 1024;
+    char* buf = icalmemory_new_buffer(buf_size);
+    char* buf_ptr = buf;
+    icalparameter *param;
+    
+    icalvalue* value;
+
+    if( prop == 0){
+        return 0;
+    }
+
+    APPENDS("{ ");
+
+    value = icalproperty_get_value(prop);
+
+    APPENDS(" 'name' ");
+    APPENDS(sep);
+    APPENDC('\'');
+    APPENDS(icalenum_property_kind_to_string(icalproperty_isa(prop)));
+    APPENDC('\'');
+
+    if(value){
+        APPENDS(", 'value_type' ");
+        APPENDS(sep);
+        APPENDC('\'');
+        APPENDS(icalenum_value_kind_to_string(icalvalue_isa(value)));
+        APPENDC('\'');
+    }
+
+    APPENDS(", 'pid' ");
+    APPENDS(sep);
+    APPENDC('\'');
+    snprintf(tmp,25,"%p",prop);
+    APPENDS(tmp);
+    APPENDC('\'');
+
+
+    if(value){
+        switch (icalvalue_isa(value)){
+        
+        case ICAL_ATTACH_VALUE:
+        case ICAL_BINARY_VALUE: 
+        case ICAL_NO_VALUE: {
+            icalerror_set_errno(ICAL_INTERNAL_ERROR);
+            break;
+        }
+
+        default: 
+        {
+            const char* str = icalvalue_as_ical_string(value);
+            char* copy = (char*) malloc(strlen(str)+1);
+            
+            const char *i;
+            char *j;
+
+            if(copy ==0){
+                icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+                break; 
+            }
+            /* Remove any newlines */
+                
+            for(j=copy, i = str; *i != 0; j++,i++){
+                if(*i=='\n'){
+                    i++;
+                }   
+                *j = *i;
+            }
+                
+            *j = 0;
+                
+            APPENDS(", 'value'");
+            APPENDS(sep);
+            APPENDC('\'');
+            APPENDS(copy);
+            APPENDC('\'');
+            
+            free(copy);
+            break;
+
+        }
+        }
+    }
+
+    /* Add Parameters */
+
+    for(param = icalproperty_get_first_parameter(prop,ICAL_ANY_PARAMETER);
+        param != 0;
+        param = icalproperty_get_next_parameter(prop,ICAL_ANY_PARAMETER)){
+        
+        const char* str = icalparameter_as_ical_string(param);
+        char *copy = icalmemory_tmp_copy(str);
+        char *v;
+
+        if(copy == 0){
+            icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+            continue;
+        }
+
+        v = strchr(copy,'=');
+
+
+        if(v == 0){
+            continue;
+        }
+
+        *v = 0;
+
+        v++;
+
+        APPENDS(", ");
+        APPENDC('\'');
+        APPENDS(copy);
+        APPENDC('\'');
+        APPENDS(sep);
+        APPENDC('\'');
+        APPENDS(v);        
+        APPENDC('\'');
+        
+    }
+
+
+    APPENDC('}');
+
+    icalmemory_add_tmp_buffer(buf);
+    return buf;
+
+}
+
+#include "fcntl.h"
+int icallangbind_string_to_open_flag(const char* str)
+{
+    if (strcmp(str,"r") == 0) {return O_RDONLY;}
+    else if (strcmp(str,"r+") == 0) {return O_RDWR;}
+    else if (strcmp(str,"w") == 0) {return O_WRONLY;}
+    else if (strcmp(str,"a") == 0) {return O_WRONLY|O_APPEND;}
+    else return -1;
+}
+
diff --git a/libical/src/libical/icallangbind.h b/libical/src/libical/icallangbind.h
new file mode 100644
index 0000000..2ed5003
--- a/dev/null
+++ b/libical/src/libical/icallangbind.h
@@ -0,0 +1,49 @@
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: icallangbind.h
+  CREATOR: eric 25 jan 2001
+  
+  DESCRIPTION:
+  
+  $Id$
+  $Locker$
+
+  (C) COPYRIGHT 1999 Eric Busboom 
+  http://www.softwarestudio.org
+  
+  This package is free software and is provided "as is" without
+  express or implied warranty.  It may be used, redistributed and/or
+  modified under the same terms as perl itself. ( Either the Artistic
+  License or the GPL. )
+
+  ======================================================================*/
+
+#ifndef __ICALLANGBIND_H__
+#define __ICALLANGBIND_H__
+
+int* icallangbind_new_array(int size);
+void icallangbind_free_array(int* array);
+int icallangbind_access_array(int* array, int index);
+icalproperty* icallangbind_get_property(icalcomponent *c, int n, const char* prop);
+const char* icallangbind_get_property_val(icalproperty* p);
+const char* icallangbind_get_parameter(icalproperty *p, const char* parameter);
+icalcomponent* icallangbind_get_component(icalcomponent *c, const char* comp);
+
+icalproperty* icallangbind_get_first_property(icalcomponent *c,
+                                              const char* prop);
+
+icalproperty* icallangbind_get_next_property(icalcomponent *c,
+                                              const char* prop);
+
+icalcomponent* icallangbind_get_first_component(icalcomponent *c,
+                                              const char* comp);
+
+icalcomponent* icallangbind_get_next_component(icalcomponent *c,
+                                              const char* comp);
+
+
+const char* icallangbind_property_eval_string(icalproperty* prop, char* sep);
+
+
+int icallangbind_string_to_open_flag(const char* str);
+#endif /*__ICALLANGBIND_H__*/
diff --git a/libical/src/libical/icallexer.c b/libical/src/libical/icallexer.c
new file mode 100644
index 0000000..4dd26c3
--- a/dev/null
+++ b/libical/src/libical/icallexer.c
@@ -0,0 +1,1793 @@
+#define yy_create_buffer ical_yy_create_buffer
+#define yy_delete_buffer ical_yy_delete_buffer
+#define yy_scan_buffer ical_yy_scan_buffer
+#define yy_scan_string ical_yy_scan_string
+#define yy_scan_bytes ical_yy_scan_bytes
+#define yy_flex_debug ical_yy_flex_debug
+#define yy_init_buffer ical_yy_init_buffer
+#define yy_flush_buffer ical_yy_flush_buffer
+#define yy_load_buffer_state ical_yy_load_buffer_state
+#define yy_switch_to_buffer ical_yy_switch_to_buffer
+#define yyin ical_yyin
+#define yyleng ical_yyleng
+#define yylex ical_yylex
+#define yyout ical_yyout
+#define yyrestart ical_yyrestart
+#define yytext ical_yytext
+#define yywrap ical_yywrap
+
+#line 20 "lex.yy.c"
+/* A lexical scanner generated by flex */
+
+/* Scanner skeleton version:
+ * $Header$
+ */
+
+#define FLEX_SCANNER
+#define YY_FLEX_MAJOR_VERSION 2
+#define YY_FLEX_MINOR_VERSION 5
+
+#include <stdio.h>
+
+
+/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
+#ifdef c_plusplus
+#ifndef __cplusplus
+#define __cplusplus
+#endif
+#endif
+
+
+#ifdef __cplusplus
+
+
+#include <stdlib.h>
+// Eugen C. <eug@thekompany.com>
+#ifndef _WIN32
+#include <unistd.h>
+#else
+#include <io.h>
+#include <stdio.h>
+
+#endif
+// Eugen C. <eug@thekompany.com>
+
+/* Use prototypes in function declarations. */
+#define YY_USE_PROTOS
+
+/* The "const" storage-class-modifier is valid. */
+#define YY_USE_CONST
+
+        #else/* ! __cplusplus */
+
+#if __STDC__
+
+#define YY_USE_PROTOS
+#define YY_USE_CONST
+
+        #endif/* __STDC__ */
+        #endif/* ! __cplusplus */
+
+#ifdef __TURBOC__
+ #pragma warn -rch
+ #pragma warn -use
+#include <io.h>
+#include <stdlib.h>
+#define YY_USE_CONST
+#define YY_USE_PROTOS
+#endif
+
+#ifdef YY_USE_CONST
+#define yyconst const
+#else
+#define yyconst
+#endif
+
+
+#ifdef YY_USE_PROTOS
+#define YY_PROTO(proto) proto
+#else
+#define YY_PROTO(proto) ()
+#endif
+
+/* Returned upon end-of-file. */
+#define YY_NULL 0
+
+/* Promotes a possibly negative, possibly signed char to an unsigned
+ * integer for use as an array index.  If the signed char is negative,
+ * we want to instead treat it as an 8-bit unsigned char, hence the
+ * double cast.
+ */
+#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
+
+/* Enter a start condition.  This macro really ought to take a parameter,
+ * but we do it the disgusting crufty way forced on us by the ()-less
+ * definition of BEGIN.
+ */
+#define BEGIN yy_start = 1 + 2 *
+
+/* Translate the current start state into a value that can be later handed
+ * to BEGIN to return to the state.  The YYSTATE alias is for lex
+ * compatibility.
+ */
+#define YY_START ((yy_start - 1) / 2)
+#define YYSTATE YY_START
+
+/* Action number for EOF rule of a given start state. */
+#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
+
+/* Special action meaning "start processing a new file". */
+#define YY_NEW_FILE yyrestart( yyin )
+
+#define YY_END_OF_BUFFER_CHAR 0
+
+/* Size of default input buffer. */
+#define YY_BUF_SIZE 16384
+
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+
+extern int yyleng;
+extern FILE *yyin, *yyout;
+
+#define EOB_ACT_CONTINUE_SCAN 0
+#define EOB_ACT_END_OF_FILE 1
+#define EOB_ACT_LAST_MATCH 2
+
+/* The funky do-while in the following #define is used to turn the definition
+ * int a single C statement (which needs a semi-colon terminator).  This
+ * avoids problems with code like:
+ *
+         * if ( condition_holds )
+         *      yyless( 5 );
+         *else
+         *      do_something_else();
+ *
+ * Prior to using the do-while the compiler would get upset at the
+ * "else" because it interpreted the "if" statement as being all
+ * done when it reached the ';' after the yyless() call.
+ */
+
+/* Return all but the first 'n' matched characters back to the input stream. */
+
+#define yyless(n) \
+        do \
+                { \
+                /* Undo effects of setting up yytext. */ \
+                *yy_cp = yy_hold_char; \
+                YY_RESTORE_YY_MORE_OFFSET \
+                yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
+                YY_DO_BEFORE_ACTION; /* set up yytext again */ \
+                } \
+        while ( 0 )
+
+#define unput(c) yyunput( c, yytext_ptr )
+
+/* The following is because we cannot portably get our hands on size_t
+ * (without autoconf's help, which isn't available because we want
+ * flex-generated scanners to compile on their own).
+ */
+typedef unsigned int yy_size_t;
+
+
+struct yy_buffer_state
+        {
+        FILE *yy_input_file;
+
+                char *yy_ch_buf;        /* input buffer */
+                char *yy_buf_pos;       /* current position in input buffer */
+
+        /* Size of input buffer in bytes, not including room for EOB
+         * characters.
+         */
+        yy_size_t yy_buf_size;
+
+        /* Number of characters read into yy_ch_buf, not including EOB
+         * characters.
+         */
+        int yy_n_chars;
+
+        /* Whether we "own" the buffer - i.e., we know we created it,
+         * and can realloc() it to grow it, and should free() it to
+         * delete it.
+         */
+        int yy_is_our_buffer;
+
+        /* Whether this is an "interactive" input source; if so, and
+         * if we're using stdio for input, then we want to use getc()
+         * instead of fread(), to make sure we stop fetching input after
+         * each newline.
+         */
+        int yy_is_interactive;
+
+        /* Whether we're considered to be at the beginning of a line.
+         * If so, '^' rules will be active on the next match, otherwise
+         * not.
+         */
+        int yy_at_bol;
+
+        /* Whether to try to fill the input buffer when we reach the
+         * end of it.
+         */
+        int yy_fill_buffer;
+
+        int yy_buffer_status;
+#define YY_BUFFER_NEW 0
+#define YY_BUFFER_NORMAL 1
+        /* When an EOF's been seen but there's still some text to process
+         * then we mark the buffer as YY_EOF_PENDING, to indicate that we
+         * shouldn't try reading from the input source any more.  We might
+         * still have a bunch of tokens to match, though, because of
+         * possible backing-up.
+         *
+         * When we actually see the EOF, we change the status to "new"
+         * (via yyrestart()), so that the user can continue scanning by
+         * just pointing yyin at a new input file.
+         */
+#define YY_BUFFER_EOF_PENDING 2
+        };
+
+static YY_BUFFER_STATE yy_current_buffer = 0;
+
+/* We provide macros for accessing buffer states in case in the
+ * future we want to put the buffer states in a more general
+ * "scanner state".
+ */
+#define YY_CURRENT_BUFFER yy_current_buffer
+
+
+/* yy_hold_char holds the character lost when yytext is formed. */
+static char yy_hold_char;
+
+        static int yy_n_chars;  /* number of characters read into yy_ch_buf */
+
+
+int yyleng;
+
+/* Points to current character in buffer. */
+static char *yy_c_buf_p = (char *) 0;
+        static int yy_init = 1;         /* whether we need to initialize */
+        static int yy_start = 0;/* start state number */
+
+/* Flag which is used to allow yywrap()'s to do buffer switches
+ * instead of setting up a fresh yyin.  A bit of a hack ...
+ */
+static int yy_did_buffer_switch_on_eof;
+
+void yyrestart YY_PROTO(( FILE *input_file ));
+
+void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
+void yy_load_buffer_state YY_PROTO(( void ));
+YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
+void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
+void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
+void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
+#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
+
+YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
+YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
+YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
+
+static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
+static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
+static void yy_flex_free YY_PROTO(( void * ));
+
+#define yy_new_buffer yy_create_buffer
+
+#define yy_set_interactive(is_interactive) \
+        { \
+        if ( ! yy_current_buffer ) \
+                yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
+        yy_current_buffer->yy_is_interactive = is_interactive; \
+        }
+
+#define yy_set_bol(at_bol) \
+        { \
+        if ( ! yy_current_buffer ) \
+                yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
+        yy_current_buffer->yy_at_bol = at_bol; \
+        }
+
+#define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
+
+typedef unsigned char YY_CHAR;
+FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
+typedef int yy_state_type;
+extern char yytext[];
+
+
+static yy_state_type yy_get_previous_state YY_PROTO(( void ));
+static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
+static int yy_get_next_buffer YY_PROTO(( void ));
+static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
+
+/* Done after the current pattern has been matched and before the
+ * corresponding action - sets up yytext.
+ */
+#define YY_DO_BEFORE_ACTION \
+        yytext_ptr = yy_bp; \
+        yyleng = (int) (yy_cp - yy_bp); \
+        yy_hold_char = *yy_cp; \
+        *yy_cp = '\0'; \
+        if ( yyleng >= YYLMAX ) \
+                YY_FATAL_ERROR( "token too large, exceeds YYLMAX" ); \
+        yy_flex_strncpy( yytext, yytext_ptr, yyleng + 1 ); \
+        yy_c_buf_p = yy_cp;
+
+#define YY_NUM_RULES 12
+#define YY_END_OF_BUFFER 13
+static yyconst short int yy_accept[67] =
+    {   0,
+        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,   13,   12,    5,   12,    4,    1,
+        2,    3,    6,   12,    7,   12,    9,   10,    9,   11,
+        5,    1,    6,    8,   10,    0
+    } ;
+
+static yyconst int yy_ec[256] =
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    2,
+        1,    1,    3,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    4,    5,    6,    1,    7,    8,    8,    8,
+        8,    8,    8,    8,    8,    8,    8,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    7,    1,    1,
+        1,    7,    1,    1,    1,    1,    7,    1,    1,    7,
+        1,    1,    7,    9,    1,    1,    7,    1,    1,   10,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    7,
+
+        1,    1,    1,    7,    1,    1,    1,    1,    7,    1,
+        1,    7,    1,    1,    7,    9,    1,    1,    7,    1,
+        1,   10,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1
+    } ;
+
+static yyconst int yy_meta[11] =
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1
+    } ;
+
+static yyconst short int yy_base[69] =
+    {   0,
+        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
+        0,    0,    9,    0,   16,   18,    0,    0,    0,    0,
+        0,    0,    0,    0,    0,    0,   25,   24,    0,    0,
+        0,    0,    0,    0,   28,   31,   31,   25,   31,   18,
+       31,   31,   31,   23,   31,   16,   31,   31,   21,   31,
+       31,   14,   31,   31,   31,   31,   15,   13
+    } ;
+
+static yyconst short int yy_def[69] =
+    {   0,
+       67,   67,   67,   67,   67,   67,   67,   67,   67,   67,
+       66,   11,   67,   67,   67,   67,   67,   67,   67,   67,
+       67,   67,   67,   23,   68,   68,   67,   67,   67,   67,
+       67,   67,   67,   67,   67,   67,   67,   67,   67,   67,
+       67,   67,   67,   67,   66,   66,   66,   66,   66,   66,
+       66,   66,   66,   66,   66,   66,   66,   66,   66,   66,
+       66,   66,   66,   66,   66,    0,   66,   66
+    } ;
+
+static yyconst short int yy_nxt[42] =
+    {   0,
+       46,   47,   48,   49,   46,   49,   49,   50,   51,   52,
+       53,   54,   55,   57,   55,   46,   56,   58,   59,   58,
+       59,   62,   65,   64,   63,   62,   61,   66,   60,   60,
+       45,   66,   66,   66,   66,   66,   66,   66,   66,   66,
+       66
+    } ;
+
+static yyconst short int yy_chk[42] =
+    {   0,
+       11,   11,   11,   11,   11,   11,   11,   11,   11,   11,
+       23,   23,   23,   68,   23,   67,   23,   25,   25,   26,
+       26,   62,   59,   56,   54,   50,   48,   45,   38,   37,
+       66,   66,   66,   66,   66,   66,   66,   66,   66,   66,
+       66
+    } ;
+
+static yy_state_type yy_last_accepting_state;
+static char *yy_last_accepting_cpos;
+
+/* The intent behind this definition is that it'll catch
+ * any uses of REJECT which flex missed.
+ */
+#define REJECT reject_used_but_not_detected
+#define yymore() yymore_used_but_not_detected
+#define YY_MORE_ADJ 0
+#define YY_RESTORE_YY_MORE_OFFSET
+#ifndef YYLMAX
+#define YYLMAX 8192
+#endif
+
+char yytext[YYLMAX];
+char *yytext_ptr;
+#line 1 "../../../../libical/src/libical/icallexer.l"
+#define INITIAL 0
+#line 2 "../../../../libical/src/libical/icallexer.l"
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: icallexer.l
+  CREATOR: eric 10 June 1999
+  
+  DESCRIPTION:
+  
+  $Id$
+  $Locker$
+
+  (C) COPYRIGHT 1999 Eric Busboom 
+  http://www.softwarestudio.org
+
+  The contents of this file are subject to the Mozilla Public License
+  Version 1.0 (the "License"); you may not use this file except in
+  compliance with the License. You may obtain a copy of the License at
+  http://www.mozilla.org/MPL/
+ 
+  Software distributed under the License is distributed on an "AS IS"
+  basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+  the License for the specific language governing rights and
+  limitations under the License.
+
+  The original author is Eric Busboom
+  The original code is icalitip.y
+
+
+
+  ======================================================================*/
+#include "icalparser.h"
+#include "icalenums.h"
+#include "icalmemory.h"
+#include "assert.h"
+#include "icalyacc.h"
+
+#ifdef _WIN32
+#include <stdio.h>
+#include <stdlib.h>
+#endif
+
+#include <string.h> /* For strdup() */
+
+int icalparser_flex_input(char* buf, int max_size);
+void icalparser_clear_flex_input(void);
+
+
+#define ICAL_MAX_STR_CONST 1024
+
+#undef YY_INPUT
+#define YY_INPUT(b,r,ms) ( r= icalparser_flex_input(b,ms))
+#undef yywrap
+
+#undef YY_FATAL_ERROR
+#define YY_FATAL_ERROR(msg) ical_yyerror(msg)
+
+icalvalue_kind value_kind=ICAL_NO_VALUE;
+void set_parser_value_state(icalvalue_kind kind);
+extern int yydebug; 
+
+void ical_yyerror(char *s);
+
+void init_str_buf(void);
+
+int last_state;
+
+char *str_buf;
+char *str_buf_p;
+size_t buf_sz; /* = ICAL_MAX_STR_CONST;*/
+
+/* Define routines that were not propertly defined because of the
+renaming hack applied in icalyacc.y */
+YY_BUFFER_STATE ical_yy_scan_buffer ( char *base, yy_size_t size );
+YY_BUFFER_STATE ical_yy_scan_string ( yyconst char *yy_str );
+YY_BUFFER_STATE ical_yy_scan_bytes ( yyconst char *bytes, int len );
+
+#define quoted_string 1
+
+#define binary_value 2
+#define boolean_value 3
+#define uri_value 4
+#define time_value 5
+#define duration_value 6
+#define number_value 7
+#define period_value 8
+#define recur_value 9
+#define text_value 10
+#define utcoffset_value 11
+
+#define enum_param_value 12
+#define string_param_value 13
+#define stringlist_param_value 14
+#define keyword 15
+#define line_start 16
+#define component 17
+#define seperator 18
+#define parameter 19
+#define end_of_value 20
+#define paramtext 21
+
+#line 511 "lex.yy.c"
+
+/* Macros after this point can all be overridden by user definitions in
+ * section 1.
+ */
+
+#ifndef YY_SKIP_YYWRAP
+#ifdef __cplusplus
+extern "C" int yywrap YY_PROTO(( void ));
+#else
+extern int yywrap YY_PROTO(( void ));
+#endif
+#endif
+
+#ifndef YY_NO_UNPUT
+static void yyunput YY_PROTO(( int c, char *buf_ptr ));
+#endif
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen YY_PROTO(( yyconst char * ));
+#endif
+
+#ifndef YY_NO_INPUT
+#ifdef __cplusplus
+static int yyinput YY_PROTO(( void ));
+#else
+static int input YY_PROTO(( void ));
+#endif
+#endif
+
+#if YY_STACK_USED
+static int yy_start_stack_ptr = 0;
+static int yy_start_stack_depth = 0;
+static int *yy_start_stack = 0;
+#ifndef YY_NO_PUSH_STATE
+static void yy_push_state YY_PROTO(( int new_state ));
+#endif
+#ifndef YY_NO_POP_STATE
+static void yy_pop_state YY_PROTO(( void ));
+#endif
+#ifndef YY_NO_TOP_STATE
+static int yy_top_state YY_PROTO(( void ));
+#endif
+
+#else
+#define YY_NO_PUSH_STATE 1
+#define YY_NO_POP_STATE 1
+#define YY_NO_TOP_STATE 1
+#endif
+
+#ifdef YY_MALLOC_DECL
+YY_MALLOC_DECL
+#else
+#if __STDC__
+#ifndef __cplusplus
+#include <stdlib.h>
+#endif
+#else
+/* Just try to get by without declaring the routines.  This will fail
+ * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
+ * or sizeof(void*) != sizeof(int).
+ */
+#endif
+#endif
+
+/* Amount of stuff to slurp up with each read. */
+#ifndef YY_READ_BUF_SIZE
+#define YY_READ_BUF_SIZE 8192
+#endif
+
+/* Copy whatever the last rule matched to the standard output. */
+
+#ifndef ECHO
+/* This used to be an fputs(), but since the string might contain NUL's,
+ * we now use fwrite().
+ */
+#define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
+#endif
+
+/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
+ * is returned in "result".
+ */
+#ifndef YY_INPUT
+#define YY_INPUT(buf,result,max_size) \
+        if ( yy_current_buffer->yy_is_interactive ) \
+                { \
+                int c = '*', n; \
+                for ( n = 0; n < max_size && \
+                             (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
+                        buf[n] = (char) c; \
+                if ( c == '\n' ) \
+                        buf[n++] = (char) c; \
+                if ( c == EOF && ferror( yyin ) ) \
+                        YY_FATAL_ERROR( "input in flex scanner failed" ); \
+                result = n; \
+                } \
+        else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
+                  && ferror( yyin ) ) \
+                YY_FATAL_ERROR( "input in flex scanner failed" );
+#endif
+
+/* No semi-colon after return; correct usage is to write "yyterminate();" -
+ * we don't want an extra ';' after the "return" because that will cause
+ * some compilers to complain about unreachable statements.
+ */
+#ifndef yyterminate
+#define yyterminate() return YY_NULL
+#endif
+
+/* Number of entries by which start-condition stack grows. */
+#ifndef YY_START_STACK_INCR
+#define YY_START_STACK_INCR 25
+#endif
+
+/* Report a fatal error. */
+#ifndef YY_FATAL_ERROR
+#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
+#endif
+
+/* Default declaration of generated scanner - a define so the user can
+ * easily add parameters.
+ */
+#ifndef YY_DECL
+#define YY_DECL int yylex YY_PROTO(( void ))
+#endif
+
+/* Code executed at the beginning of each rule, after yytext and yyleng
+ * have been set up.
+ */
+#ifndef YY_USER_ACTION
+#define YY_USER_ACTION
+#endif
+
+/* Code executed at the end of each rule. */
+#ifndef YY_BREAK
+#define YY_BREAK break;
+#endif
+
+#define YY_RULE_SETUP \
+        YY_USER_ACTION
+
+YY_DECL
+        {
+        register yy_state_type yy_current_state;
+        register char *yy_cp, *yy_bp;
+        register int yy_act;
+
+#line 97 "../../../../libical/src/libical/icallexer.l"
+
+
+
+
+
+
+
+#line 670 "lex.yy.c"
+
+        if ( yy_init )
+                {
+                yy_init = 0;
+
+#ifdef YY_USER_INIT
+                YY_USER_INIT;
+#endif
+
+                if ( ! yy_start )
+                                yy_start = 1;/* first start state */
+
+                if ( ! yyin )
+                        yyin = stdin;
+
+                if ( ! yyout )
+                        yyout = stdout;
+
+                if ( ! yy_current_buffer )
+                        yy_current_buffer =
+                                yy_create_buffer( yyin, YY_BUF_SIZE );
+
+                yy_load_buffer_state();
+                }
+
+                while ( 1 )     /* loops until end-of-file is reached */
+                {
+                yy_cp = yy_c_buf_p;
+
+                /* Support of yytext. */
+                *yy_cp = yy_hold_char;
+
+                /* yy_bp points to the position in yy_ch_buf of the start of
+                 * the current run.
+                 */
+                yy_bp = yy_cp;
+
+                yy_current_state = yy_start;
+yy_match:
+                do
+                        {
+                        register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
+                        if ( yy_accept[yy_current_state] )
+                                {
+                                yy_last_accepting_state = yy_current_state;
+                                yy_last_accepting_cpos = yy_cp;
+                                }
+                        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+                                {
+                                yy_current_state = (int) yy_def[yy_current_state];
+                                if ( yy_current_state >= 67 )
+                                        yy_c = yy_meta[(unsigned int) yy_c];
+                                }
+                        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+                        ++yy_cp;
+                        }
+                while ( yy_base[yy_current_state] != 31 );
+
+yy_find_action:
+                yy_act = yy_accept[yy_current_state];
+                if ( yy_act == 0 )
+                        { /* have to back up */
+                        yy_cp = yy_last_accepting_cpos;
+                        yy_current_state = yy_last_accepting_state;
+                        yy_act = yy_accept[yy_current_state];
+                        }
+
+                YY_DO_BEFORE_ACTION;
+
+
+        do_action:/* This label is used only to access EOF actions. */
+
+
+                switch ( yy_act )
+        { /* beginning of action switch */
+                        case 0: /* must back up */
+                        /* undo the effects of YY_DO_BEFORE_ACTION */
+                        *yy_cp = yy_hold_char;
+                        yy_cp = yy_last_accepting_cpos;
+                        yy_current_state = yy_last_accepting_state;
+                        goto yy_find_action;
+
+
+case 1:
+YY_RULE_SETUP
+#line 105 "../../../../libical/src/libical/icallexer.l"
+{ ical_yylval.v_string =icalmemory_tmp_copy(yytext) ;
+                           return DIGITS; }
+        YY_BREAK
+case 2:
+YY_RULE_SETUP
+#line 107 "../../../../libical/src/libical/icallexer.l"
+{ return TIME_CHAR; }
+        YY_BREAK
+case 3:
+YY_RULE_SETUP
+#line 108 "../../../../libical/src/libical/icallexer.l"
+{ return UTC_CHAR; }
+        YY_BREAK
+case 4:
+YY_RULE_SETUP
+#line 109 "../../../../libical/src/libical/icallexer.l"
+{ return yytext[0]; }
+        YY_BREAK
+case 5:
+YY_RULE_SETUP
+#line 110 "../../../../libical/src/libical/icallexer.l"
+{ return EOL;}
+        YY_BREAK
+
+
+case 6:
+YY_RULE_SETUP
+#line 115 "../../../../libical/src/libical/icallexer.l"
+{ return EOL;}
+        YY_BREAK
+case 7:
+YY_RULE_SETUP
+#line 116 "../../../../libical/src/libical/icallexer.l"
+{ return yytext[0]; }
+        YY_BREAK
+case 8:
+YY_RULE_SETUP
+#line 117 "../../../../libical/src/libical/icallexer.l"
+{ ical_yylval.v_int=atoi(yytext); return INTNUMBER; }
+        YY_BREAK
+
+
+case 9:
+YY_RULE_SETUP
+#line 122 "../../../../libical/src/libical/icallexer.l"
+{ return CHARACTER; }
+        YY_BREAK
+case 10:
+YY_RULE_SETUP
+#line 123 "../../../../libical/src/libical/icallexer.l"
+{ return EOL;}
+        YY_BREAK
+
+
+case 11:
+YY_RULE_SETUP
+#line 128 "../../../../libical/src/libical/icallexer.l"
+{ BEGIN(last_state); return COMMA; } 
+        YY_BREAK
+
+case 12:
+YY_RULE_SETUP
+#line 132 "../../../../libical/src/libical/icallexer.l"
+ECHO;
+        YY_BREAK
+#line 822 "lex.yy.c"
+case YY_STATE_EOF(INITIAL):
+case YY_STATE_EOF(quoted_string):
+case YY_STATE_EOF(binary_value):
+case YY_STATE_EOF(boolean_value):
+case YY_STATE_EOF(uri_value):
+case YY_STATE_EOF(time_value):
+case YY_STATE_EOF(duration_value):
+case YY_STATE_EOF(number_value):
+case YY_STATE_EOF(period_value):
+case YY_STATE_EOF(recur_value):
+case YY_STATE_EOF(text_value):
+case YY_STATE_EOF(utcoffset_value):
+case YY_STATE_EOF(enum_param_value):
+case YY_STATE_EOF(string_param_value):
+case YY_STATE_EOF(stringlist_param_value):
+case YY_STATE_EOF(keyword):
+case YY_STATE_EOF(line_start):
+case YY_STATE_EOF(component):
+case YY_STATE_EOF(seperator):
+case YY_STATE_EOF(parameter):
+case YY_STATE_EOF(end_of_value):
+case YY_STATE_EOF(paramtext):
+        yyterminate();
+
+        case YY_END_OF_BUFFER:
+                {
+                /* Amount of text matched not including the EOB char. */
+                int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
+
+                /* Undo the effects of YY_DO_BEFORE_ACTION. */
+                *yy_cp = yy_hold_char;
+                YY_RESTORE_YY_MORE_OFFSET
+
+                if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
+                        {
+                        /* We're scanning a new file or input source.  It's
+                         * possible that this happened because the user
+                         * just pointed yyin at a new source and called
+                         * yylex().  If so, then we have to assure
+                         * consistency between yy_current_buffer and our
+                         * globals.  Here is the right place to do so, because
+                         * this is the first action (other than possibly a
+                         * back-up) that will match for the new input source.
+                         */
+                        yy_n_chars = yy_current_buffer->yy_n_chars;
+                        yy_current_buffer->yy_input_file = yyin;
+                        yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
+                        }
+
+                /* Note that here we test for yy_c_buf_p "<=" to the position
+                 * of the first EOB in the buffer, since yy_c_buf_p will
+                 * already have been incremented past the NUL character
+                 * (since all states make transitions on EOB to the
+                 * end-of-buffer state).  Contrast this with the test
+                 * in input().
+                 */
+                if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
+                        { /* This was really a NUL. */
+                        yy_state_type yy_next_state;
+
+                        yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
+
+                        yy_current_state = yy_get_previous_state();
+
+                        /* Okay, we're now positioned to make the NUL
+                         * transition.  We couldn't have
+                         * yy_get_previous_state() go ahead and do it
+                         * for us because it doesn't know how to deal
+                         * with the possibility of jamming (and we don't
+                         * want to build jamming into it because then it
+                         * will run more slowly).
+                         */
+
+                        yy_next_state = yy_try_NUL_trans( yy_current_state );
+
+                        yy_bp = yytext_ptr + YY_MORE_ADJ;
+
+                        if ( yy_next_state )
+                                {
+                                /* Consume the NUL. */
+                                yy_cp = ++yy_c_buf_p;
+                                yy_current_state = yy_next_state;
+                                goto yy_match;
+                                }
+
+                        else
+                                {
+                                yy_cp = yy_c_buf_p;
+                                goto yy_find_action;
+                                }
+                        }
+
+                else switch ( yy_get_next_buffer() )
+                        {
+                        case EOB_ACT_END_OF_FILE:
+                                {
+                                yy_did_buffer_switch_on_eof = 0;
+
+                                if ( yywrap() )
+                                        {
+                                        /* Note: because we've taken care in
+                                         * yy_get_next_buffer() to have set up
+                                         * yytext, we can now set up
+                                         * yy_c_buf_p so that if some total
+                                         * hoser (like flex itself) wants to
+                                         * call the scanner after we return the
+                                         * YY_NULL, it'll still work - another
+                                         * YY_NULL will get returned.
+                                         */
+                                        yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
+
+                                        yy_act = YY_STATE_EOF(YY_START);
+                                        goto do_action;
+                                        }
+
+                                else
+                                        {
+                                        if ( ! yy_did_buffer_switch_on_eof )
+                                                YY_NEW_FILE;
+                                        }
+                                break;
+                                }
+
+                        case EOB_ACT_CONTINUE_SCAN:
+                                yy_c_buf_p =
+                                        yytext_ptr + yy_amount_of_matched_text;
+
+                                yy_current_state = yy_get_previous_state();
+
+                                yy_cp = yy_c_buf_p;
+                                yy_bp = yytext_ptr + YY_MORE_ADJ;
+                                goto yy_match;
+
+                        case EOB_ACT_LAST_MATCH:
+                                yy_c_buf_p =
+                                &yy_current_buffer->yy_ch_buf[yy_n_chars];
+
+                                yy_current_state = yy_get_previous_state();
+
+                                yy_cp = yy_c_buf_p;
+                                yy_bp = yytext_ptr + YY_MORE_ADJ;
+                                goto yy_find_action;
+                        }
+                break;
+                }
+
+        default:
+                YY_FATAL_ERROR(
+                        "fatal flex scanner internal error--no action found" );
+        } /* end of action switch */
+                } /* end of scanning one token */
+        } /* end of yylex */
+
+
+/* yy_get_next_buffer - try to read in a new buffer
+ *
+ * Returns a code representing an action:
+         *EOB_ACT_LAST_MATCH -
+         *EOB_ACT_CONTINUE_SCAN - continue scanning from current position
+         *EOB_ACT_END_OF_FILE - end of file
+ */
+
+static int yy_get_next_buffer()
+        {
+        register char *dest = yy_current_buffer->yy_ch_buf;
+        register char *source = yytext_ptr;
+        register int number_to_move, i;
+        int ret_val;
+
+        if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
+                YY_FATAL_ERROR(
+                "fatal flex scanner internal error--end of buffer missed" );
+
+        if ( yy_current_buffer->yy_fill_buffer == 0 )
+                { /* Don't try to fill the buffer, so this is an EOF. */
+                if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
+                        {
+                        /* We matched a single character, the EOB, so
+                         * treat this as a final EOF.
+                         */
+                        return EOB_ACT_END_OF_FILE;
+                        }
+
+                else
+                        {
+                        /* We matched some text prior to the EOB, first
+                         * process it.
+                         */
+                        return EOB_ACT_LAST_MATCH;
+                        }
+                }
+
+        /* Try to read more data. */
+
+        /* First move last chars to start of buffer. */
+        number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
+
+        for ( i = 0; i < number_to_move; ++i )
+                *(dest++) = *(source++);
+
+        if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
+                /* don't do the read, it's not guaranteed to return an EOF,
+                 * just force an EOF
+                 */
+                yy_current_buffer->yy_n_chars = yy_n_chars = 0;
+
+        else
+                {
+                int num_to_read =
+                        yy_current_buffer->yy_buf_size - number_to_move - 1;
+
+                while ( num_to_read <= 0 )
+                        { /* Not enough room in the buffer - grow it. */
+#ifdef YY_USES_REJECT
+                        YY_FATAL_ERROR(
+"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
+#else
+
+                        /* just a shorter name for the current buffer */
+                        YY_BUFFER_STATE b = yy_current_buffer;
+
+                        int yy_c_buf_p_offset =
+                                (int) (yy_c_buf_p - b->yy_ch_buf);
+
+                        if ( b->yy_is_our_buffer )
+                                {
+                                int new_size = b->yy_buf_size * 2;
+
+                                if ( new_size <= 0 )
+                                        b->yy_buf_size += b->yy_buf_size / 8;
+                                else
+                                        b->yy_buf_size *= 2;
+
+                                b->yy_ch_buf = (char *)
+                                        /* Include room in for 2 EOB chars. */
+                                        yy_flex_realloc( (void *) b->yy_ch_buf,
+                                                         b->yy_buf_size + 2 );
+                                }
+                        else
+                                /* Can't grow it, we don't own it. */
+                                b->yy_ch_buf = 0;
+
+                        if ( ! b->yy_ch_buf )
+                                YY_FATAL_ERROR(
+                                "fatal error - scanner input buffer overflow" );
+
+                        yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
+
+                        num_to_read = yy_current_buffer->yy_buf_size -
+                                                number_to_move - 1;
+#endif
+                        }
+
+                if ( num_to_read > YY_READ_BUF_SIZE )
+                        num_to_read = YY_READ_BUF_SIZE;
+
+                /* Read in more data. */
+                YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
+                        yy_n_chars, num_to_read );
+
+                yy_current_buffer->yy_n_chars = yy_n_chars;
+                }
+
+        if ( yy_n_chars == 0 )
+                {
+                if ( number_to_move == YY_MORE_ADJ )
+                        {
+                        ret_val = EOB_ACT_END_OF_FILE;
+                        yyrestart( yyin );
+                        }
+
+                else
+                        {
+                        ret_val = EOB_ACT_LAST_MATCH;
+                        yy_current_buffer->yy_buffer_status =
+                                YY_BUFFER_EOF_PENDING;
+                        }
+                }
+
+        else
+                ret_val = EOB_ACT_CONTINUE_SCAN;
+
+        yy_n_chars += number_to_move;
+        yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
+        yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
+
+        yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
+
+        return ret_val;
+        }
+
+
+/* yy_get_previous_state - get the state just before the EOB char was reached */
+
+static yy_state_type yy_get_previous_state()
+        {
+        register yy_state_type yy_current_state;
+        register char *yy_cp;
+
+        yy_current_state = yy_start;
+
+        for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
+                {
+                register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
+                if ( yy_accept[yy_current_state] )
+                        {
+                        yy_last_accepting_state = yy_current_state;
+                        yy_last_accepting_cpos = yy_cp;
+                        }
+                while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+                        {
+                        yy_current_state = (int) yy_def[yy_current_state];
+                        if ( yy_current_state >= 67 )
+                                yy_c = yy_meta[(unsigned int) yy_c];
+                        }
+                yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+                }
+
+        return yy_current_state;
+        }
+
+
+/* yy_try_NUL_trans - try to make a transition on the NUL character
+ *
+ * synopsis
+         *next_state = yy_try_NUL_trans( current_state );
+ */
+
+#ifdef YY_USE_PROTOS
+static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
+#else
+static yy_state_type yy_try_NUL_trans( yy_current_state )
+yy_state_type yy_current_state;
+#endif
+        {
+        register int yy_is_jam;
+        register char *yy_cp = yy_c_buf_p;
+
+        register YY_CHAR yy_c = 1;
+        if ( yy_accept[yy_current_state] )
+                {
+                yy_last_accepting_state = yy_current_state;
+                yy_last_accepting_cpos = yy_cp;
+                }
+        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+                {
+                yy_current_state = (int) yy_def[yy_current_state];
+                if ( yy_current_state >= 67 )
+                        yy_c = yy_meta[(unsigned int) yy_c];
+                }
+        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+        yy_is_jam = (yy_current_state == 66);
+
+        return yy_is_jam ? 0 : yy_current_state;
+        }
+
+
+#ifndef YY_NO_UNPUT
+#ifdef YY_USE_PROTOS
+static void yyunput( int c, register char *yy_bp )
+#else
+static void yyunput( c, yy_bp )
+int c;
+register char *yy_bp;
+#endif
+        {
+        register char *yy_cp = yy_c_buf_p;
+
+        /* undo effects of setting up yytext */
+        *yy_cp = yy_hold_char;
+
+        if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
+                { /* need to shift things up to make room */
+                /* +2 for EOB chars. */
+                register int number_to_move = yy_n_chars + 2;
+                register char *dest = &yy_current_buffer->yy_ch_buf[
+                                        yy_current_buffer->yy_buf_size + 2];
+                register char *source =
+                                &yy_current_buffer->yy_ch_buf[number_to_move];
+
+                while ( source > yy_current_buffer->yy_ch_buf )
+                        *--dest = *--source;
+
+                yy_cp += (int) (dest - source);
+                yy_bp += (int) (dest - source);
+                yy_current_buffer->yy_n_chars =
+                        yy_n_chars = yy_current_buffer->yy_buf_size;
+
+                if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
+                        YY_FATAL_ERROR( "flex scanner push-back overflow" );
+                }
+
+        *--yy_cp = (char) c;
+
+
+        yytext_ptr = yy_bp;
+        yy_hold_char = *yy_cp;
+        yy_c_buf_p = yy_cp;
+        }
+        #endif/* ifndef YY_NO_UNPUT */
+
+
+#ifdef __cplusplus
+static int yyinput()
+#else
+static int input()
+#endif
+        {
+        int c;
+
+        *yy_c_buf_p = yy_hold_char;
+
+        if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
+                {
+                /* yy_c_buf_p now points to the character we want to return.
+                 * If this occurs *before* the EOB characters, then it's a
+                 * valid NUL; if not, then we've hit the end of the buffer.
+                 */
+                if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
+                        /* This was really a NUL. */
+                        *yy_c_buf_p = '\0';
+
+                else
+                        { /* need more input */
+                        int offset = yy_c_buf_p - yytext_ptr;
+                        ++yy_c_buf_p;
+
+                        switch ( yy_get_next_buffer() )
+                                {
+                                case EOB_ACT_LAST_MATCH:
+                                        /* This happens because yy_g_n_b()
+                                         * sees that we've accumulated a
+                                         * token and flags that we need to
+                                         * try matching the token before
+                                         * proceeding.  But for input(),
+                                         * there's no matching to consider.
+                                         * So convert the EOB_ACT_LAST_MATCH
+                                         * to EOB_ACT_END_OF_FILE.
+                                         */
+
+                                        /* Reset buffer status. */
+                                        yyrestart( yyin );
+
+                                        /* fall through */
+
+                                case EOB_ACT_END_OF_FILE:
+                                        {
+                                        if ( yywrap() )
+                                                return EOF;
+
+                                        if ( ! yy_did_buffer_switch_on_eof )
+                                                YY_NEW_FILE;
+#ifdef __cplusplus
+                                        return yyinput();
+#else
+                                        return input();
+#endif
+                                        }
+
+                                case EOB_ACT_CONTINUE_SCAN:
+                                        yy_c_buf_p = yytext_ptr + offset;
+                                        break;
+                                }
+                        }
+                }
+
+                c = *(unsigned char *) yy_c_buf_p;/* cast for 8-bit char's */
+                *yy_c_buf_p = '\0';/* preserve yytext */
+        yy_hold_char = *++yy_c_buf_p;
+
+
+        return c;
+        }
+
+
+#ifdef YY_USE_PROTOS
+void yyrestart( FILE *input_file )
+#else
+void yyrestart( input_file )
+FILE *input_file;
+#endif
+        {
+        if ( ! yy_current_buffer )
+                yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
+
+        yy_init_buffer( yy_current_buffer, input_file );
+        yy_load_buffer_state();
+        }
+
+
+#ifdef YY_USE_PROTOS
+void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
+#else
+void yy_switch_to_buffer( new_buffer )
+YY_BUFFER_STATE new_buffer;
+#endif
+        {
+        if ( yy_current_buffer == new_buffer )
+                return;
+
+        if ( yy_current_buffer )
+                {
+                /* Flush out information for old buffer. */
+                *yy_c_buf_p = yy_hold_char;
+                yy_current_buffer->yy_buf_pos = yy_c_buf_p;
+                yy_current_buffer->yy_n_chars = yy_n_chars;
+                }
+
+        yy_current_buffer = new_buffer;
+        yy_load_buffer_state();
+
+        /* We don't actually know whether we did this switch during
+         * EOF (yywrap()) processing, but the only time this flag
+         * is looked at is after yywrap() is called, so it's safe
+         * to go ahead and always set it.
+         */
+        yy_did_buffer_switch_on_eof = 1;
+        }
+
+
+#ifdef YY_USE_PROTOS
+void yy_load_buffer_state( void )
+#else
+void yy_load_buffer_state()
+#endif
+        {
+        yy_n_chars = yy_current_buffer->yy_n_chars;
+        yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
+        yyin = yy_current_buffer->yy_input_file;
+        yy_hold_char = *yy_c_buf_p;
+        }
+
+
+#ifdef YY_USE_PROTOS
+YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
+#else
+YY_BUFFER_STATE yy_create_buffer( file, size )
+FILE *file;
+int size;
+#endif
+        {
+        YY_BUFFER_STATE b;
+
+        b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
+        if ( ! b )
+                YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+
+        b->yy_buf_size = size;
+
+        /* yy_ch_buf has to be 2 characters longer than the size given because
+         * we need to put in 2 end-of-buffer characters.
+         */
+        b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
+        if ( ! b->yy_ch_buf )
+                YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+
+        b->yy_is_our_buffer = 1;
+
+        yy_init_buffer( b, file );
+
+        return b;
+        }
+
+
+#ifdef YY_USE_PROTOS
+void yy_delete_buffer( YY_BUFFER_STATE b )
+#else
+void yy_delete_buffer( b )
+YY_BUFFER_STATE b;
+#endif
+        {
+        if ( ! b )
+                return;
+
+        if ( b == yy_current_buffer )
+                yy_current_buffer = (YY_BUFFER_STATE) 0;
+
+        if ( b->yy_is_our_buffer )
+                yy_flex_free( (void *) b->yy_ch_buf );
+
+        yy_flex_free( (void *) b );
+        }
+
+
+#ifndef YY_ALWAYS_INTERACTIVE
+#ifndef YY_NEVER_INTERACTIVE
+
+#ifndef _WIN32
+#include <unistd.h>
+#else
+#include <io.h>
+#include <stdio.h>
+
+#endif
+
+#endif
+#endif
+
+#ifdef YY_USE_PROTOS
+void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
+#else
+void yy_init_buffer( b, file )
+YY_BUFFER_STATE b;
+FILE *file;
+#endif
+
+
+        {
+        yy_flush_buffer( b );
+
+        b->yy_input_file = file;
+        b->yy_fill_buffer = 1;
+
+#if YY_ALWAYS_INTERACTIVE
+        b->yy_is_interactive = 1;
+#else
+#if YY_NEVER_INTERACTIVE
+        b->yy_is_interactive = 0;
+#else
+
+#ifdef _WIN32
+        b->yy_is_interactive = file ? (_isatty( fileno(file) ) > 0) : 0;
+#else
+        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
+#endif
+
+#endif
+#endif
+        }
+
+
+#ifdef YY_USE_PROTOS
+void yy_flush_buffer( YY_BUFFER_STATE b )
+#else
+void yy_flush_buffer( b )
+YY_BUFFER_STATE b;
+#endif
+
+        {
+        if ( ! b )
+                return;
+
+        b->yy_n_chars = 0;
+
+        /* We always need two end-of-buffer characters.  The first causes
+         * a transition to the end-of-buffer state.  The second causes
+         * a jam in that state.
+         */
+        b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
+        b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
+
+        b->yy_buf_pos = &b->yy_ch_buf[0];
+
+        b->yy_at_bol = 1;
+        b->yy_buffer_status = YY_BUFFER_NEW;
+
+        if ( b == yy_current_buffer )
+                yy_load_buffer_state();
+        }
+
+
+#ifndef YY_NO_SCAN_BUFFER
+#ifdef YY_USE_PROTOS
+YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
+#else
+YY_BUFFER_STATE yy_scan_buffer( base, size )
+char *base;
+yy_size_t size;
+#endif
+        {
+        YY_BUFFER_STATE b;
+
+        if ( size < 2 ||
+             base[size-2] != YY_END_OF_BUFFER_CHAR ||
+             base[size-1] != YY_END_OF_BUFFER_CHAR )
+                /* They forgot to leave room for the EOB's. */
+                return 0;
+
+        b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
+        if ( ! b )
+                YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
+
+                b->yy_buf_size = size - 2;/* "- 2" to take care of EOB's */
+        b->yy_buf_pos = b->yy_ch_buf = base;
+        b->yy_is_our_buffer = 0;
+        b->yy_input_file = 0;
+        b->yy_n_chars = b->yy_buf_size;
+        b->yy_is_interactive = 0;
+        b->yy_at_bol = 1;
+        b->yy_fill_buffer = 0;
+        b->yy_buffer_status = YY_BUFFER_NEW;
+
+        yy_switch_to_buffer( b );
+
+        return b;
+        }
+#endif
+
+
+#ifndef YY_NO_SCAN_STRING
+#ifdef YY_USE_PROTOS
+YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
+#else
+YY_BUFFER_STATE yy_scan_string( yy_str )
+yyconst char *yy_str;
+#endif
+        {
+        int len;
+        for ( len = 0; yy_str[len]; ++len )
+                ;
+
+        return yy_scan_bytes( yy_str, len );
+        }
+#endif
+
+
+#ifndef YY_NO_SCAN_BYTES
+#ifdef YY_USE_PROTOS
+YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
+#else
+YY_BUFFER_STATE yy_scan_bytes( bytes, len )
+yyconst char *bytes;
+int len;
+#endif
+        {
+        YY_BUFFER_STATE b;
+        char *buf;
+        yy_size_t n;
+        int i;
+
+        /* Get memory for full buffer, including space for trailing EOB's. */
+        n = len + 2;
+        buf = (char *) yy_flex_alloc( n );
+        if ( ! buf )
+                YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
+
+        for ( i = 0; i < len; ++i )
+                buf[i] = bytes[i];
+
+        buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
+
+        b = yy_scan_buffer( buf, n );
+        if ( ! b )
+                YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
+
+        /* It's okay to grow etc. this buffer, and we should throw it
+         * away when we're done.
+         */
+        b->yy_is_our_buffer = 1;
+
+        return b;
+        }
+#endif
+
+
+#ifndef YY_NO_PUSH_STATE
+#ifdef YY_USE_PROTOS
+static void yy_push_state( int new_state )
+#else
+static void yy_push_state( new_state )
+int new_state;
+#endif
+        {
+        if ( yy_start_stack_ptr >= yy_start_stack_depth )
+                {
+                yy_size_t new_size;
+
+                yy_start_stack_depth += YY_START_STACK_INCR;
+                new_size = yy_start_stack_depth * sizeof( int );
+
+                if ( ! yy_start_stack )
+                        yy_start_stack = (int *) yy_flex_alloc( new_size );
+
+                else
+                        yy_start_stack = (int *) yy_flex_realloc(
+                                        (void *) yy_start_stack, new_size );
+
+                if ( ! yy_start_stack )
+                        YY_FATAL_ERROR(
+                        "out of memory expanding start-condition stack" );
+                }
+
+        yy_start_stack[yy_start_stack_ptr++] = YY_START;
+
+        BEGIN(new_state);
+        }
+#endif
+
+
+#ifndef YY_NO_POP_STATE
+static void yy_pop_state()
+        {
+        if ( --yy_start_stack_ptr < 0 )
+                YY_FATAL_ERROR( "start-condition stack underflow" );
+
+        BEGIN(yy_start_stack[yy_start_stack_ptr]);
+        }
+#endif
+
+
+#ifndef YY_NO_TOP_STATE
+static int yy_top_state()
+        {
+        return yy_start_stack[yy_start_stack_ptr - 1];
+        }
+#endif
+
+#ifndef YY_EXIT_FAILURE
+#define YY_EXIT_FAILURE 2
+#endif
+
+#ifdef YY_USE_PROTOS
+static void yy_fatal_error( yyconst char msg[] )
+#else
+static void yy_fatal_error( msg )
+char msg[];
+#endif
+        {
+        (void) fprintf( stderr, "%s\n", msg );
+        exit( YY_EXIT_FAILURE );
+        }
+
+
+
+/* Redefine yyless() so it works in section 3 code. */
+
+#undef yyless
+#define yyless(n) \
+        do \
+                { \
+                /* Undo effects of setting up yytext. */ \
+                yytext[yyleng] = yy_hold_char; \
+                yy_c_buf_p = yytext + n; \
+                yy_hold_char = *yy_c_buf_p; \
+                *yy_c_buf_p = '\0'; \
+                yyleng = n; \
+                } \
+        while ( 0 )
+
+
+/* Internal utility routines. */
+
+#ifndef yytext_ptr
+#ifdef YY_USE_PROTOS
+static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
+#else
+static void yy_flex_strncpy( s1, s2, n )
+char *s1;
+yyconst char *s2;
+int n;
+#endif
+        {
+        register int i;
+        for ( i = 0; i < n; ++i )
+                s1[i] = s2[i];
+        }
+#endif
+
+#ifdef YY_NEED_STRLEN
+#ifdef YY_USE_PROTOS
+static int yy_flex_strlen( yyconst char *s )
+#else
+static int yy_flex_strlen( s )
+yyconst char *s;
+#endif
+        {
+        register int n;
+        for ( n = 0; s[n]; ++n )
+                ;
+
+        return n;
+        }
+#endif
+
+
+#ifdef YY_USE_PROTOS
+static void *yy_flex_alloc( yy_size_t size )
+#else
+static void *yy_flex_alloc( size )
+yy_size_t size;
+#endif
+        {
+        return (void *) malloc( size );
+        }
+
+#ifdef YY_USE_PROTOS
+static void *yy_flex_realloc( void *ptr, yy_size_t size )
+#else
+static void *yy_flex_realloc( ptr, size )
+void *ptr;
+yy_size_t size;
+#endif
+        {
+        /* The cast to (char *) in the following accommodates both
+         * implementations that use char* generic pointers, and those
+         * that use void* generic pointers.  It works with the latter
+         * because both ANSI C and C++ allow castless assignment from
+         * any pointer type to void*, and deal with argument conversions
+         * as though doing an assignment.
+         */
+        return (void *) realloc( (char *) ptr, size );
+        }
+
+#ifdef YY_USE_PROTOS
+static void yy_flex_free( void *ptr )
+#else
+static void yy_flex_free( ptr )
+void *ptr;
+#endif
+        {
+        free( ptr );
+        }
+
+#if YY_MAIN
+int main()
+        {
+        yylex();
+        return 0;
+        }
+#endif
+#line 132 "../../../../libical/src/libical/icallexer.l"
+
+
+int yywrap()
+{
+     return 1;
+}
+
+
+void set_parser_value_state(icalvalue_kind kind)
+{
+
+    switch (kind){
+
+        case ICAL_UTCOFFSET_VALUE:
+            {BEGIN(utcoffset_value);break;}
+
+        case ICAL_DATETIMEPERIOD_VALUE:
+        case ICAL_DURATION_VALUE:
+        case ICAL_PERIOD_VALUE:
+            {BEGIN(time_value);break;}
+
+        default:
+        {
+           assert(1==0);
+        }
+    }
+}
+
+void init_str_buf(void)
+{
+   str_buf = icalmemory_tmp_buffer(ICAL_MAX_STR_CONST);
+   str_buf_p = str_buf;
+   buf_sz = ICAL_MAX_STR_CONST;
+
+
+}
+
diff --git a/libical/src/libical/icallexer.l b/libical/src/libical/icallexer.l
new file mode 100644
index 0000000..53b396a
--- a/dev/null
+++ b/libical/src/libical/icallexer.l
@@ -0,0 +1,170 @@
+%{
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: icallexer.l
+  CREATOR: eric 10 June 1999
+  
+  DESCRIPTION:
+  
+  $Id$
+  $Locker$
+
+  (C) COPYRIGHT 1999 Eric Busboom 
+  http://www.softwarestudio.org
+
+  The contents of this file are subject to the Mozilla Public License
+  Version 1.0 (the "License"); you may not use this file except in
+  compliance with the License. You may obtain a copy of the License at
+  http://www.mozilla.org/MPL/
+ 
+  Software distributed under the License is distributed on an "AS IS"
+  basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+  the License for the specific language governing rights and
+  limitations under the License.
+
+  The original author is Eric Busboom
+  The original code is icalitip.y
+
+
+
+  ======================================================================*/
+#include "icalparser.h"
+#include "icalenums.h"
+#include "icalmemory.h"
+#include "assert.h"
+#include "icalyacc.h"
+
+#include <string.h> /* For strdup() */
+#include <stdlib.h>
+#include <math.h>
+
+int icalparser_flex_input(char* buf, int max_size);
+void icalparser_clear_flex_input(void);
+
+
+#define ICAL_MAX_STR_CONST 1024
+
+#undef YY_INPUT
+#define YY_INPUT(b,r,ms) ( r= icalparser_flex_input(b,ms))
+#undef yywrap
+
+#undef YY_FATAL_ERROR
+#define YY_FATAL_ERROR(msg) ical_yyerror(msg)
+
+icalvalue_kind value_kind=ICAL_NO_VALUE;
+void set_parser_value_state(icalvalue_kind kind);
+extern int yydebug; 
+
+void ical_yyerror(char *s);
+
+void init_str_buf(void);
+
+int last_state;
+
+char *str_buf;
+char *str_buf_p;
+size_t buf_sz; /* = ICAL_MAX_STR_CONST;*/
+
+/* Define routines that were not propertly defined because of the
+renaming hack applied in icalyacc.y */
+YY_BUFFER_STATE ical_yy_scan_buffer ( char *base, yy_size_t size );
+YY_BUFFER_STATE ical_yy_scan_string ( yyconst char *yy_str );
+YY_BUFFER_STATE ical_yy_scan_bytes ( yyconst char *bytes, int len );
+
+%}
+
+        crlf    \x0D?\x0A
+        space   [ ]
+        qsafechar[^\x00-\x1F\"]
+        safechar[^\x00-\x1F\"\:\;\,]
+        tsafechar[\x20-\x21\x23-\x2B\x2D-\x39\x3C-\x5B\x5D-\x7E]
+        valuechar[^\x00-\x08\x10-\x1F]
+        xname   X-[a-zA-Z0-9\-]+
+xname2          [a-zA-Z0-9\-\ ]
+        paramtext{safechar}+
+        value   {valuechar}+
+        quotedstring\"{qsafechar}+\"
+        digit   [0-9]
+
+%array /* Make yytext an array. Slow, but handy. HACK */
+
+%option caseless
+
+%s quoted_string
+%s binary_value boolean_value uri_value time_value duration_value number_value period_value recur_value text_value utcoffset_value
+%s enum_param_value string_param_value stringlist_param_value keyword line_start component seperator parameter end_of_value paramtext
+
+
+
+%%
+
+%{
+%}
+
+
+
+<time_value>{
+        {digit}+         { ical_yylval.v_string =icalmemory_tmp_copy(yytext) ;
+                           return DIGITS; }
+        T                { return TIME_CHAR; }
+        Z                { return UTC_CHAR; }
+        [\/\+\-PWHMSD]   { return yytext[0]; }
+{crlf}                   { return EOL;}
+
+}
+
+<utcoffset_value>{
+{crlf}                   { return EOL;}
+        \-|\+            { return yytext[0]; }
+        {digit}{digit}   { ical_yylval.v_int=atoi(yytext); return INTNUMBER; }
+
+}
+
+<enum_param_value>{
+        .                { return CHARACTER; }
+{crlf}                   { return EOL;}
+
+}
+
+<seperator>{
+,       { BEGIN(last_state); return COMMA; } 
+}
+
+
+%% 
+
+int yywrap()
+{
+     return 1;
+}
+
+
+void set_parser_value_state(icalvalue_kind kind)
+{
+
+    switch (kind){
+
+        case ICAL_UTCOFFSET_VALUE:
+            {BEGIN(utcoffset_value);break;}
+
+        case ICAL_DATETIMEPERIOD_VALUE:
+        case ICAL_DURATION_VALUE:
+        case ICAL_PERIOD_VALUE:
+            {BEGIN(time_value);break;}
+
+        default:
+        {
+           assert(1==0);
+        }
+    }
+}
+
+void init_str_buf(void)
+{
+   str_buf = icalmemory_tmp_buffer(ICAL_MAX_STR_CONST);
+   str_buf_p = str_buf;
+   buf_sz = ICAL_MAX_STR_CONST;
+
+
+}
+
diff --git a/libical/src/libical/icalmemory.c b/libical/src/libical/icalmemory.c
new file mode 100644
index 0000000..297ead8
--- a/dev/null
+++ b/libical/src/libical/icalmemory.c
@@ -0,0 +1,287 @@
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: icalmemory.c
+  CREATOR: eric 30 June 1999
+  
+  $Id$
+  $Locker$
+    
+ The contents of this file are subject to the Mozilla Public License
+ Version 1.0 (the "License"); you may not use this file except in
+ compliance with the License. You may obtain a copy of the License at
+ http://www.mozilla.org/MPL/
+ 
+ Software distributed under the License is distributed on an "AS IS"
+ basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+ the License for the specific language governing rights and
+ limitations under the License.
+ 
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is icalmemory.h
+
+ ======================================================================*/
+
+/* libical often passes strings back to the caller. To make these
+ * interfaces simple, I did not want the caller to have to pass in a
+ * memory buffer, but having libical pass out newly allocated memory
+ * makes it difficult to de-allocate the memory.
+ * 
+ * The ring buffer in this scheme makes it possible for libical to pass
+ * out references to memory which the caller does not own, and be able
+ * to de-allocate the memory later. The ring allows libical to have
+ * several buffers active simultaneously, which is handy when creating
+ * string representations of components. */
+
+#define ICALMEMORY_C
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#ifdef DMALLOC
+#include "dmalloc.h"
+#endif
+
+#include "icalmemory.h"
+#include "icalerror.h"
+
+#include <stdio.h> /* for printf (debugging) */
+#include <stdlib.h> /* for malloc, realloc */
+#include <string.h> /* for memset(), strdup */
+
+#define BUFFER_RING_SIZE 25
+#define MIN_BUFFER_SIZE 200
+
+void icalmemory_free_tmp_buffer (void* buf);
+
+
+/* HACK. Not threadsafe */
+void* buffer_ring[BUFFER_RING_SIZE];
+int buffer_pos = -1;
+int initialized = 0;
+
+/* Add an existing buffer to the buffer ring */
+void  icalmemory_add_tmp_buffer(void* buf)
+{
+    /* I don't think I need this -- I think static arrays are
+       initialized to 0 as a standard part of C, but I am not sure. */
+    if (initialized == 0){
+        int i;
+        for(i=0; i<BUFFER_RING_SIZE; i++){
+            buffer_ring[i]  = 0;
+        }
+        initialized = 1;
+    }
+
+    /* Wrap around the ring */
+    if(++buffer_pos == BUFFER_RING_SIZE){
+        buffer_pos = 0;
+    }
+
+    /* Free buffers as their slots are overwritten */
+    if ( buffer_ring[buffer_pos] != 0){
+        free( buffer_ring[buffer_pos]);
+        buffer_ring[buffer_pos] = 0;
+    }
+
+    /* Assign the buffer to a slot */
+    buffer_ring[buffer_pos] = buf; 
+}
+
+/* Create a new temporary buffer on the ring. Libical owns these and
+   wil deallocate them. */
+void*
+icalmemory_tmp_buffer (size_t size)
+{
+    char *buf;
+
+    if (size < MIN_BUFFER_SIZE){
+        size = MIN_BUFFER_SIZE;
+    }
+    
+    buf = (void*)malloc(size);
+
+    if( buf == 0){
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        return 0;
+    }
+
+    memset(buf,0,size); 
+
+    icalmemory_add_tmp_buffer(buf);
+
+    return buf;
+}
+
+void icalmemory_free_ring()
+{
+        
+   int i;
+   for(i=0; i<BUFFER_RING_SIZE; i++){
+    if ( buffer_ring[i] != 0){
+       free( buffer_ring[i]);
+    }
+    buffer_ring[i]  = 0;
+   }
+
+   initialized = 1;
+
+}
+
+
+
+/* Like strdup, but the buffer is on the ring. */
+char*
+icalmemory_tmp_copy(const char* str)
+{
+    char* b = icalmemory_tmp_buffer(strlen(str)+1);
+
+    strcpy(b,str);
+
+    return b;
+}
+    
+
+char* icalmemory_strdup(const char *s)
+{
+    return strdup(s);
+}
+
+void
+icalmemory_free_tmp_buffer (void* buf)
+{
+   if(buf == 0)
+   {
+       return;
+   }
+
+   free(buf);
+}
+
+
+/* These buffer routines create memory the old fashioned way -- so the
+   caller will have to delocate the new memory */
+
+void* icalmemory_new_buffer(size_t size)
+{
+    void *b = malloc(size);
+
+    if( b == 0){
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        return 0;
+    }
+
+    memset(b,0,size); 
+
+    return b;
+}
+
+void* icalmemory_resize_buffer(void* buf, size_t size)
+{
+    void *b = realloc(buf, size);
+
+    if( b == 0){
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        return 0;
+    }
+
+   return b;
+}
+
+void icalmemory_free_buffer(void* buf)
+{
+    free(buf);
+}
+
+void 
+icalmemory_append_string(char** buf, char** pos, size_t* buf_size, 
+                              const char* string)
+{
+    char *new_buf;
+    char *new_pos;
+
+    size_t data_length, final_length, string_length;
+
+#ifndef ICAL_NO_INTERNAL_DEBUG
+    icalerror_check_arg_rv( (buf!=0),"buf");
+    icalerror_check_arg_rv( (*buf!=0),"*buf");
+    icalerror_check_arg_rv( (pos!=0),"pos");
+    icalerror_check_arg_rv( (*pos!=0),"*pos");
+    icalerror_check_arg_rv( (buf_size!=0),"buf_size");
+    icalerror_check_arg_rv( (*buf_size!=0),"*buf_size");
+    icalerror_check_arg_rv( (string!=0),"string");
+#endif 
+
+    string_length = strlen(string);
+    data_length = (size_t)*pos - (size_t)*buf;    
+    final_length = data_length + string_length; 
+
+    if ( final_length >= (size_t) *buf_size) {
+
+        
+        *buf_size  = (*buf_size) * 2  + final_length;
+
+        new_buf = realloc(*buf,*buf_size);
+
+        new_pos = (void*)((size_t)new_buf + data_length);
+        
+        *pos = new_pos;
+        *buf = new_buf;
+    }
+    
+    strcpy(*pos, string);
+
+    *pos += string_length;
+}
+
+
+void 
+icalmemory_append_char(char** buf, char** pos, size_t* buf_size, 
+                              char ch)
+{
+    char *new_buf;
+    char *new_pos;
+
+    size_t data_length, final_length;
+
+#ifndef ICAL_NO_INTERNAL_DEBUG
+    icalerror_check_arg_rv( (buf!=0),"buf");
+    icalerror_check_arg_rv( (*buf!=0),"*buf");
+    icalerror_check_arg_rv( (pos!=0),"pos");
+    icalerror_check_arg_rv( (*pos!=0),"*pos");
+    icalerror_check_arg_rv( (buf_size!=0),"buf_size");
+    icalerror_check_arg_rv( (*buf_size!=0),"*buf_size");
+#endif
+
+    data_length = (size_t)*pos - (size_t)*buf;
+
+    final_length = data_length + 2; 
+
+    if ( final_length > (size_t) *buf_size ) {
+
+        
+        *buf_size  = (*buf_size) * 2  + final_length +1;
+
+        new_buf = realloc(*buf,*buf_size);
+
+        new_pos = (void*)((size_t)new_buf + data_length);
+        
+        *pos = new_pos;
+        *buf = new_buf;
+    }
+
+    **pos = ch;
+    *pos += 1;
+    **pos = 0;
+}
diff --git a/libical/src/libical/icalmemory.h b/libical/src/libical/icalmemory.h
new file mode 100644
index 0000000..f833c6c
--- a/dev/null
+++ b/libical/src/libical/icalmemory.h
@@ -0,0 +1,85 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalmemory.h
+ CREATOR: eric 30 June 1999
+
+
+ $Id$
+ $Locker$
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Initial Developer of the Original Code is Eric Busboom
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+======================================================================*/
+
+#ifndef ICALMEMORY_H
+#define ICALMEMORY_H
+
+#include <sys/types.h> /* for size_t */
+
+// Eugen C. <eug@thekompany.com>
+#ifdef _WIN32
+#include <stddef.h>
+#endif
+// Eugen C. <eug@thekompany.com>
+
+/* Tmp buffers are managed by ical. References can be returned to the
+   caller, although the caller will not own the memory. */
+
+void* icalmemory_tmp_buffer(size_t size);
+char* icalmemory_tmp_copy(const char* str);
+
+/* Add an externally allocated buffer to the ring. */
+void  icalmemory_add_tmp_buffer(void*);
+
+
+/* Free all memory used in the ring */
+void icalmemory_free_ring(void);
+
+/* Non-tmp buffers must be freed. These are mostly wrappers around
+ * malloc, etc, but are used so the caller can change the memory
+ * allocators in a future version of the library */
+
+void* icalmemory_new_buffer(size_t size);
+void* icalmemory_resize_buffer(void* buf, size_t size);
+void icalmemory_free_buffer(void* buf);
+
+/* icalmemory_append_string will copy the string 'string' to the
+   buffer 'buf' starting at position 'pos', reallocing 'buf' if it is
+   too small. 'buf_size' is the size of 'buf' and will be changed if
+   'buf' is reallocated. 'pos' will point to the last byte of the new
+   string in 'buf', usually a '\0' */
+
+/* THESE ROUTINES CAN NOT BE USED ON TMP BUFFERS. Only use them on
+   normally allocated memory, or on buffers created from
+   icalmemory_new_buffer, never with buffers created by
+   icalmemory_tmp_buffer. If icalmemory_append_string has to resize a
+   buffer on the ring, the ring will loose track of it an you will
+   have memory problems. */
+
+void icalmemory_append_string(char** buf, char** pos, size_t* buf_size, 
+                              const char* string);
+
+/*  icalmemory_append_char is similar, but is appends a character instead of a string */
+void icalmemory_append_char(char** buf, char** pos, size_t* buf_size, 
+                              char ch);
+
+/* A wrapper around strdup. Partly to trap calls to strdup, partly
+   because in -ansi, gcc on Red Hat claims that strudup is undeclared */
+char* icalmemory_strdup(const char *s);
+
+#endif /* !ICALMEMORY_H */
+
+
+
diff --git a/libical/src/libical/icalmime.c b/libical/src/libical/icalmime.c
new file mode 100644
index 0000000..7021746
--- a/dev/null
+++ b/libical/src/libical/icalmime.c
@@ -0,0 +1,388 @@
+/* -*- Mode: C -*-*/
+/*======================================================================
+ FILE: icalmime.c
+ CREATOR: eric 26 July 2000
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+======================================================================*/
+
+#include "icalmime.h"
+#include "icalerror.h"
+#include "icalmemory.h"
+#include "sspm.h"
+#include "stdlib.h"
+#include <string.h> /* For strdup */
+#include <stdio.h> /* for snprintf*/
+
+int snprintf(char *str, size_t n, char const *fmt, ...);
+
+#ifdef DMALLOC
+#include "dmalloc.h"
+#endif
+
+
+/* These *_part routines are called by the MIME parser via the
+   local_action_map */
+
+struct text_part
+{
+        char* buf;
+        char* buf_pos;
+        size_t buf_size;
+};
+
+void* icalmime_text_new_part()
+{
+
+#define BUF_SIZE 2048
+
+    struct text_part* impl;
+
+    if ( ( impl = (struct text_part*)
+           malloc(sizeof(struct text_part))) == 0) {
+        return 0;
+    }
+
+    impl->buf =  icalmemory_new_buffer(BUF_SIZE);
+    impl->buf_pos = impl->buf;
+    impl->buf_size = BUF_SIZE;
+
+    return impl;    
+}
+void icalmime_text_add_line(void *part, 
+                            struct sspm_header *header, 
+                            char* line, size_t size)
+{
+    struct text_part* impl = (struct text_part*) part;
+
+    icalmemory_append_string(&(impl->buf),&(impl->buf_pos),
+                             &(impl->buf_size),line);
+    
+}
+
+void* icalmime_textcalendar_end_part(void* part)
+{
+
+    struct text_part* impl = (struct text_part*) part;
+    icalcomponent *c = icalparser_parse_string(impl->buf);
+
+    icalmemory_free_buffer(impl->buf);
+    free(impl);
+
+    return c;
+
+}
+
+void* icalmime_text_end_part(void* part)
+{
+    struct text_part* impl = ( struct text_part*) part;
+
+    icalmemory_add_tmp_buffer(impl->buf);
+    free(impl);
+
+    return impl->buf;
+}
+
+void icalmime_text_free_part(void *part)
+{
+    part = part;
+}
+
+
+/* Ignore Attachments for now */
+
+void* icalmime_attachment_new_part()
+{
+    return 0;
+}
+void icalmime_attachment_add_line(void *part, struct sspm_header *header, 
+                                  char* line, size_t size)
+{
+    part = part;
+    header = header;
+    line = line;
+    size = size;
+}
+
+void* icalmime_attachment_end_part(void* part)
+{
+    return 0;
+}
+
+void icalmime_attachment_free_part(void *part)
+{
+}
+
+
+
+
+struct sspm_action_map icalmime_local_action_map[] = 
+{
+    {SSPM_TEXT_MAJOR_TYPE,SSPM_CALENDAR_MINOR_TYPE,icalmime_text_new_part,icalmime_text_add_line,icalmime_textcalendar_end_part,icalmime_text_free_part},
+    {SSPM_TEXT_MAJOR_TYPE,SSPM_ANY_MINOR_TYPE,icalmime_text_new_part,icalmime_text_add_line,icalmime_text_end_part,icalmime_text_free_part},
+    {SSPM_TEXT_MAJOR_TYPE,SSPM_PLAIN_MINOR_TYPE,icalmime_text_new_part,icalmime_text_add_line,icalmime_text_end_part,icalmime_text_free_part},
+    {SSPM_APPLICATION_MAJOR_TYPE,SSPM_CALENDAR_MINOR_TYPE,icalmime_attachment_new_part,icalmime_attachment_add_line,icalmime_attachment_end_part,icalmime_attachment_free_part},
+    {SSPM_IMAGE_MAJOR_TYPE,SSPM_CALENDAR_MINOR_TYPE,icalmime_attachment_new_part,icalmime_attachment_add_line,icalmime_attachment_end_part,icalmime_attachment_free_part},
+    {SSPM_AUDIO_MAJOR_TYPE,SSPM_CALENDAR_MINOR_TYPE,icalmime_attachment_new_part,icalmime_attachment_add_line,icalmime_attachment_end_part,icalmime_attachment_free_part},
+    {SSPM_IMAGE_MAJOR_TYPE,SSPM_CALENDAR_MINOR_TYPE,icalmime_attachment_new_part,icalmime_attachment_add_line,icalmime_attachment_end_part,icalmime_attachment_free_part},
+   {SSPM_UNKNOWN_MAJOR_TYPE,SSPM_UNKNOWN_MINOR_TYPE,0,0,0,0}
+};
+
+#define NUM_PARTS 100 /* HACK. Hard Limit */
+
+
+
+struct sspm_part* icalmime_make_part(icalcomponent* comp)
+{
+    comp = comp;
+    return 0;
+}
+
+char* icalmime_as_mime_string(char* icalcomponent);
+
+icalcomponent* icalmime_parse(char* (*get_string)(char *s, size_t size, 
+                                                       void *d),
+                                void *data)
+{
+    struct sspm_part *parts;
+    int i, last_level=0;
+    icalcomponent *root=0, *parent=0, *comp=0, *last = 0;
+
+    if ( (parts = (struct sspm_part *)
+          malloc(NUM_PARTS*sizeof(struct sspm_part)))==0) {
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        return 0;
+    }
+
+    memset(parts,0,sizeof(parts));
+
+    sspm_parse_mime(parts, 
+                    NUM_PARTS, /* Max parts */
+                    icalmime_local_action_map, /* Actions */ 
+                    get_string,
+                    data, /* data for get_string*/
+                    0 /* First header */);
+
+
+
+    for(i = 0; i <NUM_PARTS && parts[i].header.major != SSPM_NO_MAJOR_TYPE ; i++){
+
+#define TMPSZ 1024
+                char mimetype[TMPSZ];                  
+        char* major = sspm_major_type_string(parts[i].header.major);
+        char* minor = sspm_minor_type_string(parts[i].header.minor);
+
+        if(parts[i].header.minor == SSPM_UNKNOWN_MINOR_TYPE ){
+            assert(parts[i].header.minor_text !=0);
+            minor = parts[i].header.minor_text;
+        }
+        
+        sprintf(mimetype,"%s/%s",major,minor);
+
+        comp = icalcomponent_new(ICAL_XLICMIMEPART_COMPONENT);
+
+        if(comp == 0){
+            /* HACK Handle Error */
+            assert(0);
+        }
+
+        if(parts[i].header.error!=SSPM_NO_ERROR){
+            char *str;
+            char* temp[256];
+
+            if(parts[i].header.error==SSPM_UNEXPECTED_BOUNDARY_ERROR){
+                str = "Got an unexpected boundary, possibly due to a MIME header for a MULTIPART part that is missing the Content-Type line";
+            }
+
+            if(parts[i].header.error==SSPM_WRONG_BOUNDARY_ERROR){
+                str = "Got the wrong boundary for the opening of a MULTIPART part.";
+            }
+
+            if(parts[i].header.error==SSPM_NO_BOUNDARY_ERROR){
+                str = "Got a multipart header that did not specify a boundary";
+            }
+
+            if(parts[i].header.error==SSPM_NO_HEADER_ERROR){
+                str = "Did not get a header for the part. Is there a blank\
+line between the header and the previous boundary\?";
+
+            }
+
+            if(parts[i].header.error_text != 0){
+                snprintf((char*)temp,256,
+                         "%s: %s",str,parts[i].header.error_text);
+            } else {
+                strcpy((char*)temp,str);
+            }
+
+            icalcomponent_add_property
+                (comp,
+                 icalproperty_vanew_xlicerror(
+                     (char*)temp,
+                     icalparameter_new_xlicerrortype(
+                         ICAL_XLICERRORTYPE_MIMEPARSEERROR),
+                     0));  
+        }
+
+        if(parts[i].header.major != SSPM_NO_MAJOR_TYPE &&
+           parts[i].header.major != SSPM_UNKNOWN_MAJOR_TYPE){
+
+            icalcomponent_add_property(comp,
+                icalproperty_new_xlicmimecontenttype((char*)
+                                icalmemory_strdup(mimetype)));
+
+        }
+
+        if (parts[i].header.encoding != SSPM_NO_ENCODING){
+
+            icalcomponent_add_property(comp,
+               icalproperty_new_xlicmimeencoding(
+                   sspm_encoding_string(parts[i].header.encoding)));
+        }
+
+        if (parts[i].header.filename != 0){
+            icalcomponent_add_property(comp,
+               icalproperty_new_xlicmimefilename(parts[i].header.filename));
+        }
+
+        if (parts[i].header.content_id != 0){
+            icalcomponent_add_property(comp,
+               icalproperty_new_xlicmimecid(parts[i].header.content_id));
+        }
+
+        if (parts[i].header.charset != 0){
+            icalcomponent_add_property(comp,
+               icalproperty_new_xlicmimecharset(parts[i].header.charset));
+        }
+
+        /* Add iCal components as children of the component */
+        if(parts[i].header.major == SSPM_TEXT_MAJOR_TYPE &&
+           parts[i].header.minor == SSPM_CALENDAR_MINOR_TYPE &&
+           parts[i].data != 0){
+
+            icalcomponent_add_component(comp,
+                                        (icalcomponent*)parts[i].data);
+            parts[i].data = 0;
+
+                } else if(parts[i].header.major == SSPM_TEXT_MAJOR_TYPE &&
+           parts[i].header.minor != SSPM_CALENDAR_MINOR_TYPE &&
+           parts[i].data != 0){
+
+            /* Add other text components as "DESCRIPTION" properties */
+
+            icalcomponent_add_property(comp,
+               icalproperty_new_description(
+                   (char*)icalmemory_strdup((char*)parts[i].data)));
+
+            parts[i].data = 0;
+        }
+        
+
+        if(root!= 0 && parts[i].level == 0){
+            /* We've already assigned the root, but there is another
+               part at the root level. This is probably a parse
+               error*/
+            icalcomponent_free(comp);
+            continue;
+        }
+
+        if(parts[i].level == last_level && last_level != 0){
+            icalerror_assert(parent!=0,"No parent for adding component");
+
+            icalcomponent_add_component(parent,comp);
+
+        } else if (parts[i].level == last_level && last_level == 0 &&
+            root == 0) {
+
+            root = comp;
+            parent = comp;
+
+                } else if (parts[i].level > last_level){    
+
+            parent = last;
+            icalcomponent_add_component(parent,comp);
+
+            last_level = parts[i].level;
+
+        } else if (parts[i].level < last_level){
+
+            parent = icalcomponent_get_parent(parent);
+            icalcomponent_add_component(parent,comp);
+
+            last_level = parts[i].level;
+        } else { 
+            assert(0);
+        }
+
+        last = comp;
+        last_level = parts[i].level;
+        assert(parts[i].data == 0);
+    }
+
+    sspm_free_parts(parts,NUM_PARTS);
+    free(parts);
+
+    return root;
+}
+
+
+
+int icalmime_test(char* (*get_string)(char *s, size_t size, void *d),
+                  void *data)
+{
+    char *out;
+    struct sspm_part *parts;
+    int i;
+
+    if ( (parts = (struct sspm_part *)
+          malloc(NUM_PARTS*sizeof(struct sspm_part)))==0) {
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        return 0;
+    }
+
+    memset(parts,0,sizeof(parts));
+
+    sspm_parse_mime(parts, 
+                    NUM_PARTS, /* Max parts */
+                    icalmime_local_action_map, /* Actions */ 
+                    get_string,
+                    data, /* data for get_string*/
+                    0 /* First header */);
+
+   for(i = 0; i <NUM_PARTS && parts[i].header.major != SSPM_NO_MAJOR_TYPE ; 
+       i++){
+       if(parts[i].header.minor == SSPM_CALENDAR_MINOR_TYPE){
+           parts[i].data = icalmemory_strdup(
+               icalcomponent_as_ical_string((icalcomponent*)parts[i].data));
+       }
+   }
+
+    sspm_write_mime(parts,NUM_PARTS,&out,"To: bob@bob.org");
+
+    printf("%s\n",out);
+
+    return 0;
+
+}
+
+
diff --git a/libical/src/libical/icalmime.h b/libical/src/libical/icalmime.h
new file mode 100644
index 0000000..b222888
--- a/dev/null
+++ b/libical/src/libical/icalmime.h
@@ -0,0 +1,43 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalmime.h
+ CREATOR: eric 26 July 2000
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+======================================================================*/
+
+#ifndef ICALMIME_H
+#define ICALMIME_H
+
+#include "icalcomponent.h"
+#include "icalparser.h"
+
+        icalcomponent* icalmime_parse(char* (*line_gen_func)(char *s, size_t size, 
+                                                       void *d),
+                                void *data);
+
+/* The inverse of icalmime_parse, not implemented yet. Use sspm.h directly.  */
+char* icalmime_as_mime_string(char* component);
+
+
+
+#endif /* !ICALMIME_H */
+
+
+
diff --git a/libical/src/libical/icalparameter.c b/libical/src/libical/icalparameter.c
new file mode 100644
index 0000000..156ecdb
--- a/dev/null
+++ b/libical/src/libical/icalparameter.c
@@ -0,0 +1,382 @@
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: icalderivedparameters.{c,h}
+  CREATOR: eric 09 May 1999
+  
+  $Id$
+  $Locker$
+    
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalderivedparameters.{c,h}
+
+  Contributions from:
+     Graham Davison (g.m.davison@computer.org)
+
+ ======================================================================*/
+/*#line 29 "icalparameter.c.in"*/
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+
+#include "icalparameter.h"
+#include "icalproperty.h"
+#include "icalerror.h"
+#include "icalmemory.h"
+#include "icalparameterimpl.h"
+
+#include <stdlib.h> /* for malloc() */
+#include <errno.h>
+#include <string.h> /* for memset() */
+
+/* In icalderivedparameter */
+icalparameter* icalparameter_new_from_value_string(icalparameter_kind kind,const  char* val);
+
+
+struct icalparameter_impl* icalparameter_new_impl(icalparameter_kind kind)
+{
+    struct icalparameter_impl* v;
+
+    if ( ( v = (struct icalparameter_impl*)
+           malloc(sizeof(struct icalparameter_impl))) == 0) {
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        return 0;
+    }
+    
+    strcpy(v->id,"para");
+
+    v->kind = kind;
+    v->size = 0;
+    v->string = 0;
+    v->x_name = 0;
+    v->parent = 0;
+    v->data = 0;
+
+    return v;
+}
+
+icalparameter*
+icalparameter_new (icalparameter_kind kind)
+{
+    struct icalparameter_impl* v = icalparameter_new_impl(kind);
+
+    return (icalparameter*) v;
+
+}
+
+void
+icalparameter_free (icalparameter* parameter)
+{
+    struct icalparameter_impl * impl;
+
+    impl = (struct icalparameter_impl*)parameter;
+
+/*  HACK. This always triggers, even when parameter is non-zero
+    icalerror_check_arg_rv((parameter==0),"parameter");*/
+
+
+#ifdef ICAL_FREE_ON_LIST_IS_ERROR
+    icalerror_assert( (impl->parent ==0),"Tried to free a parameter that is still attached to a component. ");
+    
+#else
+    if(impl->parent !=0){
+        return;
+    }
+#endif
+
+    
+    if (impl->string != 0){
+        free ((void*)impl->string);
+    }
+    
+    if (impl->x_name != 0){
+        free ((void*)impl->x_name);
+    }
+    
+    memset(impl,0,sizeof(impl));
+
+    impl->parent = 0;
+    impl->id[0] = 'X';
+    free(impl);
+}
+
+
+
+icalparameter* 
+icalparameter_new_clone(icalparameter* param)
+{
+    struct icalparameter_impl *old;
+    struct icalparameter_impl *new;
+
+    old = (struct icalparameter_impl *)param;
+    new = icalparameter_new_impl(old->kind);
+
+    icalerror_check_arg_rz((param!=0),"param");
+
+    if (new == 0){
+        return 0;
+    }
+
+    memcpy(new,old,sizeof(struct icalparameter_impl));
+
+    if (old->string != 0){
+        new->string = icalmemory_strdup(old->string);
+        if (new->string == 0){
+            icalparameter_free(new);
+            return 0;
+        }
+    }
+
+    if (old->x_name != 0){
+        new->x_name = icalmemory_strdup(old->x_name);
+        if (new->x_name == 0){
+            icalparameter_free(new);
+            return 0;
+        }
+    }
+
+    return new;
+}
+
+icalparameter* icalparameter_new_from_string(const char *str)
+{
+    char* eq;
+    char* cpy;
+    icalparameter_kind kind;
+    icalparameter *param;
+
+    icalerror_check_arg_rz(str != 0,"str");
+
+    cpy = icalmemory_strdup(str);
+
+    if (cpy == 0){
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        return 0;
+    }
+
+    eq = strchr(cpy,'=');
+
+    if(eq == 0){
+        icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+        return 0;
+    }
+
+    *eq = '\0';
+
+    eq++;
+
+    kind = icalparameter_string_to_kind(cpy);
+
+    if(kind == ICAL_NO_PARAMETER){
+        icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+        return 0;
+    }
+
+    param = icalparameter_new_from_value_string(kind,eq);
+
+    if(kind == ICAL_X_PARAMETER){
+        icalparameter_set_xname(param,cpy);
+    }
+
+    free(cpy);
+
+    return param;
+    
+}
+
+char*
+icalparameter_as_ical_string (icalparameter* parameter)
+{
+    struct icalparameter_impl* impl;
+    size_t buf_size = 1024;
+    char* buf; 
+    char* buf_ptr;
+    char *out_buf;
+    const char *kind_string;
+
+    icalerror_check_arg_rz( (parameter!=0), "parameter");
+
+    /* Create new buffer that we can append names, parameters and a
+       value to, and reallocate as needed. Later, this buffer will be
+       copied to a icalmemory_tmp_buffer, which is managed internally
+       by libical, so it can be given to the caller without fear of
+       the caller forgetting to free it */
+
+    buf = icalmemory_new_buffer(buf_size);
+    buf_ptr = buf;
+    impl = (struct icalparameter_impl*)parameter;
+
+    if(impl->kind == ICAL_X_PARAMETER) {
+
+        icalmemory_append_string(&buf, &buf_ptr, &buf_size, 
+                                 icalparameter_get_xname(impl));
+
+    } else {
+
+        kind_string = icalparameter_kind_to_string(impl->kind);
+        
+        if (impl->kind == ICAL_NO_PARAMETER || 
+            impl->kind == ICAL_ANY_PARAMETER || 
+            kind_string == 0)
+        {
+            icalerror_set_errno(ICAL_BADARG_ERROR);
+            return 0;
+        }
+        
+        
+        /* Put the parameter name into the string */
+        icalmemory_append_string(&buf, &buf_ptr, &buf_size, kind_string);
+
+    }
+
+    icalmemory_append_string(&buf, &buf_ptr, &buf_size, "=");
+
+    if(impl->string !=0){
+        icalmemory_append_string(&buf, &buf_ptr, &buf_size, impl->string); 
+    } else if (impl->data != 0){
+        const char* str = icalparameter_enum_to_string(impl->data);
+        icalmemory_append_string(&buf, &buf_ptr, &buf_size, str); 
+    } else {
+        icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+        return 0;
+    }
+
+    /* Now, copy the buffer to a tmp_buffer, which is safe to give to
+       the caller without worring about de-allocating it. */
+    
+    out_buf = icalmemory_tmp_buffer(strlen(buf));
+    strcpy(out_buf, buf);
+
+    icalmemory_free_buffer(buf);
+
+    return out_buf;
+
+}
+
+
+int
+icalparameter_is_valid (icalparameter* parameter);
+
+
+icalparameter_kind
+icalparameter_isa (icalparameter* parameter)
+{
+    if(parameter == 0){
+        return ICAL_NO_PARAMETER;
+    }
+
+    return ((struct icalparameter_impl *)parameter)->kind;
+}
+
+
+int
+icalparameter_isa_parameter (void* parameter)
+{
+    struct icalparameter_impl *impl = (struct icalparameter_impl *)parameter;
+
+    if (parameter == 0){
+        return 0;
+    }
+
+    if (strcmp(impl->id,"para") == 0) {
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+
+void
+icalparameter_set_xname (icalparameter* param, const char* v)
+{
+    struct icalparameter_impl *impl = (struct icalparameter_impl*)param;
+    icalerror_check_arg_rv( (param!=0),"param");
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    if (impl->x_name != 0){
+        free((void*)impl->x_name);
+    }
+
+    impl->x_name = icalmemory_strdup(v);
+
+    if (impl->x_name == 0){
+        errno = ENOMEM;
+    }
+
+}
+
+const char*
+icalparameter_get_xname (icalparameter* param)
+{
+    struct icalparameter_impl *impl = (struct icalparameter_impl*)param;
+    icalerror_check_arg_rz( (param!=0),"param");
+
+    return impl->x_name;
+}
+
+void
+icalparameter_set_xvalue (icalparameter* param, const char* v)
+{
+    struct icalparameter_impl *impl = (struct icalparameter_impl*)param;
+
+    icalerror_check_arg_rv( (param!=0),"param");
+    icalerror_check_arg_rv( (v!=0),"v");
+
+    if (impl->string != 0){
+        free((void*)impl->string);
+    }
+
+    impl->string = icalmemory_strdup(v);
+
+    if (impl->string == 0){
+        errno = ENOMEM;
+    }
+
+}
+
+const char*
+icalparameter_get_xvalue (icalparameter* param)
+{
+    struct icalparameter_impl *impl = (struct icalparameter_impl*)param;
+
+    icalerror_check_arg_rz( (param!=0),"param");
+
+    return impl->string;
+
+}
+
+void icalparameter_set_parent(icalparameter* param,
+                             icalproperty* property)
+{
+    struct icalparameter_impl *impl = (struct icalparameter_impl*)param;
+
+    icalerror_check_arg_rv( (param!=0),"param");
+
+    impl->parent = property;
+}
+
+icalproperty* icalparameter_get_parent(icalparameter* param)
+{
+    struct icalparameter_impl *impl = (struct icalparameter_impl*)param;
+
+    icalerror_check_arg_rz( (param!=0),"param");
+
+    return impl->parent;
+}
+
+
+/* Everything below this line is machine generated. Do not edit. */
+/* ALTREP */
diff --git a/libical/src/libical/icalparameter.h b/libical/src/libical/icalparameter.h
new file mode 100644
index 0000000..3f3b59f
--- a/dev/null
+++ b/libical/src/libical/icalparameter.h
@@ -0,0 +1,69 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+  FILE: icalparam.h
+  CREATOR: eric 20 March 1999
+
+
+  $Id$
+  $Locker$
+
+  
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalparam.h
+
+  ======================================================================*/
+
+#ifndef ICALPARAM_H
+#define ICALPARAM_H
+
+#include "icalderivedparameter.h"
+
+/* Declared in icalderivedparameter.h */
+/*typedef void icalparameter;*/
+
+icalparameter* icalparameter_new(icalparameter_kind kind);
+icalparameter* icalparameter_new_clone(icalparameter* p);
+
+/* Create from string of form "PARAMNAME=VALUE" */
+icalparameter* icalparameter_new_from_string(const char* value);
+
+/* Create from just the value, the part after the "=" */
+icalparameter* icalparameter_new_from_value_string(icalparameter_kind kind, const char* value);
+
+void icalparameter_free(icalparameter* parameter);
+
+char* icalparameter_as_ical_string(icalparameter* parameter);
+
+int icalparameter_is_valid(icalparameter* parameter);
+
+icalparameter_kind icalparameter_isa(icalparameter* parameter);
+
+int icalparameter_isa_parameter(void* param);
+
+/* Acess the name of an X parameer */
+void icalparameter_set_xname (icalparameter* param, const char* v);
+const char* icalparameter_get_xname(icalparameter* param);
+void icalparameter_set_xvalue (icalparameter* param, const char* v);
+const char* icalparameter_get_xvalue(icalparameter* param);
+
+/* Convert enumerations */
+
+const char* icalparameter_kind_to_string(icalparameter_kind kind);
+icalparameter_kind icalparameter_string_to_kind(const char* string);
+
+
+
+#endif 
diff --git a/libical/src/libical/icalparameterimpl.h b/libical/src/libical/icalparameterimpl.h
new file mode 100644
index 0000000..2d0fdd6
--- a/dev/null
+++ b/libical/src/libical/icalparameterimpl.h
@@ -0,0 +1,52 @@
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: icalparameterimpl.h
+  CREATOR: eric 09 May 1999
+  
+  $Id$
+  $Locker$
+    
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalderivedparameters.{c,h}
+
+  Contributions from:
+     Graham Davison (g.m.davison@computer.org)
+
+ ======================================================================*/
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#ifndef ICALPARAMETER_IMPL
+#define ICALPARAMETER_IMPL
+
+#include "icalparameter.h"
+#include "icalproperty.h"
+
+struct icalparameter_impl
+{
+        icalparameter_kind kind;
+        char id[5];
+        int size;
+        const char* string;
+        const char* x_name;
+        icalproperty* parent;
+
+        int data;
+};
+
+
+#endif /*ICALPARAMETER_IMPL*/
diff --git a/libical/src/libical/icalparser.c b/libical/src/libical/icalparser.c
new file mode 100644
index 0000000..b5824d5
--- a/dev/null
+++ b/libical/src/libical/icalparser.c
@@ -0,0 +1,1111 @@
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: icalparser.c
+  CREATOR: eric 04 August 1999
+  
+  $Id$
+  $Locker$
+    
+ The contents of this file are subject to the Mozilla Public License
+ Version 1.0 (the "License"); you may not use this file except in
+ compliance with the License. You may obtain a copy of the License at
+ http://www.mozilla.org/MPL/
+ 
+ Software distributed under the License is distributed on an "AS IS"
+ basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+ the License for the specific language governing rights and
+ limitations under the License.
+ 
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The Initial Developer of the Original Code is Eric Busboom
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+ ======================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+
+#include "icalparser.h"
+#include "pvl.h"
+#include "icalmemory.h"
+#include "icalerror.h"
+#include "icalvalue.h"
+#include "icalderivedparameter.h"
+#include "icalparameter.h"
+#include "icalproperty.h"
+#include "icalcomponent.h"
+
+#include <string.h> /* For strncpy & size_t */
+#include <stdio.h> /* For FILE and fgets and sprintf */
+#include <stdlib.h> /* for free */
+
+int snprintf(char *str, size_t n, char const *fmt, ...);
+
+extern icalvalue* icalparser_yy_value;
+void set_parser_value_state(icalvalue_kind kind);
+int ical_yyparse(void);
+
+char* icalparser_get_next_char(char c, char *str);
+char* icalparser_get_next_parameter(char* line,char** end);
+char* icalparser_get_next_value(char* line, char **end, icalvalue_kind kind);
+char* icalparser_get_prop_name(char* line, char** end);
+char* icalparser_get_param_name(char* line, char **end);
+
+#define TMP_BUF_SIZE 80
+
+struct icalparser_impl 
+{
+    int buffer_full; /* flag indicates that temp is smaller that 
+                        data being read into it*/
+    int continuation_line; /* last line read was a continuation line */
+    size_t tmp_buf_size; 
+    char temp[TMP_BUF_SIZE];
+    icalcomponent *root_component;
+    int version; 
+    int level;
+    int lineno;
+    icalparser_state state;
+    pvl_list components;
+    
+    void *line_gen_data;
+    
+};
+
+
+icalparser* icalparser_new(void)
+{
+    struct icalparser_impl* impl = 0;
+    if ( ( impl = (struct icalparser_impl*)
+           malloc(sizeof(struct icalparser_impl))) == 0) {
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        return 0;
+    }
+    
+    impl->root_component = 0;
+    impl->components  = pvl_newlist();  
+    impl->level = 0;
+    impl->state = ICALPARSER_SUCCESS;
+    impl->tmp_buf_size = TMP_BUF_SIZE;
+    impl->buffer_full = 0;
+    impl->lineno = 0;
+    impl->continuation_line = 0;
+    memset(impl->temp,0, TMP_BUF_SIZE);
+
+    return (icalparser*)impl;
+}
+
+
+void icalparser_free(icalparser* parser)
+{
+    struct icalparser_impl* impl = (struct icalparser_impl*)parser;
+    icalcomponent *c;
+
+    if (impl->root_component != 0){
+        icalcomponent_free(impl->root_component);
+    }
+
+    while( (c=pvl_pop(impl->components)) != 0){
+        icalcomponent_free(c);
+    }
+    
+    pvl_free(impl->components);
+    
+    free(impl);
+}
+
+void icalparser_set_gen_data(icalparser* parser, void* data)
+{
+    struct icalparser_impl* impl = (struct icalparser_impl*)parser;
+
+    impl->line_gen_data  = data;
+}
+
+
+icalvalue* icalvalue_new_From_string_with_error(icalvalue_kind kind, 
+                                                char* str, 
+                                                icalproperty **error);
+
+
+
+char* icalparser_get_next_char(char c, char *str)
+{
+    int quote_mode = 0;
+    char* p;
+    
+
+    for(p=str; *p!=0; p++){
+        
+        if ( quote_mode == 0 && *p=='"' && *(p-1) != '\\' ){
+            quote_mode =1;
+            continue;
+        }
+
+        if ( quote_mode == 1 && *p=='"' && *(p-1) != '\\' ){
+            quote_mode =0;
+            continue;
+        }
+
+        if (quote_mode == 0 &&  *p== c  && *(p-1) != '\\' ){
+            return p;
+        }
+
+    }
+
+    return 0;
+}
+
+/* make a new tmp buffer out of a substring */
+char* make_segment(char* start, char* end)
+{
+    char *buf;
+    size_t size = (size_t)end - (size_t)start;
+    
+    buf = icalmemory_tmp_buffer(size+1);
+    
+
+    strncpy(buf,start,size);
+    *(buf+size) = 0;
+    
+    return buf;
+    
+}
+
+const char* input_buffer;
+const char* input_buffer_p;
+//#define min(a,b) ((a) < (b) ? (a) : (b))   
+
+int icalparser_flex_input(char* buf, int max_size)
+{
+  int n = max_size; // = min(max_size,strlen(input_buffer_p));
+  if ( n < ((int )strlen(input_buffer_p)) )
+    n = strlen(input_buffer_p);
+    if (n > 0){
+        memcpy(buf, input_buffer_p, n);
+        input_buffer_p += n;
+        return n;
+    } else {
+        return 0;
+    }
+}
+
+void icalparser_clear_flex_input(void)
+{
+    input_buffer_p = input_buffer+strlen(input_buffer);
+}
+
+/* Call the flex/bison parser to parse a complex value */
+
+icalvalue*  icalparser_parse_value(icalvalue_kind kind,
+                                   const char* str, icalproperty** error)
+{
+    int r;
+    input_buffer_p = input_buffer = str;
+
+    set_parser_value_state(kind);
+    icalparser_yy_value = 0;
+
+    r = ical_yyparse();
+
+    /* Error. Parse failed */
+    if( icalparser_yy_value == 0 || r != 0){
+
+        if(icalparser_yy_value !=0){
+            icalvalue_free(icalparser_yy_value);
+            icalparser_yy_value = 0;
+        }
+
+        return 0;
+    }
+
+    if (error != 0){
+        *error = 0;
+    }
+
+    return icalparser_yy_value;
+}
+
+char* icalparser_get_prop_name(char* line, char** end)
+{
+    char* p;
+    char* v;
+    char *str;
+
+    p = icalparser_get_next_char(';',line); 
+    v = icalparser_get_next_char(':',line); 
+    if (p== 0 && v == 0) {
+        return 0;
+    }
+
+    /* There is no ';' or, it is after the ';' that marks the beginning of
+       the value */
+    if (v!=0 && ( p == 0 || p > v)){
+        str = make_segment(line,v);
+        *end = v+1;
+    } else {
+        str = make_segment(line,p);
+        *end = p+1;
+    }
+
+    return str;
+}
+
+char* icalparser_get_param_name(char* line, char **end)
+{
+    
+    char* next; 
+    char *str;
+
+    next = icalparser_get_next_char('=',line);
+
+    if (next == 0) {
+        return 0;
+    }
+
+    str = make_segment(line,next);
+    *end = next+1;
+    return str;
+   
+}
+
+char* icalparser_get_next_paramvalue(char* line, char **end)
+{
+    
+    char* next; 
+    char *str;
+
+    next = icalparser_get_next_char(',',line);
+
+    if (next == 0){
+        next = (char*)(size_t)line+(size_t)strlen(line);\
+    }
+
+    if (next == line){
+        return 0;
+    } else {
+        str = make_segment(line,next);
+        *end = next+1;
+        return str;
+    }
+   
+}
+
+/* A property may have multiple values, if the values are seperated by
+   commas in the content line. This routine will look for the next
+   comma after line and will set the next place to start searching in
+   end. */
+
+char* icalparser_get_next_value(char* line, char **end, icalvalue_kind kind)
+{
+    
+    char* next;
+    char *p;
+    char *str;
+    size_t length = strlen(line);
+
+    p = line;
+    while(1){
+
+        next = icalparser_get_next_char(',',p);
+
+        /* Unforunately, RFC2445 says that for the RECUR value, COMMA
+           can both seperate digits in a list, and it can seperate
+           multiple recurrence specifications. This is not a friendly
+           part of the spec. This weirdness tries to
+           distinguish the two uses. it is probably a HACK*/
+      
+        if( kind == ICAL_RECUR_VALUE ) {
+            if ( next != 0 &&
+                 (*end+length) > next+5 &&
+                 strncmp(next,"FREQ",4) == 0
+                ) {
+                /* The COMMA was followed by 'FREQ', is it a real seperator*/
+                /* Fall through */
+            } else if (next != 0){
+                /* Not real, get the next COMMA */
+                p = next+1;
+                next = 0;
+                continue;
+            } 
+        }
+
+        /* If the comma is preceeded by a '\', then it is a literal and
+           not a value seperator*/  
+      
+        if ( (next!=0 && *(next-1) == '\\') ||
+             (next!=0 && *(next-3) == '\\')
+            ) 
+            /*second clause for '/' is on prev line. HACK may be out of bounds */
+        {
+            p = next+1;
+        } else {
+            break;
+        }
+
+    }
+
+    if (next == 0){
+        next = (char*)(size_t)line+length;
+        *end = next;
+    } else {
+        *end = next+1;
+    }
+
+    if (next == line){
+        return 0;
+    } 
+        
+
+    str = make_segment(line,next);
+    return str;
+   
+}
+
+char* icalparser_get_next_parameter(char* line,char** end)
+{
+    char *next;
+    char *v;
+    char *str;
+
+    v = icalparser_get_next_char(':',line); 
+    next = icalparser_get_next_char(';', line);
+    
+    /* There is no ';' or, it is after the ':' that marks the beginning of
+       the value */
+
+    if (next == 0 || next > v) {
+        next = icalparser_get_next_char(':', line);
+    }
+
+    if (next != 0) {
+        str = make_segment(line,next);
+        *end = next+1;
+        return str;
+    } else {
+        *end = line;
+        return 0;
+    }
+}
+
+/* Get a single property line, from the property name through the
+   final new line, and include any continuation lines */
+
+char* icalparser_get_line(icalparser *parser,
+                          char* (*line_gen_func)(char *s, size_t size, void *d))
+{
+    char *line;
+    char *line_p;
+    struct icalparser_impl* impl = (struct icalparser_impl*)parser;
+    size_t buf_size = impl->tmp_buf_size;
+
+    
+    line_p = line = icalmemory_new_buffer(buf_size);
+    line[0] = '\0';
+   
+    /* Read lines by calling line_gen_func and putting the data into
+       impl->temp. If the line is a continuation line ( begins with a
+       space after a newline ) then append the data onto line and read
+       again. Otherwise, exit the loop. */
+
+    while(1) {
+
+        /* The first part of the loop deals with the temp buffer,
+           which was read on he last pass through the loop. The
+           routine is split like this because it has to read lone line
+           ahead to determine if a line is a continuation line. */
+
+
+        /* The tmp buffer is not clear, so transfer the data in it to the
+           output. This may be left over from a previous call */
+        if (impl->temp[0] != '\0' ) {
+
+            /* If the last position in the temp buffer is occupied,
+               mark the buffer as full. The means we will do another
+               read later, because the line is not finished */
+            if (impl->temp[impl->tmp_buf_size-1] == 0 &&
+                impl->temp[impl->tmp_buf_size-2] != '\n'&& 
+                impl->temp[impl->tmp_buf_size-2] != 0 ){
+                impl->buffer_full = 1;
+            } else {
+                impl->buffer_full = 0;
+            }
+
+            /* Copy the temp to the output and clear the temp buffer. */
+            if(impl->continuation_line==1){
+                /* back up the pointer to erase the continuation characters */
+                impl->continuation_line = 0;
+                line_p--;
+                
+                if ( *(line_p-1) == '\r'){
+                    line_p--;
+                }
+                
+                /* copy one space up to eliminate the leading space*/
+                icalmemory_append_string(&line,&line_p,&buf_size,
+                                         impl->temp+1);
+
+            } else {
+                icalmemory_append_string(&line,&line_p,&buf_size,impl->temp);
+            }
+
+            impl->temp[0] = '\0' ;
+        }
+        
+        impl->temp[impl->tmp_buf_size-1] = 1; /* Mark end of buffer */
+
+        /****** Here is where the routine gets string data ******************/
+        if ((*line_gen_func)(impl->temp,impl->tmp_buf_size,impl->line_gen_data)
+            ==0){/* Get more data */
+
+            /* If the first position is clear, it means we didn't get
+               any more data from the last call to line_ge_func*/
+            if (impl->temp[0] == '\0'){
+
+                if(line[0] != '\0'){
+                    /* There is data in the output, so fall trhough and process it*/
+                    break;
+                } else {
+                    /* No data in output; return and signal that there
+                       is no more input*/
+                    free(line);
+                    return 0;
+                }
+            }
+        }
+        
+ 
+        /* If the output line ends in a '\n' and the temp buffer
+           begins with a ' ', then the buffer holds a continuation
+           line, so keep reading.  */
+
+        if ( line_p > line+1 && *(line_p-1) == '\n'
+          && (impl->temp[0] == ' ' || impl->temp[0] == '\t') ) {
+
+            impl->continuation_line = 1;
+
+        } else if ( impl->buffer_full == 1 ) {
+            
+            /* The buffer was filled on the last read, so read again */
+
+        } else {
+
+            /* Looks like the end of this content line, so break */
+            break;
+        }
+
+        
+    }
+
+    /* Erase the final newline and/or carriage return*/
+            if ( line_p > line+1 && *(line_p-1) == '\n') {
+        *(line_p-1) = '\0';
+        if ( *(line_p-2) == '\r'){
+            *(line_p-2) = '\0';
+        }
+
+    } else {
+        *(line_p) = '\0';
+    }
+
+    return line;
+
+}
+
+void insert_error(icalcomponent* comp, char* text, 
+                  char* message, icalparameter_xlicerrortype type)
+{
+    char temp[1024];
+    
+    if (text == 0){
+        snprintf(temp,1024,"%s:",message);
+    } else {
+        snprintf(temp,1024,"%s: %s",message,text);
+            }
+    
+    icalcomponent_add_property
+        (comp,
+         icalproperty_vanew_xlicerror(
+             temp,
+             icalparameter_new_xlicerrortype(type),
+             0));   
+}
+
+int line_is_blank(char* line){
+    int i=0;
+
+    for(i=0; *(line+i)!=0; i++){
+        char c = *(line+i);
+
+        if(c != ' ' && c != '\n' && c != '\t'){
+            return 0;
+        }
+    }
+    
+    return 1;
+}
+
+icalcomponent* icalparser_parse(icalparser *parser,
+                                char* (*line_gen_func)(char *s, size_t size, 
+                                                       void* d))
+{
+
+    char* line; 
+    icalcomponent *c=0; 
+    icalcomponent *root=0;
+    struct icalparser_impl *impl = (struct icalparser_impl*)parser;
+    icalerrorstate es = icalerror_get_error_state(ICAL_MALFORMEDDATA_ERROR);
+
+    icalerror_check_arg_rz((parser !=0),"parser");
+
+    icalerror_set_error_state(ICAL_MALFORMEDDATA_ERROR,ICAL_ERROR_NONFATAL);
+
+    do{
+            line = icalparser_get_line(parser, line_gen_func);
+
+        if ((c = icalparser_add_line(parser,line)) != 0){
+
+            if(icalcomponent_get_parent(c) !=0){
+                /* This is bad news... assert? */
+                    }    
+            
+            assert(impl->root_component == 0);
+            assert(pvl_count(impl->components) ==0);
+
+            if (root == 0){
+                /* Just one component */
+                root = c;
+            } else if(icalcomponent_isa(root) != ICAL_XROOT_COMPONENT) {
+                /*Got a second component, so move the two components under
+                  an XROOT container */
+                icalcomponent *tempc = icalcomponent_new(ICAL_XROOT_COMPONENT);
+                icalcomponent_add_component(tempc, root);
+                icalcomponent_add_component(tempc, c);
+                root = tempc;
+            } else if(icalcomponent_isa(root) == ICAL_XROOT_COMPONENT) {
+                /* Already have an XROOT container, so add the component
+                   to it*/
+                icalcomponent_add_component(root, c);
+                
+            } else {
+                /* Badness */
+                assert(0);
+            }
+
+            c = 0;
+
+        }
+        if(line != 0){
+            free(line);
+        }
+    } while ( line != 0);
+
+    icalerror_set_error_state(ICAL_MALFORMEDDATA_ERROR,es);
+
+    return root;
+
+}
+
+
+icalcomponent* icalparser_add_line(icalparser* parser,
+                                       char* line)
+{ 
+    char *p; 
+    char *str;
+    char *end;
+    int vcount = 0;
+    icalproperty *prop;
+    icalproperty_kind prop_kind;
+    icalvalue *value;
+    icalvalue_kind value_kind = ICAL_NO_VALUE;
+
+
+    struct icalparser_impl *impl = (struct icalparser_impl*)parser;
+    icalerror_check_arg_rz((parser != 0),"parser");
+
+
+    if (line == 0)
+    {
+        impl->state = ICALPARSER_ERROR;
+        return 0;
+    }
+
+    if(line_is_blank(line) == 1){
+        return 0;
+    }
+
+    /* Begin by getting the property name at the start of the line. The
+       property name may end up being "BEGIN" or "END" in which case it
+       is not really a property, but the marker for the start or end of
+       a component */
+
+    end = 0;
+    str = icalparser_get_prop_name(line, &end);
+
+    if (str == 0 || strlen(str) == 0 ){
+        /* Could not get a property name */
+        icalcomponent *tail = pvl_data(pvl_tail(impl->components));
+
+        if (tail){
+            insert_error(tail,line,
+                         "Got a data line, but could not find a property name or component begin tag",
+                         ICAL_XLICERRORTYPE_COMPONENTPARSEERROR);
+        }
+        tail = 0;
+        impl->state = ICALPARSER_ERROR;
+        return 0; 
+    }
+
+    /**********************************************************************
+     * Handle begin and end of components
+             **********************************************************************/                                                           
+    /* If the property name is BEGIN or END, we are actually
+       starting or ending a new component */
+
+    if(strcmp(str,"BEGIN") == 0){
+        icalcomponent *c;
+        icalcomponent_kind comp_kind;
+
+        impl->level++;
+        str = icalparser_get_next_value(end,&end, value_kind);
+            
+
+        comp_kind = icalenum_string_to_component_kind(str);
+
+        if (comp_kind == ICAL_NO_COMPONENT){
+            c = icalcomponent_new(ICAL_XLICINVALID_COMPONENT);
+            insert_error(c,str,"Parse error in component name",
+                         ICAL_XLICERRORTYPE_COMPONENTPARSEERROR);
+        }
+
+        c  =  icalcomponent_new(comp_kind);
+
+        if (c == 0){
+            c = icalcomponent_new(ICAL_XLICINVALID_COMPONENT);
+            insert_error(c,str,"Parse error in component name",
+                         ICAL_XLICERRORTYPE_COMPONENTPARSEERROR);
+        }
+            
+        pvl_push(impl->components,c);
+
+        impl->state = ICALPARSER_BEGIN_COMP;
+        return 0;
+
+    } else if (strcmp(str,"END") == 0 ) {
+        icalcomponent* tail;
+
+        impl->level--;
+        str = icalparser_get_next_value(end,&end, value_kind);
+
+        /* Pop last component off of list and add it to the second-to-last*/
+        impl->root_component = pvl_pop(impl->components);
+
+        tail = pvl_data(pvl_tail(impl->components));
+
+        if(tail != 0){
+            icalcomponent_add_component(tail,impl->root_component);
+        } 
+
+        tail = 0;
+
+        /* Return the component if we are back to the 0th level */
+        if (impl->level == 0){
+            icalcomponent *rtrn; 
+
+            if(pvl_count(impl->components) != 0){
+            /* There are still components on the stack -- this means
+               that one of them did not have a proper "END" */
+                pvl_push(impl->components,impl->root_component);
+                icalparser_clean(parser); /* may reset impl->root_component*/
+            }
+
+            assert(pvl_count(impl->components) == 0);
+
+            impl->state = ICALPARSER_SUCCESS;
+            rtrn = impl->root_component;
+            impl->root_component = 0;
+            return rtrn;
+
+        } else {
+            impl->state = ICALPARSER_END_COMP;
+            return 0;
+        }
+    }
+
+
+    /* There is no point in continuing if we have not seen a
+       component yet */
+
+    if(pvl_data(pvl_tail(impl->components)) == 0){
+        impl->state = ICALPARSER_ERROR;
+        return 0;
+    }
+
+
+    /**********************************************************************
+     * Handle property names
+     **********************************************************************/
+                                                                       
+    /* At this point, the property name really is a property name,
+       (Not a component name) so make a new property and add it to
+       the component */
+
+    
+    prop_kind = icalproperty_string_to_kind(str);
+
+    prop = icalproperty_new(prop_kind);
+
+    if (prop != 0){
+        icalcomponent *tail = pvl_data(pvl_tail(impl->components));
+
+        if(prop_kind==ICAL_X_PROPERTY){
+            icalproperty_set_x_name(prop,str);
+        }
+
+        icalcomponent_add_property(tail, prop);
+
+        /* Set the value kind for the default for this type of
+           property. This may be re-set by a VALUE parameter */
+        value_kind = icalproperty_kind_to_value_kind(icalproperty_isa(prop));
+
+    } else {
+        icalcomponent* tail = pvl_data(pvl_tail(impl->components));
+
+        insert_error(tail,str,"Parse error in property name",
+                     ICAL_XLICERRORTYPE_PROPERTYPARSEERROR);
+            
+        tail = 0;
+        impl->state = ICALPARSER_ERROR;
+        return 0;
+    }
+
+    /**********************************************************************
+     * Handle parameter values
+             **********************************************************************/                                                           
+
+    /* Now, add any parameters to the last property */
+
+    p = 0;
+    while(1) {
+
+        if (*(end-1) == ':'){
+            /* if the last seperator was a ":" and the value is a
+               URL, icalparser_get_next_parameter will find the
+               ':' in the URL, so better break now. */
+            break;
+        }
+
+        str = icalparser_get_next_parameter(end,&end);
+
+        if (str != 0){
+            char* name;
+            char* pvalue;
+        
+            icalparameter *param = 0;
+            icalparameter_kind kind;
+            icalcomponent *tail = pvl_data(pvl_tail(impl->components));
+
+            name = icalparser_get_param_name(str,&pvalue);
+
+            if (name == 0){
+                /* 'tail' defined above */
+                insert_error(tail, str, "Cant parse parameter name",
+                             ICAL_XLICERRORTYPE_PARAMETERNAMEPARSEERROR);
+                tail = 0;
+                break;
+            }
+
+            kind = icalparameter_string_to_kind(name);
+
+            if(kind == ICAL_X_PARAMETER){
+                param = icalparameter_new(ICAL_X_PARAMETER);
+                
+                if(param != 0){
+                    icalparameter_set_xname(param,name);
+                    icalparameter_set_xvalue(param,pvalue);
+                }
+
+
+            } else if (kind != ICAL_NO_PARAMETER){
+                param = icalparameter_new_from_value_string(kind,pvalue);
+            } else {
+                /* Error. Failed to parse the parameter*/
+                /* 'tail' defined above */
+                insert_error(tail, str, "Cant parse parameter name",
+                             ICAL_XLICERRORTYPE_PARAMETERNAMEPARSEERROR);
+                tail = 0;
+                impl->state = ICALPARSER_ERROR;
+                return 0;
+            }
+
+            if (param == 0){
+                /* 'tail' defined above */
+                insert_error(tail,str,"Cant parse parameter value",
+                             ICAL_XLICERRORTYPE_PARAMETERVALUEPARSEERROR);
+                    
+                tail = 0;
+                impl->state = ICALPARSER_ERROR;
+                continue;
+            }
+
+            /* If it is a VALUE parameter, set the kind of value*/
+            if (icalparameter_isa(param)==ICAL_VALUE_PARAMETER){
+
+                value_kind = (icalvalue_kind)
+                    icalparameter_value_to_value_kind(
+                                icalparameter_get_value(param)
+                                );
+
+                if (value_kind == ICAL_NO_VALUE){
+
+                    /* Ooops, could not parse the value of the
+                       parameter ( it was not one of the defined
+                       values ), so reset the value_kind */
+                        
+                    insert_error(
+                        tail, str, 
+                        "Got a VALUE parameter with an unknown type",
+                        ICAL_XLICERRORTYPE_PARAMETERVALUEPARSEERROR);
+                    icalparameter_free(param);
+                        
+                    value_kind = 
+                        icalproperty_kind_to_value_kind(
+                            icalproperty_isa(prop));
+                        
+                    icalparameter_free(param);
+                    tail = 0;
+                    impl->state = ICALPARSER_ERROR;
+                    return 0;
+                } 
+            }
+
+            /* Everything is OK, so add the parameter */
+            icalproperty_add_parameter(prop,param);
+            tail = 0;
+
+        } else { /* if ( str != 0)  */
+            /* If we did not get a param string, go on to looking
+               for a value */
+            break;
+        } /* if ( str != 0)  */
+
+            } /* while(1) */    
+        
+    /**********************************************************************
+     * Handle values
+             **********************************************************************/                                                           
+
+    /* Look for values. If there are ',' characters in the values,
+       then there are multiple values, so clone the current
+       parameter and add one part of the value to each clone */
+
+    vcount=0;
+    while(1) {
+        str = icalparser_get_next_value(end,&end, value_kind);
+
+        if (str != 0){
+                
+            if (vcount > 0){
+                /* Actually, only clone after the second value */
+                icalproperty* clone = icalproperty_new_clone(prop);
+                icalcomponent* tail = pvl_data(pvl_tail(impl->components));
+                    
+                icalcomponent_add_property(tail, clone);
+                        prop = clone;       
+                tail = 0;
+            }
+                
+            value = icalvalue_new_from_string(value_kind, str);
+                
+            /* Don't add properties without value */
+            if (value == 0){
+                char temp[200]; /* HACK */
+
+                icalproperty_kind prop_kind = icalproperty_isa(prop);
+                icalcomponent* tail = pvl_data(pvl_tail(impl->components));
+
+                sprintf(temp,"Cant parse as %s value in %s property. Removing entire property",
+                        icalvalue_kind_to_string(value_kind),
+                        icalproperty_kind_to_string(prop_kind));
+
+                insert_error(tail, str, temp,
+                             ICAL_XLICERRORTYPE_VALUEPARSEERROR);
+
+                /* Remove the troublesome property */
+                icalcomponent_remove_property(tail,prop);
+                icalproperty_free(prop);
+                prop = 0;
+                tail = 0;
+                impl->state = ICALPARSER_ERROR;
+                return 0;
+                    
+            } else {
+                vcount++;
+                icalproperty_set_value(prop, value);
+            }
+
+
+        } else {
+            if (vcount == 0){
+                char temp[200]; /* HACK */
+                
+                icalproperty_kind prop_kind = icalproperty_isa(prop);
+                icalcomponent *tail = pvl_data(pvl_tail(impl->components));
+                
+                sprintf(temp,"No value for %s property. Removing entire property",
+                        icalproperty_kind_to_string(prop_kind));
+
+                insert_error(tail, str, temp,
+                             ICAL_XLICERRORTYPE_VALUEPARSEERROR);
+
+                /* Remove the troublesome property */
+                icalcomponent_remove_property(tail,prop);
+                icalproperty_free(prop);
+                prop = 0;
+                tail = 0;
+                impl->state = ICALPARSER_ERROR;
+                return 0;
+            } else {
+
+                break;
+            }
+        }
+    }
+        
+    /****************************************************************
+     * End of component parsing. 
+     *****************************************************************/
+
+    if (pvl_data(pvl_tail(impl->components)) == 0 &&
+        impl->level == 0){
+        /* HACK. Does this clause ever get executed? */
+        impl->state = ICALPARSER_SUCCESS;
+        assert(0);
+        return impl->root_component;
+    } else {
+        impl->state = ICALPARSER_IN_PROGRESS;
+        return 0;
+    }
+
+}
+
+icalparser_state icalparser_get_state(icalparser* parser)
+{
+    struct icalparser_impl* impl = (struct icalparser_impl*) parser;
+    return impl->state;
+
+}
+
+icalcomponent* icalparser_clean(icalparser* parser)
+{
+    struct icalparser_impl* impl = (struct icalparser_impl*) parser;
+    icalcomponent *tail; 
+
+    icalerror_check_arg_rz((parser != 0 ),"parser");
+
+    /* We won't get a clean exit if some components did not have an
+       "END" tag. Clear off any component that may be left in the list */
+    
+    while((tail=pvl_data(pvl_tail(impl->components))) != 0){
+
+        insert_error(tail," ",
+                     "Missing END tag for this component. Closing component at end of input.",
+                     ICAL_XLICERRORTYPE_COMPONENTPARSEERROR);
+        
+
+        impl->root_component = pvl_pop(impl->components);
+        tail=pvl_data(pvl_tail(impl->components));
+
+        if(tail != 0){
+            if(icalcomponent_get_parent(impl->root_component)!=0){
+                icalerror_warn("icalparser_clean is trying to attach a component for the second time");
+            } else {
+                icalcomponent_add_component(tail,impl->root_component);
+            }
+        }
+            
+    }
+
+    return impl->root_component;
+
+}
+
+struct slg_data {
+        const char* pos;
+        const char* str;
+};
+
+char* string_line_generator(char *out, size_t buf_size, void *d)
+{
+    char *n;
+    size_t size;
+    struct slg_data* data = (struct slg_data*)d;
+
+    if(data->pos==0){
+        data->pos=data->str;
+    }
+
+    /* If the pointer is at the end of the string, we are done */
+    if (*(data->pos)==0){
+        return 0;
+    }
+
+    n = strchr(data->pos,'\n');
+    
+    if (n == 0){
+        size = strlen(data->pos);
+    } else {
+        n++; /* include newline in output */
+                size = (n-data->pos);
+    }
+
+    if (size > buf_size-1){
+        size = buf_size-1;
+    }
+    
+
+    strncpy(out,data->pos,size);
+    
+    *(out+size) = '\0';
+    
+    data->pos += size;
+
+    return out;    
+}
+
+icalcomponent* icalparser_parse_string(const char* str)
+{
+    icalcomponent *c;
+    struct slg_data d;
+    icalparser *p;
+
+    icalerrorstate es = icalerror_get_error_state(ICAL_MALFORMEDDATA_ERROR);
+
+    d.pos = 0;
+    d.str = str;
+
+    p = icalparser_new();
+    icalparser_set_gen_data(p,&d);
+
+    icalerror_set_error_state(ICAL_MALFORMEDDATA_ERROR,ICAL_ERROR_NONFATAL);
+
+    c = icalparser_parse(p,string_line_generator);
+
+    icalerror_set_error_state(ICAL_MALFORMEDDATA_ERROR,es);
+
+    icalparser_free(p);
+
+    return c;
+
+}
diff --git a/libical/src/libical/icalparser.h b/libical/src/libical/icalparser.h
new file mode 100644
index 0000000..5e1c88f
--- a/dev/null
+++ b/libical/src/libical/icalparser.h
@@ -0,0 +1,93 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+  FILE: icalparser.h
+  CREATOR: eric 20 April 1999
+  
+  $Id$
+
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalparser.h
+
+======================================================================*/
+
+
+#ifndef ICALPARSER_H
+#define ICALPARSER_H
+
+#include "icalenums.h"
+#include "icaltypes.h"
+#include"icalcomponent.h"
+
+#include <stdio.h> /* For FILE* */
+
+typedef void* icalparser;
+
+
+/***********************************************************************
+ * Line-oriented parsing. 
+ * 
+ * Create a new parser via icalparse_new_parser, then add ines one at
+ * a time with icalparse_add_line(). icalparser_add_line() will return
+ * non-zero when it has finished with a component.
+ ***********************************************************************/
+
+typedef enum icalparser_state {
+    ICALPARSER_ERROR,
+    ICALPARSER_SUCCESS,
+    ICALPARSER_BEGIN_COMP,
+    ICALPARSER_END_COMP,
+    ICALPARSER_IN_PROGRESS
+} icalparser_state;
+
+icalparser* icalparser_new(void);
+icalcomponent* icalparser_add_line(icalparser* parser, char* str );
+icalcomponent* icalparser_clean(icalparser* parser);
+icalparser_state icalparser_get_state(icalparser* parser);
+void icalparser_free(icalparser* parser);
+
+
+/***********************************************************************
+ * Message oriented parsing.  icalparser_parse takes a string that
+ * holds the text ( in RFC 2445 format ) and returns a pointer to an
+ * icalcomponent. The caller owns the memory. line_gen_func is a
+ * pointer to a function that returns one content line per invocation
+ **********************************************************************/
+
+icalcomponent* icalparser_parse(icalparser *parser,
+                                char* (*line_gen_func)(char *s, size_t size, void *d));
+
+/* Set the data that icalparser_parse will give to the line_gen_func
+   as the parameter 'd'*/
+void icalparser_set_gen_data(icalparser* parser, void* data);
+
+
+icalcomponent* icalparser_parse_string(const char* str);
+
+
+/***********************************************************************
+ * Parser support functions
+ ***********************************************************************/
+
+/* Use the flex/bison parser to turn a string into a value type */
+icalvalue*  icalparser_parse_value(icalvalue_kind kind, 
+                                   const char* str, icalcomponent** errors);
+
+/* Given a line generator function, return a single iCal content line.*/
+char* icalparser_get_line(icalparser* parser, char* (*line_gen_func)(char *s, size_t size, void *d));
+
+char* string_line_generator(char *out, size_t buf_size, void *d);
+
+#endif /* !ICALPARSE_H */
diff --git a/libical/src/libical/icalperiod.c b/libical/src/libical/icalperiod.c
new file mode 100644
index 0000000..c74c157
--- a/dev/null
+++ b/libical/src/libical/icalperiod.c
@@ -0,0 +1,170 @@
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: icalperiod.c
+  CREATOR: eric 02 June 2000
+  
+  $Id$
+  $Locker$
+    
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+ ======================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "icalperiod.h"
+
+#include <assert.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#ifdef ICAL_NO_LIBICAL
+#define icalerror_set_errno(x)
+#define  icalerror_check_arg_rv(x,y)
+#define  icalerror_check_arg_re(x,y,z)
+#else
+#include "icalerror.h"
+#include "icalmemory.h"
+#endif
+
+
+
+
+struct icalperiodtype icalperiodtype_from_string (const char* str)
+{
+    
+    struct icalperiodtype p, null_p;
+    char *s = icalmemory_strdup(str);
+    char *start, *end = s;
+    icalerrorstate es;
+
+    /* Errors are normally generated in the following code, so save
+       the error state for resoration later */
+
+    icalerrorenum e = icalerrno;
+
+    p.start = p.end = icaltime_null_time();
+    p.duration = icaldurationtype_from_int(0);
+
+    null_p = p;
+
+    if(s == 0) goto error;
+
+    start = s;
+    end = strchr(s, '/');
+
+    if(end == 0) goto error;
+
+    *end = 0;
+    end++;
+
+    p.start = icaltime_from_string(start);
+
+    if (icaltime_is_null_time(p.start)) goto error;
+
+    es = icalerror_get_error_state(ICAL_MALFORMEDDATA_ERROR);
+    icalerror_set_error_state(ICAL_MALFORMEDDATA_ERROR,ICAL_ERROR_NONFATAL);
+
+    p.end = icaltime_from_string(end);
+
+    icalerror_set_error_state(ICAL_MALFORMEDDATA_ERROR,es);
+    
+
+    if (icaltime_is_null_time(p.end)){
+
+        p.duration = icaldurationtype_from_string(end);
+
+        if(icaldurationtype_as_int(p.duration) == 0) goto error;
+    } 
+
+    icalerrno = e;
+
+    return p;
+
+ error:
+    icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+    return null_p;
+}
+
+
+const char* icalperiodtype_as_ical_string(struct icalperiodtype p)
+{
+
+    const char* start;
+    const char* end;
+
+    char *buf;
+    size_t buf_size = 40;
+    char* buf_ptr = 0;
+
+    buf = (char*)icalmemory_new_buffer(buf_size);
+    buf_ptr = buf;
+    
+
+    start = icaltime_as_ical_string(p.start);
+
+    icalmemory_append_string(&buf, &buf_ptr, &buf_size, start); 
+
+    if(!icaltime_is_null_time(p.end)){
+        end = icaltime_as_ical_string(p.end);
+    } else {
+        end = icaldurationtype_as_ical_string(p.duration);
+    }
+
+    icalmemory_append_char(&buf, &buf_ptr, &buf_size, '/'); 
+
+    icalmemory_append_string(&buf, &buf_ptr, &buf_size, end); 
+    
+
+    return buf;
+}
+
+
+
+struct icalperiodtype icalperiodtype_null_period() {
+    struct icalperiodtype p;
+    p.start = icaltime_null_time();
+    p.end = icaltime_null_time();
+    p.duration = icaldurationtype_null_duration();
+
+    return p;
+}
+int icalperiodtype_is_null_period(struct icalperiodtype p){
+    
+    if(icaltime_is_null_time(p.start) && 
+       icaltime_is_null_time(p.end) && 
+       icaldurationtype_is_null_duration(p.duration)){
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+int icalperiodtype_is_valid_period(struct icalperiodtype p){
+    if(icaltime_is_valid_time(p.start) && 
+       (icaltime_is_valid_time(p.end) || icaltime_is_null_time(p.end)) )
+        {
+            return 1;
+        }
+
+    return 0;
+}
+
diff --git a/libical/src/libical/icalperiod.h b/libical/src/libical/icalperiod.h
new file mode 100644
index 0000000..64d5323
--- a/dev/null
+++ b/libical/src/libical/icalperiod.h
@@ -0,0 +1,55 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalperiod.h
+ CREATOR: eric 26 Jan 2001
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+======================================================================*/
+
+#ifndef ICALPERIOD_H
+#define ICALPERIOD_H
+
+#include "icaltime.h"
+#include "icalduration.h"
+
+struct icalperiodtype 
+{
+        struct icaltimetype start; 
+        struct icaltimetype end; 
+        struct icaldurationtype duration;
+};
+
+struct icalperiodtype icalperiodtype_from_string (const char* str);
+
+const char* icalperiodtype_as_ical_string(struct icalperiodtype p);
+struct icalperiodtype icalperiodtype_null_period();
+int icalperiodtype_is_null_period(struct icalperiodtype p);
+int icalperiodtype_is_valid_period(struct icalperiodtype p);
+
+
+
+
+#endif /* !ICALTIME_H */
+
+
+
diff --git a/libical/src/libical/icalproperty.c b/libical/src/libical/icalproperty.c
new file mode 100644
index 0000000..7f2cfa5
--- a/dev/null
+++ b/libical/src/libical/icalproperty.c
@@ -0,0 +1,810 @@
+/* -*- Mode: C -*- */
+
+/*======================================================================
+  FILE: icalproperty.c
+  CREATOR: eric 28 April 1999
+  
+  $Id$
+
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalproperty.c
+
+======================================================================*/
+/*#line 27 "icalproperty.c.in"*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "icalproperty.h"
+#include "icalparameter.h"
+#include "icalcomponent.h"
+#include "pvl.h"
+#include "icalenums.h"
+#include "icalerror.h"
+#include "icalmemory.h"
+#include "icalparser.h"
+
+#include <string.h> /* For icalmemory_strdup, rindex */
+#include <assert.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <stdio.h> /* for printf */
+#include <stdarg.h> /* for va_list, va_start, etc. */
+                                               
+int snprintf(char *str, size_t n, char const *fmt, ...);
+
+#define TMP_BUF_SIZE 1024
+
+/* Private routines for icalproperty */
+void icalvalue_set_parent(icalvalue* value,
+                             icalproperty* property);
+icalproperty* icalvalue_get_parent(icalvalue* value);
+
+void icalparameter_set_parent(icalparameter* param,
+                             icalproperty* property);
+icalproperty* icalparameter_get_parent(icalparameter* value);
+
+
+void icalproperty_set_x_name(icalproperty* prop, const char* name);
+
+struct icalproperty_impl 
+{
+        char id[5];
+        icalproperty_kind kind;
+        char* x_name;
+        pvl_list parameters;
+        pvl_elem parameter_iterator;
+        icalvalue* value;
+        icalcomponent *parent;
+};
+
+void icalproperty_add_parameters(struct icalproperty_impl *prop,va_list args)
+{
+
+    void* vp;
+
+    struct icalproperty_impl *impl = (struct icalproperty_impl*)prop;
+  
+    while((vp = va_arg(args, void*)) != 0) {
+
+        if (icalvalue_isa_value(vp) != 0 ){
+        } else if (icalparameter_isa_parameter(vp) != 0 ){
+
+            icalproperty_add_parameter((icalproperty*)impl,
+                                       (icalparameter*)vp);
+        } else {
+            assert(0);
+        }
+
+    }
+    
+    
+}
+
+
+struct icalproperty_impl*
+icalproperty_new_impl (icalproperty_kind kind)
+{
+    struct icalproperty_impl* prop;
+
+    if ( ( prop = (struct icalproperty_impl*)
+           malloc(sizeof(struct icalproperty_impl))) == 0) {
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        return 0;
+    }
+    
+    strcpy(prop->id,"prop");
+
+    prop->kind = kind;
+    prop->parameters = pvl_newlist();
+    prop->parameter_iterator = 0;
+    prop->value = 0;
+    prop->x_name = 0;
+    prop->parent = 0;
+
+    return prop;
+}
+
+
+icalproperty*
+icalproperty_new (icalproperty_kind kind)
+{
+    if(kind == ICAL_NO_PROPERTY){
+        return 0;
+    }
+
+    return (icalproperty*)icalproperty_new_impl(kind);
+}
+
+
+icalproperty*
+icalproperty_new_clone(icalproperty* prop)
+{
+    struct icalproperty_impl *old = (struct icalproperty_impl*)prop;
+    struct icalproperty_impl *new = icalproperty_new_impl(old->kind);
+    pvl_elem p;
+
+    icalerror_check_arg_rz((prop!=0),"Prop");
+    icalerror_check_arg_rz((old!=0),"old");
+    icalerror_check_arg_rz((new!=0),"new");
+
+    if (old->value !=0) {
+        new->value = icalvalue_new_clone(old->value);
+    }
+
+    if (old->x_name != 0) {
+
+        new->x_name = icalmemory_strdup(old->x_name);
+        
+        if (new->x_name == 0) {
+            icalproperty_free(new);
+            icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+            return 0;
+        }
+    }
+
+    for(p=pvl_head(old->parameters);p != 0; p = pvl_next(p)){
+        icalparameter *param = icalparameter_new_clone(pvl_data(p));
+        
+        if (param == 0){
+            icalproperty_free(new);
+            icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+            return 0;
+        }
+
+        pvl_push(new->parameters,param);
+    
+    } 
+
+    return new;
+
+}
+
+icalproperty* icalproperty_new_from_string(const char* str)
+{
+
+    size_t buf_size = 1024;
+    char* buf = icalmemory_new_buffer(buf_size);
+    char* buf_ptr = buf;  
+    icalproperty *prop;
+    icalcomponent *comp;
+    int errors  = 0;
+
+    icalerror_check_arg_rz( (str!=0),"str");
+
+    /* Is this a HACK or a crafty reuse of code? */
+
+    icalmemory_append_string(&buf, &buf_ptr, &buf_size, "BEGIN:VCALENDAR\n");
+    icalmemory_append_string(&buf, &buf_ptr, &buf_size, str);
+    icalmemory_append_string(&buf, &buf_ptr, &buf_size, "\n");    
+    icalmemory_append_string(&buf, &buf_ptr, &buf_size, "END:VCALENDAR\n");
+
+    comp = icalparser_parse_string(buf);
+
+    if(comp == 0){
+        icalerror_set_errno(ICAL_PARSE_ERROR);
+        return 0;
+    }
+
+    errors = icalcomponent_count_errors(comp);
+
+    prop = icalcomponent_get_first_property(comp,ICAL_ANY_PROPERTY);
+
+    icalcomponent_remove_property(comp,prop);
+
+    icalcomponent_free(comp);
+    free(buf);
+
+    if(errors > 0){
+        icalproperty_free(prop);
+        return 0;
+    } else {
+        return prop;
+    }
+    
+}
+
+void
+icalproperty_free (icalproperty* prop)
+{
+    struct icalproperty_impl *p;
+
+    icalparameter* param;
+    
+    icalerror_check_arg_rv((prop!=0),"prop");
+
+    p = (struct icalproperty_impl*)prop;
+
+#ifdef ICAL_FREE_ON_LIST_IS_ERROR
+    icalerror_assert( (p->parent ==0),"Tried to free a property that is still attached to a component. ");
+    
+#else
+    if(p->parent !=0){
+        return;
+    }
+#endif
+
+    if (p->value != 0){
+        icalvalue_set_parent(p->value,0);
+        icalvalue_free(p->value);
+    }
+    
+    while( (param = pvl_pop(p->parameters)) != 0){
+        icalparameter_free(param);
+    }
+    
+    pvl_free(p->parameters);
+    
+    if (p->x_name != 0) {
+        free(p->x_name);
+    }
+    
+    p->kind = ICAL_NO_PROPERTY;
+    p->parameters = 0;
+    p->parameter_iterator = 0;
+    p->value = 0;
+    p->x_name = 0;
+    p->id[0] = 'X';
+    
+    free(p);
+
+}
+
+
+const char*
+icalproperty_as_ical_string (icalproperty* prop)
+{   
+    icalparameter *param;
+
+    /* Create new buffer that we can append names, parameters and a
+       value to, and reallocate as needed. Later, this buffer will be
+       copied to a icalmemory_tmp_buffer, which is managed internally
+       by libical, so it can be given to the caller without fear of
+       the caller forgetting to free it */
+
+    const char* property_name = 0; 
+    size_t buf_size = 1024;
+    char* buf = icalmemory_new_buffer(buf_size);
+    char* buf_ptr = buf;
+    icalvalue* value;
+    char *out_buf;
+
+    char newline[] = "\n";
+
+    struct icalproperty_impl *impl = (struct icalproperty_impl*)prop;
+    
+    icalerror_check_arg_rz( (prop!=0),"prop");
+
+
+    /* Append property name */
+
+    if (impl->kind == ICAL_X_PROPERTY && impl->x_name != 0){
+        property_name = impl->x_name;
+    } else {
+        property_name = icalproperty_kind_to_string(impl->kind);
+    }
+
+    if (property_name == 0 ) {
+        icalerror_warn("Got a property of an unknown kind.");
+        icalmemory_free_buffer(buf);
+        return 0;
+        
+    }
+
+
+    icalmemory_append_string(&buf, &buf_ptr, &buf_size, property_name);
+    icalmemory_append_string(&buf, &buf_ptr, &buf_size, newline);
+
+
+
+    /* Determine what VALUE parameter to include. The VALUE parameters
+       are ignored in the normal parameter printing ( the block after
+       this one, so we need to do it here */
+    {
+        const char* kind_string = 0;
+
+        icalparameter *orig_val_param
+            = icalproperty_get_first_parameter(prop,ICAL_VALUE_PARAMETER);
+
+        icalvalue *value = icalproperty_get_value(impl);
+
+        icalvalue_kind orig_kind = ICAL_NO_VALUE;
+
+        icalvalue_kind this_kind = ICAL_NO_VALUE;
+
+        icalvalue_kind default_kind 
+            =  icalproperty_kind_to_value_kind(impl->kind);
+
+        if(orig_val_param){
+            orig_kind = (icalvalue_kind)icalparameter_get_value(orig_val_param);
+        }
+
+        if(value != 0){
+            this_kind = icalvalue_isa(value);
+        }
+        
+        
+        if(this_kind == default_kind &&
+           orig_kind != ICAL_NO_VALUE){
+            /* The kind is the default, so it does not need to be
+               included, but do it anyway, since it was explicit in
+               the property. But, use the default, not the one
+               specified in the property */
+            
+            kind_string = icalvalue_kind_to_string(default_kind);
+
+        } else if (this_kind != default_kind && this_kind !=  ICAL_NO_VALUE){
+            /* Not the default, so it must be specified */
+            kind_string = icalvalue_kind_to_string(this_kind);
+        } else {
+            /* Don'tinclude the VALUE parameter at all */
+        }
+
+        if(kind_string!=0){
+            icalmemory_append_string(&buf, &buf_ptr, &buf_size, " ;");
+            icalmemory_append_string(&buf, &buf_ptr, &buf_size, "VALUE=");
+            icalmemory_append_string(&buf, &buf_ptr, &buf_size, kind_string);
+            icalmemory_append_string(&buf, &buf_ptr, &buf_size, newline);
+        }
+        
+
+    }
+
+    /* Append parameters */
+    for(param = icalproperty_get_first_parameter(prop,ICAL_ANY_PARAMETER);
+        param != 0; 
+        param = icalproperty_get_next_parameter(prop,ICAL_ANY_PARAMETER)) {
+
+        char* kind_string = icalparameter_as_ical_string(param); 
+        icalparameter_kind kind = icalparameter_isa(param);
+
+        if(kind==ICAL_VALUE_PARAMETER){
+            continue;
+        }
+
+        if (kind_string == 0 ) {
+            char temp[TMP_BUF_SIZE];
+            snprintf(temp, TMP_BUF_SIZE,"Got a parameter of unknown kind in %s property",property_name);
+            icalerror_warn(temp);
+            continue;
+        }
+
+        icalmemory_append_string(&buf, &buf_ptr, &buf_size, " ;");
+            icalmemory_append_string(&buf, &buf_ptr, &buf_size, kind_string);
+         icalmemory_append_string(&buf, &buf_ptr, &buf_size, newline);
+
+    }    
+
+    /* Append value */
+
+    icalmemory_append_string(&buf, &buf_ptr, &buf_size, " :");
+
+    value = icalproperty_get_value(prop);
+
+    if (value != 0){
+        const char *str = icalvalue_as_ical_string(value);
+        icalerror_assert((str !=0),"Could not get string representation of a value");
+        icalmemory_append_string(&buf, &buf_ptr, &buf_size, str);
+    } else {
+        icalmemory_append_string(&buf, &buf_ptr, &buf_size,"ERROR: No Value"); 
+        
+    }
+    
+    icalmemory_append_string(&buf, &buf_ptr, &buf_size, newline);
+
+    /* Now, copy the buffer to a tmp_buffer, which is safe to give to
+       the caller without worring about de-allocating it. */
+
+    
+    out_buf = icalmemory_tmp_buffer(strlen(buf)+1);
+    strcpy(out_buf, buf);
+
+    icalmemory_free_buffer(buf);
+
+    return out_buf;
+}
+
+
+
+icalproperty_kind
+icalproperty_isa (icalproperty* property)
+{
+    struct icalproperty_impl *p = (struct icalproperty_impl*)property;
+
+   if(property != 0){
+       return p->kind;
+   }
+
+   return ICAL_NO_PROPERTY;
+}
+
+int
+icalproperty_isa_property (void* property)
+{
+    struct icalproperty_impl *impl = (struct icalproperty_impl*)property;
+
+    icalerror_check_arg_rz( (property!=0), "property");
+
+    if (strcmp(impl->id,"prop") == 0) {
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+
+void
+icalproperty_add_parameter (icalproperty* prop,icalparameter* parameter)
+{
+    struct icalproperty_impl *p = (struct icalproperty_impl*)prop;
+    
+   icalerror_check_arg_rv( (prop!=0),"prop");
+   icalerror_check_arg_rv( (parameter!=0),"parameter");
+    
+   pvl_push(p->parameters, parameter);
+
+}
+
+void
+icalproperty_set_parameter (icalproperty* prop,icalparameter* parameter)
+{
+    icalparameter_kind kind;
+    
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalerror_check_arg_rv( (parameter!=0),"parameter");
+
+    kind = icalparameter_isa(parameter);
+
+    icalproperty_remove_parameter(prop,kind);
+
+    icalproperty_add_parameter(prop,parameter);
+}
+
+void icalproperty_set_parameter_from_string(icalproperty* prop,
+                                            const char* name, const char* value)
+{
+
+    icalparameter_kind kind;
+    icalparameter *param;
+
+    icalerror_check_arg_rv( (prop!=0),"prop");
+    icalerror_check_arg_rv( (name!=0),"name");
+    icalerror_check_arg_rv( (value!=0),"value");
+    
+    kind = icalparameter_string_to_kind(name);
+
+    if(kind == ICAL_NO_PARAMETER){
+        icalerror_set_errno(ICAL_BADARG_ERROR);
+        return;
+    }
+
+    param  = icalparameter_new_from_value_string(kind,value);
+
+    if (param == 0){
+        icalerror_set_errno(ICAL_BADARG_ERROR);
+        return;
+    }
+
+    icalproperty_set_parameter(prop,param);
+
+}
+
+const char* icalproperty_get_parameter_as_string(icalproperty* prop,
+                                                 const char* name)
+{
+    icalparameter_kind kind;
+    icalparameter *param;
+    char* str;
+    char* pv;
+
+    icalerror_check_arg_rz( (prop!=0),"prop");
+    icalerror_check_arg_rz( (name!=0),"name");
+    
+    kind = icalparameter_string_to_kind(name);
+
+    if(kind == ICAL_NO_PROPERTY){
+        /* icalenum_string_to_parameter_kind will set icalerrno */
+        return 0;
+    }
+
+    param = icalproperty_get_first_parameter(prop,kind);
+
+    if (param == 0){
+        return 0;
+    }
+
+    str = icalparameter_as_ical_string(param);
+
+    pv = strchr(str,'=');
+
+    if(pv == 0){
+        icalerror_set_errno(ICAL_INTERNAL_ERROR);
+        return 0;
+    }
+
+    return pv+1;
+
+}
+
+void
+icalproperty_remove_parameter (icalproperty* prop, icalparameter_kind kind)
+{
+    pvl_elem p;     
+    struct icalproperty_impl *impl = (struct icalproperty_impl*)prop;
+
+    icalerror_check_arg_rv((prop!=0),"prop");
+    
+    for(p=pvl_head(impl->parameters);p != 0; p = pvl_next(p)){
+        icalparameter* param = (icalparameter *)pvl_data (p);
+        if (icalparameter_isa(param) == kind) {
+            pvl_remove (impl->parameters, p);
+            icalparameter_free (param);
+            break;
+        }
+    }                       
+}
+
+
+int
+icalproperty_count_parameters (icalproperty* prop)
+{
+    struct icalproperty_impl *p = (struct icalproperty_impl*)prop;
+
+    if(prop != 0){
+        return pvl_count(p->parameters);
+    }
+
+    icalerror_set_errno(ICAL_USAGE_ERROR);
+    return -1;
+}
+
+
+icalparameter*
+icalproperty_get_first_parameter (icalproperty* prop, icalparameter_kind kind)
+{
+   struct icalproperty_impl *p = (struct icalproperty_impl*)prop;
+
+   icalerror_check_arg_rz( (prop!=0),"prop");
+   
+   p->parameter_iterator = pvl_head(p->parameters);
+
+   if (p->parameter_iterator == 0) {
+       return 0;
+   }
+
+   for( p->parameter_iterator = pvl_head(p->parameters);
+        p->parameter_iterator !=0;
+        p->parameter_iterator = pvl_next(p->parameter_iterator)){
+
+       icalparameter *param = (icalparameter*)pvl_data(p->parameter_iterator);
+
+       if(icalparameter_isa(param) == kind || kind == ICAL_ANY_PARAMETER){
+           return param;
+       }
+   }
+
+   return 0;
+}
+
+
+icalparameter*
+icalproperty_get_next_parameter (icalproperty* prop, icalparameter_kind kind)
+{
+    struct icalproperty_impl *p = (struct icalproperty_impl*)prop;
+    
+    icalerror_check_arg_rz( (prop!=0),"prop");
+    
+    if (p->parameter_iterator == 0) {
+        return 0;
+    }
+    
+    for( p->parameter_iterator = pvl_next(p->parameter_iterator);
+         p->parameter_iterator !=0;
+         p->parameter_iterator = pvl_next(p->parameter_iterator)){
+        
+        icalparameter *param = (icalparameter*)pvl_data(p->parameter_iterator);
+        
+        if(icalparameter_isa(param) == kind || kind == ICAL_ANY_PARAMETER){
+            return param;
+        }
+    }
+    
+    return 0;
+
+}
+
+void
+icalproperty_set_value (icalproperty* prop, icalvalue* value)
+{
+    struct icalproperty_impl *p = (struct icalproperty_impl*)prop;
+
+    icalerror_check_arg_rv((prop !=0),"prop");
+    icalerror_check_arg_rv((value !=0),"value");
+    
+    if (p->value != 0){
+        icalvalue_set_parent(p->value,0);
+        icalvalue_free(p->value);
+        p->value = 0;
+    }
+
+    p->value = value;
+    
+    icalvalue_set_parent(value,prop);
+}
+
+
+void icalproperty_set_value_from_string(icalproperty* prop,const char* str,
+                                        const char* type)
+{
+    icalvalue *oval,*nval;
+    icalvalue_kind kind = ICAL_NO_VALUE;
+
+    icalerror_check_arg_rv( (prop!=0),"prop"); 
+    icalerror_check_arg_rv( (str!=0),"str");
+    icalerror_check_arg_rv( (type!=0),"type");
+   
+    if(strcmp(type,"NO")==0){
+        /* Get the type from the value the property already has, if it exists */
+        oval = icalproperty_get_value(prop);
+        if(oval != 0){
+            /* Use the existing value kind */
+            kind  = icalvalue_isa(oval);
+        } else {   
+            /* Use the default kind for the property */
+            kind = icalproperty_kind_to_value_kind(icalproperty_isa(prop));
+        }
+    } else {
+        /* Use the given kind string */
+        kind = icalvalue_string_to_kind(type);
+    }
+
+    if(kind == ICAL_NO_VALUE){
+        icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+        return;
+    }
+
+    nval = icalvalue_new_from_string(kind, str);
+
+    if(nval == 0){
+        /* icalvalue_new_from_string sets errno */
+        assert(icalerrno != ICAL_NO_ERROR);
+        return;
+    }
+
+    icalproperty_set_value(prop,nval);
+
+
+}
+
+icalvalue*
+icalproperty_get_value (icalproperty* prop)
+{
+    struct icalproperty_impl *p = (struct icalproperty_impl*)prop;
+    
+    icalerror_check_arg_rz( (prop!=0),"prop");
+    
+    return p->value;
+}
+
+const char* icalproperty_get_value_as_string(icalproperty* prop)
+{
+    icalvalue *value;
+    
+    struct icalproperty_impl *impl = (struct icalproperty_impl*)prop;
+    
+    icalerror_check_arg_rz( (prop!=0),"prop");
+
+    value = impl->value; 
+
+    return icalvalue_as_ical_string(value);
+}
+
+
+void icalproperty_set_x_name(icalproperty* prop, const char* name)
+{
+    struct icalproperty_impl *impl = (struct icalproperty_impl*)prop;
+
+    icalerror_check_arg_rv( (name!=0),"name");
+    icalerror_check_arg_rv( (prop!=0),"prop");
+
+    if (impl->x_name != 0) {
+        free(impl->x_name);
+    }
+
+    impl->x_name = icalmemory_strdup(name);
+
+    if(impl->x_name == 0){
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+    }
+
+}
+                              
+const char* icalproperty_get_x_name(icalproperty* prop){
+
+    struct icalproperty_impl *impl = (struct icalproperty_impl*)prop;
+
+    icalerror_check_arg_rz( (prop!=0),"prop");
+
+    return impl->x_name;
+}
+
+
+/* From Jonathan Yue <jonathan.yue@cp.net>    */
+const char* icalproperty_get_name (icalproperty* prop)
+{
+
+    const char* property_name = 0;
+    size_t buf_size = 256;
+    char* buf = icalmemory_new_buffer(buf_size);
+    char* buf_ptr = buf;  
+
+    struct icalproperty_impl *impl = (struct icalproperty_impl*)prop;
+
+    icalerror_check_arg_rz( (prop!=0),"prop");
+ 
+    if (impl->kind == ICAL_X_PROPERTY && impl->x_name != 0){
+        property_name = impl->x_name;
+    } else {
+        property_name = icalproperty_kind_to_string(impl->kind);
+    }
+ 
+    if (property_name == 0 ) {
+        icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+        return 0;
+
+    } else {
+        /* _append_string will automatically grow the buffer if
+           property_name is longer than the initial buffer size */
+        icalmemory_append_string(&buf, &buf_ptr, &buf_size, property_name);
+    }
+ 
+    /* Add the buffer to the temporary buffer ring -- the caller will
+       not have to free the memory. */
+    icalmemory_add_tmp_buffer(buf);
+ 
+    return buf;
+}
+                            
+
+
+
+void icalproperty_set_parent(icalproperty* property,
+                             icalcomponent* component)
+{
+    struct icalproperty_impl *impl = (struct icalproperty_impl*)property;
+
+    icalerror_check_arg_rv( (property!=0),"property");
+    
+    impl->parent = component;
+}
+
+icalcomponent* icalproperty_get_parent(icalproperty* property)
+{
+    struct icalproperty_impl *impl = (struct icalproperty_impl*)property;
+ 
+    icalerror_check_arg_rz( (property!=0),"property");
+
+    return impl->parent;
+}
+
+
+
+
+
+
+
+/* Everything below this line is machine generated. Do not edit. */
diff --git a/libical/src/libical/icalproperty.h b/libical/src/libical/icalproperty.h
new file mode 100644
index 0000000..e39c6b5
--- a/dev/null
+++ b/libical/src/libical/icalproperty.h
@@ -0,0 +1,122 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+  FILE: icalproperty.h
+  CREATOR: eric 20 March 1999
+
+
+  $Id$
+  $Locker$
+
+  
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalparam.h
+
+  ======================================================================*/
+
+
+#ifndef ICALPROPERTY_H
+#define ICALPROPERTY_H
+
+#include <time.h>
+
+#ifdef _WIN32
+#include <stdio.h> /* for printf */
+#include <stdarg.h> /* for va_list, va_start, etc. */
+#endif
+
+#include "icalderivedparameter.h"
+
+#include "icalvalue.h"  
+#include "icalrecur.h"
+
+/* Actually in icalderivedproperty.h:
+   typedef void icalproperty; */
+
+#include "icalderivedproperty.h" /* To get icalproperty_kind enumerations */
+
+// void icalproperty_add_parameters(struct icalproperty_impl *prop,va_list args);
+
+icalproperty* icalproperty_new(icalproperty_kind kind);
+
+icalproperty* icalproperty_new_clone(icalproperty * prop);
+
+icalproperty* icalproperty_new_from_string(const char* str);
+
+const char* icalproperty_as_ical_string(icalproperty* prop);
+
+void  icalproperty_free(icalproperty* prop);
+
+icalproperty_kind icalproperty_isa(icalproperty* property);
+int icalproperty_isa_property(void* property);
+
+void icalproperty_add_parameter(icalproperty* prop,icalparameter* parameter);
+void icalproperty_set_parameter(icalproperty* prop,icalparameter* parameter);
+void icalproperty_set_parameter_from_string(icalproperty* prop,
+                                            const char* name, const char* value);
+const char* icalproperty_get_parameter_as_string(icalproperty* prop,
+                                                 const char* name);
+
+void icalproperty_remove_parameter(icalproperty* prop,
+                                   icalparameter_kind kind);
+
+int icalproperty_count_parameters(icalproperty* prop);
+
+/* Iterate through the parameters */
+icalparameter* icalproperty_get_first_parameter(icalproperty* prop,
+                                                icalparameter_kind kind);
+icalparameter* icalproperty_get_next_parameter(icalproperty* prop,
+                                                icalparameter_kind kind);
+/* Access the value of the property */
+void icalproperty_set_value(icalproperty* prop, icalvalue* value);
+void icalproperty_set_value_from_string(icalproperty* prop,const char* value, const char* kind);
+
+icalvalue* icalproperty_get_value(icalproperty* prop);
+const char* icalproperty_get_value_as_string(icalproperty* prop);
+
+/* Deal with X properties */
+
+void icalproperty_set_x_name(icalproperty* prop, const char* name);
+const char* icalproperty_get_x_name(icalproperty* prop);
+
+/* Return the name of the property -- the type name converted to a
+   string, or the value of _get_x_name if the type is and X property */
+const char* icalproperty_get_name (icalproperty* prop);
+
+icalvalue_kind icalparameter_value_to_value_kind(icalparameter_value value);
+
+/* Convert kinds to string and get default value type */
+
+icalvalue_kind icalproperty_kind_to_value_kind(icalproperty_kind kind);
+icalvalue_kind icalproperty_value_kind_to_kind(icalvalue_kind kind);
+const char* icalproperty_kind_to_string(icalproperty_kind kind);
+icalproperty_kind icalproperty_string_to_kind(const char* string);
+
+icalproperty_method icalproperty_string_to_method(const char* str);
+const char* icalproperty_method_to_string(icalproperty_method method);
+
+
+const char* icalproperty_enum_to_string(int e);
+int icalproperty_string_to_enum(const char* str);
+
+const char* icalproperty_status_to_string(icalproperty_status);
+icalproperty_status icalproperty_string_to_status(const char* string);
+
+int icalproperty_enum_belongs_to_property(icalproperty_kind kind, int e);
+
+
+
+
+#endif /*ICALPROPERTY_H*/
diff --git a/libical/src/libical/icalrecur.c b/libical/src/libical/icalrecur.c
new file mode 100644
index 0000000..203ce70
--- a/dev/null
+++ b/libical/src/libical/icalrecur.c
@@ -0,0 +1,2315 @@
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: icalrecur.c
+  CREATOR: eric 16 May 2000
+  
+  $Id$
+  $Locker$
+    
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+
+  How this code works:
+
+  Processing starts when the caller generates a new recurrence
+  iterator via icalrecur_iterator_new(). This routine copies the
+  recurrence rule into the iterator and extracts things like start and
+  end dates. Then, it checks if the rule is legal, using some logic
+  from RFC2445 and some logic that probably should be in RFC2445.
+
+  Then, icalrecur_iterator_new() re-writes some of the BY*
+  arrays. This involves ( via a call to setup_defaults() ) :
+
+  1) For BY rule parts with no data ( ie BYSECOND was not specified )
+  copy the corresponding time part from DTSTART into the BY array. (
+  So impl->by_ptrs[BY_SECOND] will then have one element if is
+  originally had none ) This only happens if the BY* rule part data
+  would expand the number of occurrences in the occurrence set. This
+  lets the code ignore DTSTART later on and still use it to get the
+  time parts that were not specified in any other way.
+  
+  2) For the by rule part that are not the same interval as the
+  frequency -- for HOURLY anything but BYHOUR, for instance -- copy the
+  first data element from the rule part into the first occurrence. For
+  example, for "INTERVAL=MONTHLY and BYHOUR=10,30", initialize the
+  first time to be returned to have an hour of 10.
+
+  Finally, for INTERVAL=YEARLY, the routine expands the rule to get
+  all of the days specified in the rule. The code will do this for
+  each new year, and this is the first expansion. This is a special
+  case for the yearly interval; no other frequency gets expanded this
+  way. The yearly interval is the most complex, so some special
+  processing is required.
+
+  After creating a new iterator, the caller will make successive calls
+  to icalrecur_iterator_next() to get the next time specified by the
+  rule. The main part of this routine is a switch on the frequency of
+  the rule. Each different frequency is handled by a different
+  routine. 
+
+  For example, next_hour handles the case of INTERVAL=HOURLY, and it
+  is called by other routines to get the next hour. First, the routine
+  tries to get the next minute part of a time with a call to
+  next_minute(). If next_minute() returns 1, it has reached the end of
+  its data, usually the last element of the BYMINUTE array. Then, if
+  there is data in the BYHOUR array, the routine changes the hour to
+  the next one in the array. If INTERVAL=HOURLY, the routine advances
+  the hour by the interval.
+
+  If the routine used the last hour in the BYHOUR array, and the
+  INTERVAL=HOURLY, then the routine calls increment_monthday() to set
+  the next month day. The increment_* routines may call higher routine
+  to increment the month or year also.
+
+  The code for INTERVAL=DAILY is handled by next_day(). First, the
+  routine tries to get the next hour part of a time with a call to
+  next_hour. If next_hour() returns 1, it has reached the end of its
+  data, usually the last element of the BYHOUR array. This means that
+  next_day() should increment the time to the next day. If FREQUENCY==DAILY,
+  the routine increments the day by the interval; otherwise, it
+  increments the day by 1.
+
+  Next_day() differs from next_hour because it does not use the BYDAY
+  array to select an appropriate day. Instead, it returns every day (
+  incrementing by 1 if the frequency is not DAILY with INTERVAL!=1)
+  Any days that are not specified in an non-empty BYDAY array are
+  filtered out later.
+
+  Generally, the flow of these routine is for a next_* call a next_*
+  routine of a lower interval ( next_day calls next_hour) and then to
+  possibly call an increment_* routine of an equal or higher
+  interval. ( next_day calls increment_monthday() )
+
+  When the call to the original next_* routine returns,
+  icalrecur_iterator_next() will check the returned data against other
+  BYrule parts to determine if is should be excluded by calling
+  check_contracting_rules. Generally, a contracting rule is any with a
+  larger time span than the interval. For instance, if
+  INTERVAL=DAILY, BYMONTH is a contracting rule part. 
+
+  Check_contracting_rules() uses icalrecur_check_rulepart() to do its
+  work. icalrecur_check_rulepart() uses expand_map[] to determine if a rule
+  is contracting, and if it is, and if the BY rule part has some data,
+  then the routine checks if the value of a component of the time is
+  part of the byrule part. For instance, for "INTERVAL=DAILY;
+  BYMONTH=6,10", icalrecur_check_rulepart() would check that the time value
+  given to it has a month of either 6 or 10.
+
+  Finally, icalrecur_iterator_next() does a few other checks on the
+  time value, and if it passes, it returns the time.
+
+  A note about the end_of_data flag. The flag indicates that the
+  routine is at the end of its data -- the last BY rule if the routine
+  is using by rules, or the last day of the week/month/year/etc if
+  not.
+
+  This flag is usually set early in a next_* routine and returned in
+  the end. The way it is used allows the next_* routine to set the
+  last time back to the first element in a BYxx rule, and then signal
+  to the higer level routine to increment the next higher level. For
+  instance. WITH FREQ=MONTHLY;BYDAY=TU,FR, After next_weekday_by_month
+  runs though both TU and FR, it sets the week day back to TU and sets
+  end_of_data to 1x. This signals next_month to increment the month.
+
+
+ ======================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "icalrecur.h"
+
+#ifdef ICAL_NO_LIBICAL
+#define icalerror_set_errno(x)
+#define  icalerror_check_arg_rv(x,y)
+#else
+#include "icalerror.h"
+#include "icalmemory.h"
+#endif
+
+#include <stdlib.h> /* for malloc */
+#include <errno.h> /* for errno */
+#include <string.h> /* for strdup and strchr*/
+#include <assert.h>
+#include <stddef.h> /* For offsetof() macro */
+
+#include "pvl.h"
+
+#define TEMP_MAX 1024
+
+
+#define BYDAYIDX impl->by_indices[BY_DAY]
+#define BYDAYPTR impl->by_ptrs[BY_DAY]
+
+#define BYMONIDX impl->by_indices[BY_MONTH]
+#define BYMONPTR impl->by_ptrs[BY_MONTH]
+
+#define BYMDIDX impl->by_indices[BY_MONTH_DAY]
+#define BYMDPTR impl->by_ptrs[BY_MONTH_DAY]
+
+#define BYWEEKIDX impl->by_indices[BY_WEEK_NO]
+#define BYWEEKPTR impl->by_ptrs[BY_WEEK_NO]
+
+const char* icalrecur_freq_to_string(icalrecurrencetype_frequency kind);
+icalrecurrencetype_frequency icalrecur_string_to_freq(const char* str);
+
+const char* icalrecur_weekday_to_string(icalrecurrencetype_weekday kind);
+icalrecurrencetype_weekday icalrecur_string_to_weekday(const char* str);
+
+
+
+/*********************** Rule parsing routines ************************/
+
+struct icalrecur_parser {
+        const char* rule;
+        char* copy;
+        char* this_clause;
+        char* next_clause;
+
+        struct icalrecurrencetype rt;
+};
+
+const char* icalrecur_first_clause(struct icalrecur_parser *parser)
+{
+    char *idx;
+    parser->this_clause = parser->copy;
+    
+    idx = strchr(parser->this_clause,';');
+
+    if (idx == 0){
+        parser->next_clause = 0;
+        return 0;
+    }
+
+    *idx = 0;
+    idx++;
+    parser->next_clause = idx;
+
+    return parser->this_clause;
+
+}
+
+const char* icalrecur_next_clause(struct icalrecur_parser *parser)
+{
+    char* idx;
+
+    parser->this_clause = parser->next_clause;
+
+    if(parser->this_clause == 0){
+        return 0;
+    }
+
+    idx = strchr(parser->this_clause,';');
+
+    if (idx == 0){
+        parser->next_clause = 0;
+    } else {
+
+        *idx = 0;
+        idx++;
+        parser->next_clause = idx;
+    }
+        
+    return parser->this_clause;
+
+}
+
+void icalrecur_clause_name_and_value(struct icalrecur_parser *parser,
+                                     char** name, char** value)
+{
+    char *idx;
+
+    *name = parser->this_clause;
+
+    idx = strchr(parser->this_clause,'=');
+
+    if (idx == 0){
+        *name = 0;
+        *value = 0;
+        return;
+    }
+    
+    *idx = 0;
+    idx++;
+    *value = idx;
+}
+
+void icalrecur_add_byrules(struct icalrecur_parser *parser, short *array,
+                           int size, char* vals)
+{
+    char *t, *n;
+    int i=0;
+    int sign = 1;
+    short v;
+
+    n = vals;
+
+    while(n != 0){
+
+        if(i == size){
+            return;
+        }
+        
+        t = n;
+
+        n = strchr(t,',');
+
+        if(n != 0){
+            *n = 0;
+            n++;
+        }
+        
+        /* Get optional sign. HACK. sign is not allowed for all BYxxx
+           rule parts */
+        if( *t == '-'){
+            sign = -1;
+            t++;
+        } else if (*t == '+'){
+            sign = 1;
+            t++;
+        }
+
+        v = atoi(t) * sign ;
+
+
+        array[i++] = v;
+        array[i] =  ICAL_RECURRENCE_ARRAY_MAX;
+
+    }
+
+}
+
+void icalrecur_add_bydayrules(struct icalrecur_parser *parser, const char* vals)
+{
+
+    char *t, *n;
+    int i=0;
+    int sign = 1;
+    int weekno = 0;
+    icalrecurrencetype_weekday wd;
+    short *array = parser->rt.by_day;
+    char* end;
+    char* vals_copy;
+
+    vals_copy = icalmemory_strdup(vals);
+
+    end = (char*)vals_copy+strlen(vals_copy);
+    n = vals_copy;
+
+    while(n != 0){
+        
+
+        t = n;
+
+        n = strchr(t,',');
+
+        if(n != 0){
+            *n = 0;
+            n++;
+        }
+        
+        /* Get optional sign. */
+        if( *t == '-'){
+            sign = -1;
+            t++;
+        } else if (*t == '+'){
+            sign = 1;
+            t++;
+        } else {
+            sign = 1;
+        }
+
+        weekno = 0;
+        /* Get Optional weekno */
+        if( sscanf(t,"%d",&weekno) != 0){
+            if (n != 0){
+                int weeknolen = (n-t)-3; /* 3 -> one for \0, 2 for day name */
+                /* could use abs(log10(weekno))+1, but that needs libm */
+                t += weeknolen;
+            } else {
+                t = end -2;
+            }
+        }
+
+        wd = icalrecur_string_to_weekday(t);
+
+        array[i++] = sign* ((int)wd + 8*weekno);
+        array[i] =  ICAL_RECURRENCE_ARRAY_MAX;
+
+    }
+
+    free(vals_copy);
+
+}
+
+
+struct icalrecurrencetype icalrecurrencetype_from_string(const char* str)
+{
+    struct icalrecur_parser parser;
+
+    memset(&parser,0,sizeof(parser));
+    icalrecurrencetype_clear(&parser.rt);
+
+    icalerror_check_arg_re(str!=0,"str",parser.rt);
+
+
+    /* Set up the parser struct */
+    parser.rule = str;
+    parser.copy = icalmemory_strdup(parser.rule);
+    parser.this_clause = parser.copy;
+
+    if(parser.copy == 0){
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        return parser.rt;
+    }
+
+    /* Loop through all of the clauses */
+    for(icalrecur_first_clause(&parser); 
+        parser.this_clause != 0;
+        icalrecur_next_clause(&parser))
+    {
+        char *name, *value;
+        icalrecur_clause_name_and_value(&parser,&name,&value);
+
+        if(name == 0){
+            icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+            icalrecurrencetype_clear(&parser.rt);
+            return parser.rt;
+        }
+
+        if (strcmp(name,"FREQ") == 0){
+            parser.rt.freq = icalrecur_string_to_freq(value);
+        } else if (strcmp(name,"COUNT") == 0){
+            parser.rt.count = atoi(value);
+        } else if (strcmp(name,"UNTIL") == 0){
+            parser.rt.until = icaltime_from_string(value);
+        } else if (strcmp(name,"INTERVAL") == 0){
+            parser.rt.interval = atoi(value);
+        } else if (strcmp(name,"WKST") == 0){
+            parser.rt.week_start = icalrecur_string_to_weekday(value);
+        } else if (strcmp(name,"BYSECOND") == 0){
+            icalrecur_add_byrules(&parser,parser.rt.by_second,
+                                  ICAL_BY_SECOND_SIZE,value);
+        } else if (strcmp(name,"BYMINUTE") == 0){
+            icalrecur_add_byrules(&parser,parser.rt.by_minute,
+                                  ICAL_BY_MINUTE_SIZE,value);
+        } else if (strcmp(name,"BYHOUR") == 0){
+            icalrecur_add_byrules(&parser,parser.rt.by_hour,
+                                  ICAL_BY_HOUR_SIZE,value);
+        } else if (strcmp(name,"BYDAY") == 0){
+            icalrecur_add_bydayrules(&parser,value);
+        } else if (strcmp(name,"BYMONTHDAY") == 0){
+            icalrecur_add_byrules(&parser,parser.rt.by_month_day,
+                                  ICAL_BY_MONTHDAY_SIZE,value);
+        } else if (strcmp(name,"BYYEARDAY") == 0){
+            icalrecur_add_byrules(&parser,parser.rt.by_year_day,
+                                  ICAL_BY_YEARDAY_SIZE,value);
+        } else if (strcmp(name,"BYWEEKNO") == 0){
+            icalrecur_add_byrules(&parser,parser.rt.by_week_no,
+                                  ICAL_BY_WEEKNO_SIZE,value);
+        } else if (strcmp(name,"BYMONTH") == 0){
+            icalrecur_add_byrules(&parser,parser.rt.by_month,
+                                  ICAL_BY_MONTH_SIZE,value);
+        } else if (strcmp(name,"BYSETPOS") == 0){
+            icalrecur_add_byrules(&parser,parser.rt.by_set_pos,
+                                  ICAL_BY_SETPOS_SIZE,value);
+        } else {
+            icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+            icalrecurrencetype_clear(&parser.rt);
+            return parser.rt;
+        }
+        
+    }
+
+    free(parser.copy);
+
+    return parser.rt;
+
+}
+
+#ifndef ICAL_NO_LIBICAL
+
+struct { char* str;size_t offset; short limit;  } recurmap[] = 
+{
+    {";BYSECOND=",offsetof(struct icalrecurrencetype,by_second),60},
+    {";BYMINUTE=",offsetof(struct icalrecurrencetype,by_minute),60},
+    {";BYHOUR=",offsetof(struct icalrecurrencetype,by_hour),24},
+    {";BYDAY=",offsetof(struct icalrecurrencetype,by_day),7},
+    {";BYMONTHDAY=",offsetof(struct icalrecurrencetype,by_month_day),31},
+    {";BYYEARDAY=",offsetof(struct icalrecurrencetype,by_year_day),366},
+    {";BYWEEKNO=",offsetof(struct icalrecurrencetype,by_week_no),52},
+    {";BYMONTH=",offsetof(struct icalrecurrencetype,by_month),12},
+    {";BYSETPOS=",offsetof(struct icalrecurrencetype,by_set_pos),366},
+    {0,0,0},
+};
+
+/* A private routine in icalvalue.c */
+void print_datetime_to_string(char* str,  struct icaltimetype *data);
+
+char* icalrecurrencetype_as_string(struct icalrecurrencetype *recur)
+{
+    char* str;
+    char *str_p;
+    size_t buf_sz = 200;
+    char temp[20];
+    int i,j;
+
+    if(recur->freq == ICAL_NO_RECURRENCE){
+        return 0;
+    }
+
+    str = (char*)icalmemory_tmp_buffer(buf_sz);
+    str_p = str;
+
+    icalmemory_append_string(&str,&str_p,&buf_sz,"FREQ=");
+    icalmemory_append_string(&str,&str_p,&buf_sz,
+                             icalrecur_freq_to_string(recur->freq));
+
+    if(recur->until.year != 0){
+        
+        temp[0] = 0;
+        print_datetime_to_string(temp,&(recur->until));
+        
+        icalmemory_append_string(&str,&str_p,&buf_sz,";UNTIL=");
+        icalmemory_append_string(&str,&str_p,&buf_sz, temp);
+    }
+
+    if(recur->count != 0){
+        sprintf(temp,"%d",recur->count);
+        icalmemory_append_string(&str,&str_p,&buf_sz,";COUNT=");
+        icalmemory_append_string(&str,&str_p,&buf_sz, temp);
+    }
+
+    if(recur->interval != 0){
+        sprintf(temp,"%d",recur->interval);
+        icalmemory_append_string(&str,&str_p,&buf_sz,";INTERVAL=");
+        icalmemory_append_string(&str,&str_p,&buf_sz, temp);
+    }
+    
+    for(j =0; recurmap[j].str != 0; j++){
+        short* array = (short*)(recurmap[j].offset+ (size_t)recur);
+        short limit = recurmap[j].limit;
+
+        /* Skip unused arrays */
+        if( array[0] != ICAL_RECURRENCE_ARRAY_MAX ) {
+
+            icalmemory_append_string(&str,&str_p,&buf_sz,recurmap[j].str);
+            
+            for(i=0; 
+                i< limit  && array[i] != ICAL_RECURRENCE_ARRAY_MAX;
+                i++){
+                if (j == 3) { /* BYDAY */
+                    short dow = icalrecurrencetype_day_day_of_week(array[i]);
+                    const char *daystr = icalrecur_weekday_to_string(dow);
+                    short pos;
+
+                    pos = icalrecurrencetype_day_position(array[i]);  
+                    
+                    if (pos == 0)
+                        icalmemory_append_string(&str,&str_p,&buf_sz,daystr);
+                    else {
+                        sprintf(temp,"%d%s",pos,daystr);
+                        icalmemory_append_string(&str,&str_p,&buf_sz,temp);
+                    }                  
+                    
+                } else {
+                    sprintf(temp,"%d",array[i]);
+                    icalmemory_append_string(&str,&str_p,&buf_sz, temp);
+                }
+                
+                if( (i+1)<limit &&array[i+1] 
+                    != ICAL_RECURRENCE_ARRAY_MAX){
+                    icalmemory_append_char(&str,&str_p,&buf_sz,',');
+                }
+                    } 
+        }   
+    }
+
+    return  str;
+}
+#endif
+
+
+
+/************************* occurrence iteration routiens ******************/
+
+enum byrule {
+    NO_CONTRACTION = -1,
+    BY_SECOND = 0,
+    BY_MINUTE = 1,
+    BY_HOUR = 2,
+    BY_DAY = 3,
+    BY_MONTH_DAY = 4,
+    BY_YEAR_DAY = 5,
+    BY_WEEK_NO = 6,
+    BY_MONTH = 7,
+    BY_SET_POS
+};
+
+
+
+struct icalrecur_iterator_impl {
+        
+    struct icaltimetype dtstart; /* Hack. Make into time_t */
+    struct icaltimetype last; /* last time return from _iterator_next*/
+    int occurrence_no; /* number of step made on t iterator */
+    struct icalrecurrencetype rule;
+    
+    short days[366];
+    short days_index;
+    
+    enum byrule byrule;
+    short by_indices[9];
+    short orig_data[9]; /* 1 if there was data in the byrule */
+    
+    
+    short *by_ptrs[9]; /* Pointers into the by_* array elements of the rule */
+    
+};
+
+int icalrecur_iterator_sizeof_byarray(short* byarray)
+{
+    int array_itr;
+
+    for(array_itr = 0; 
+        byarray[array_itr] != ICAL_RECURRENCE_ARRAY_MAX;
+        array_itr++){
+    }
+
+    return array_itr;
+}
+
+enum expand_table {
+    UNKNOWN  = 0,
+    CONTRACT = 1,
+    EXPAND =2,
+    ILLEGAL=3
+};
+
+/* The split map indicates, for a particular interval, wether a BY_*
+   rule part expands the number of instances in the occcurrence set or
+   contracts it. 1=> contract, 2=>expand, and 3 means the pairing is
+   not allowed. */
+struct expand_split_map_struct 
+{ 
+        icalrecurrencetype_frequency frequency;
+
+        /* Elements of the 'map' array correspond to the BYxxx rules:
+           Second,Minute,Hour,Day,Month Day,Year Day,Week No,Month*/
+
+        short map[8];
+}; 
+
+struct expand_split_map_struct expand_map[] =
+{
+    {ICAL_SECONDLY_RECURRENCE,{1,1,1,1,1,1,1,1}},
+    {ICAL_MINUTELY_RECURRENCE,{2,1,1,1,1,1,1,1}},
+    {ICAL_HOURLY_RECURRENCE,  {2,2,1,1,1,1,1,1}},
+    {ICAL_DAILY_RECURRENCE,   {2,2,2,1,1,1,1,1}},
+    {ICAL_WEEKLY_RECURRENCE,  {2,2,2,2,3,3,1,1}},
+    {ICAL_MONTHLY_RECURRENCE, {2,2,2,2,2,3,3,1}},
+    {ICAL_YEARLY_RECURRENCE,  {2,2,2,2,2,2,2,2}},
+    {ICAL_NO_RECURRENCE,      {0,0,0,0,0,0,0,0}}
+
+};
+
+
+
+/* Check that the rule has only the two given interday byrule parts. */
+int icalrecur_two_byrule(struct icalrecur_iterator_impl* impl,
+                         enum byrule one,enum byrule two)
+{
+    short test_array[9];
+    enum byrule itr;
+    int passes = 0;
+
+    memset(test_array,0,9);
+
+    test_array[one] = 1;
+    test_array[two] = 1;
+
+    for(itr = BY_DAY; itr != BY_SET_POS; itr++){
+
+        if( (test_array[itr] == 0  &&
+             impl->by_ptrs[itr][0] != ICAL_RECURRENCE_ARRAY_MAX
+            ) ||
+            (test_array[itr] == 1  &&
+             impl->by_ptrs[itr][0] == ICAL_RECURRENCE_ARRAY_MAX
+                ) 
+            ) {
+            /* test failed */
+            passes = 0;
+        }
+    }
+
+    return passes;
+
+} 
+
+/* Check that the rule has only the one given interdat byrule parts. */
+int icalrecur_one_byrule(struct icalrecur_iterator_impl* impl,enum byrule one)
+{
+    int passes = 1;
+    enum byrule itr;
+
+    for(itr = BY_DAY; itr != BY_SET_POS; itr++){
+        
+        if ((itr==one && impl->by_ptrs[itr][0] == ICAL_RECURRENCE_ARRAY_MAX) ||
+            (itr!=one && impl->by_ptrs[itr][0] != ICAL_RECURRENCE_ARRAY_MAX)) {
+            passes = 0;
+        }
+    }
+
+    return passes;
+} 
+
+int count_byrules(struct icalrecur_iterator_impl* impl)
+{
+    int count = 0;
+    enum byrule itr;
+
+    for(itr = BY_DAY; itr <= BY_SET_POS; itr++){
+        if(impl->by_ptrs[itr][0] != ICAL_RECURRENCE_ARRAY_MAX){
+            count++;
+        }
+    }
+
+    return count;
+}
+
+
+void setup_defaults(struct icalrecur_iterator_impl* impl, 
+                    enum byrule byrule, icalrecurrencetype_frequency req,
+                    short deftime, int *timepart)
+{
+
+    icalrecurrencetype_frequency freq;
+    freq = impl->rule.freq;
+
+    /* Re-write the BY rule arrays with data from the DTSTART time so
+       we don't have to explicitly deal with DTSTART */
+
+    if(impl->by_ptrs[byrule][0] == ICAL_RECURRENCE_ARRAY_MAX &&
+        expand_map[freq].map[byrule] != CONTRACT){
+        impl->by_ptrs[byrule][0] = deftime;
+    }
+
+    /* Initialize the first occurence */
+    if( freq != req && expand_map[freq].map[byrule] != CONTRACT){
+        *timepart = impl->by_ptrs[byrule][0];
+    }
+
+
+}
+
+int has_by_data(struct icalrecur_iterator_impl* impl, enum byrule byrule){
+
+    return (impl->orig_data[byrule] == 1);
+}
+
+
+int expand_year_days(struct icalrecur_iterator_impl* impl,short year);
+
+
+icalrecur_iterator* icalrecur_iterator_new(struct icalrecurrencetype rule, 
+                                           struct icaltimetype dtstart)
+{
+    struct icalrecur_iterator_impl* impl;
+    icalrecurrencetype_frequency freq;
+
+    short days_in_month;
+
+    if ( ( impl = (struct icalrecur_iterator_impl *)
+           malloc(sizeof(struct icalrecur_iterator_impl))) == 0) {
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        return 0;
+    }
+
+    memset(impl,0,sizeof(struct icalrecur_iterator_impl));
+
+    impl->rule = rule;
+    impl->last = dtstart;
+    impl->dtstart = dtstart;
+    impl->days_index =0;
+    impl->occurrence_no = 0;
+    freq = impl->rule.freq;
+
+    /* Set up convienience pointers to make the code simpler. Allows
+       us to iterate through all of the BY* arrays in the rule. */
+
+    impl->by_ptrs[BY_MONTH]=impl->rule.by_month;
+    impl->by_ptrs[BY_WEEK_NO]=impl->rule.by_week_no;
+    impl->by_ptrs[BY_YEAR_DAY]=impl->rule.by_year_day;
+    impl->by_ptrs[BY_MONTH_DAY]=impl->rule.by_month_day;
+    impl->by_ptrs[BY_DAY]=impl->rule.by_day;
+    impl->by_ptrs[BY_HOUR]=impl->rule.by_hour;
+    impl->by_ptrs[BY_MINUTE]=impl->rule.by_minute;
+    impl->by_ptrs[BY_SECOND]=impl->rule.by_second;
+    impl->by_ptrs[BY_SET_POS]=impl->rule.by_set_pos;
+
+    memset(impl->orig_data,0,9);
+
+    /* Note which by rules had data in them when the iterator was
+       created. We can't use the actuall by_x arrays, because the
+       empty ones will be given default values later in this
+       routine. The orig_data array will be used later in has_by_data */
+
+    impl->orig_data[BY_MONTH]
+        = (impl->rule.by_month[0]!=ICAL_RECURRENCE_ARRAY_MAX);
+    impl->orig_data[BY_WEEK_NO]
+      =(impl->rule.by_week_no[0]!=ICAL_RECURRENCE_ARRAY_MAX);
+    impl->orig_data[BY_YEAR_DAY]
+    =(impl->rule.by_year_day[0]!=ICAL_RECURRENCE_ARRAY_MAX);
+    impl->orig_data[BY_MONTH_DAY]
+    =(impl->rule.by_month_day[0]!=ICAL_RECURRENCE_ARRAY_MAX);
+    impl->orig_data[BY_DAY]
+        = (impl->rule.by_day[0]!=ICAL_RECURRENCE_ARRAY_MAX);
+    impl->orig_data[BY_HOUR]
+        = (impl->rule.by_hour[0]!=ICAL_RECURRENCE_ARRAY_MAX);
+    impl->orig_data[BY_MINUTE]
+     = (impl->rule.by_minute[0]!=ICAL_RECURRENCE_ARRAY_MAX);
+    impl->orig_data[BY_SECOND]
+     = (impl->rule.by_second[0]!=ICAL_RECURRENCE_ARRAY_MAX);
+    impl->orig_data[BY_SET_POS]
+     = (impl->rule.by_set_pos[0]!=ICAL_RECURRENCE_ARRAY_MAX);
+
+
+    /* Check if the recurrence rule is legal */
+
+    /* If the BYYEARDAY appears, no other date rule part may appear.   */
+
+    if(icalrecur_two_byrule(impl,BY_YEAR_DAY,BY_MONTH) ||
+       icalrecur_two_byrule(impl,BY_YEAR_DAY,BY_WEEK_NO) ||
+       icalrecur_two_byrule(impl,BY_YEAR_DAY,BY_MONTH_DAY) ||
+       icalrecur_two_byrule(impl,BY_YEAR_DAY,BY_DAY) ){
+
+        icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+
+        return 0;
+    }
+
+    /* BYWEEKNO and BYMONTH rule parts may not both appear.*/
+
+    if(icalrecur_two_byrule(impl,BY_WEEK_NO,BY_MONTH)){
+        icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+
+        icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+        return 0;
+    }
+
+    /* BYWEEKNO and BYMONTHDAY rule parts may not both appear.*/
+
+    if(icalrecur_two_byrule(impl,BY_WEEK_NO,BY_MONTH_DAY)){
+        icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+
+        icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+        return 0;
+    }
+
+
+    /*For MONTHLY recurrences (FREQ=MONTHLY) neither BYYEARDAY nor
+      BYWEEKNO may appear. */
+
+    if(freq == ICAL_MONTHLY_RECURRENCE && 
+       icalrecur_one_byrule(impl,BY_WEEK_NO)){
+        icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+        return 0;
+    }
+
+
+    /*For WEEKLY recurrences (FREQ=WEEKLY) neither BYMONTHDAY nor
+      BYYEARDAY may appear. */
+
+    if(freq == ICAL_WEEKLY_RECURRENCE && 
+       icalrecur_one_byrule(impl,BY_MONTH_DAY )) {
+        icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+        return 0;
+    }
+
+    /* BYYEARDAY may only appear in YEARLY rules */
+    if(freq != ICAL_YEARLY_RECURRENCE && 
+       icalrecur_one_byrule(impl,BY_YEAR_DAY )) {
+        icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+        return 0;
+    }
+
+    /* Rewrite some of the rules and set up defaults to make later
+       processing easier. Primarily, t involves copying an element
+       from the start time into the coresponding BY_* array when the
+       BY_* array is empty */
+
+
+    setup_defaults(impl,BY_SECOND,ICAL_SECONDLY_RECURRENCE,impl->dtstart.second,
+                   &(impl->last.second));
+
+    setup_defaults(impl,BY_MINUTE,ICAL_MINUTELY_RECURRENCE,impl->dtstart.minute,
+                   &(impl->last.minute));
+
+    setup_defaults(impl,BY_HOUR,ICAL_HOURLY_RECURRENCE,impl->dtstart.hour,
+                   &(impl->last.hour));
+
+    setup_defaults(impl,BY_MONTH_DAY,ICAL_DAILY_RECURRENCE,impl->dtstart.day,
+                   &(impl->last.day));
+
+    setup_defaults(impl,BY_MONTH,ICAL_MONTHLY_RECURRENCE,impl->dtstart.month,
+                   &(impl->last.month));
+
+
+    if(impl->rule.freq == ICAL_WEEKLY_RECURRENCE ){
+
+       if(impl->by_ptrs[BY_DAY][0] == ICAL_RECURRENCE_ARRAY_MAX){
+
+           /* Weekly recurrences with no BY_DAY data should occur on the
+              same day of the week as the start time . */
+           impl->by_ptrs[BY_DAY][0] = icaltime_day_of_week(impl->dtstart);
+
+       } else {
+          /* If there is BY_DAY data, then we need to move the initial
+             time to the start of the BY_DAY data. That is if the
+             start time is on a Wednesday, and the rule has
+             BYDAY=MO,WE,FR, move the initial time back to
+             monday. Otherwise, jumping to the next week ( jumping 7
+             days ahead ) will skip over some occurrences in the
+             second week. */
+          
+          /* This is probably a HACK. There should be some more
+             general way to solve this problem */
+
+          short dow = impl->by_ptrs[BY_DAY][0]-icaltime_day_of_week(impl->last);
+
+          if(dow < 0) {
+              /* initial time is after first day of BY_DAY data */
+
+              impl->last.day += dow;
+              impl->last = icaltime_normalize(impl->last);
+          }
+      }
+      
+
+    }
+
+    /* For YEARLY rule, begin by setting up the year days array */
+
+    if(impl->rule.freq == ICAL_YEARLY_RECURRENCE){
+        expand_year_days(impl,impl->last.year);
+    } 
+
+
+    /* If this is a monthly interval with by day data, then we need to
+       set the last value to the appropriate day of the month */
+
+    if(impl->rule.freq == ICAL_MONTHLY_RECURRENCE &&
+       has_by_data(impl,BY_DAY)) {
+
+        short dow = icalrecurrencetype_day_day_of_week(
+            impl->by_ptrs[BY_DAY][impl->by_indices[BY_DAY]]);  
+        short pos =  icalrecurrencetype_day_position(
+            impl->by_ptrs[BY_DAY][impl->by_indices[BY_DAY]]);  
+        
+        short poscount = 0;
+        days_in_month = 
+            icaltime_days_in_month(impl->last.month, impl->last.year); 
+        
+        if(pos >= 0){
+            /* Count up from the first day pf the month to find the
+               pos'th weekday of dow ( like the second monday. ) */
+
+            for(impl->last.day = 1;
+                impl->last.day <= days_in_month;
+                impl->last.day++){
+                
+                if(icaltime_day_of_week(impl->last) == dow){
+                    if(++poscount == pos || pos == 0){
+                        break;
+                    }
+                }
+            }
+        } else {
+            /* Count down from the last day pf the month to find the
+               pos'th weekday of dow ( like the second to last monday. ) */
+            pos = -pos;
+            for(impl->last.day = days_in_month;
+                impl->last.day != 0;
+                impl->last.day--){
+                
+                if(icaltime_day_of_week(impl->last) == dow){
+                    if(++poscount == pos ){
+                        break;
+                    }
+                }
+            }
+        }
+
+
+        if(impl->last.day > days_in_month || impl->last.day == 0){
+            icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+            return 0;
+        }
+        
+    }
+
+
+
+    return impl;
+}
+
+
+void icalrecur_iterator_free(icalrecur_iterator* i)
+{
+    
+    struct icalrecur_iterator_impl* impl = 
+        (struct icalrecur_iterator_impl*)i;
+
+    icalerror_check_arg_rv((impl!=0),"impl");
+
+    free(impl);
+
+}
+
+
+void increment_year(struct icalrecur_iterator_impl* impl, int inc)
+{
+    impl->last.year+=inc;
+}
+
+/* Increment month is different that the other incement_* routines --
+   it figures out the interval for itself, and uses BYMONTH data if
+   available. */
+void increment_month(struct icalrecur_iterator_impl* impl)
+{
+    int years;
+
+     if(has_by_data(impl,BY_MONTH) ){
+         /* Ignore the frequency and use the byrule data */
+         
+         impl->by_indices[BY_MONTH]++;
+         
+         if (impl->by_ptrs[BY_MONTH][impl->by_indices[BY_MONTH]]
+             ==ICAL_RECURRENCE_ARRAY_MAX){
+             impl->by_indices[BY_MONTH] = 0;
+
+             increment_year(impl,1);
+             
+         }
+         
+         impl->last.month = 
+             impl->by_ptrs[BY_MONTH][impl->by_indices[BY_MONTH]];
+
+     } else {
+         
+         int inc;
+
+         if(impl->rule.freq == ICAL_MONTHLY_RECURRENCE){
+            inc =  impl->rule.interval;
+         } else {
+             inc = 1;
+         }
+
+         impl->last.month+=inc;
+         
+         /* Months are offset by one */
+         impl->last.month--;
+         
+         years = impl->last.month / 12;
+         
+         impl->last.month = impl->last.month % 12;
+         
+         impl->last.month++;
+         
+         if (years != 0){
+             increment_year(impl,years);
+         }
+     }
+}
+
+void increment_monthday(struct icalrecur_iterator_impl* impl, int inc)
+{
+    int i;
+
+    for(i=0; i<inc; i++){
+        
+        short days_in_month = 
+            icaltime_days_in_month(impl->last.month,impl->last.year);
+
+        impl->last.day++;
+        
+        if (impl->last.day > days_in_month){
+            impl->last.day = impl->last.day-days_in_month;
+            increment_month(impl);
+        }
+    }
+}
+
+
+void increment_hour(struct icalrecur_iterator_impl* impl, int inc)
+{
+    short days;
+
+    impl->last.hour+=inc;
+
+    days = impl->last.hour / 24;
+    impl->last.hour = impl->last.hour % 24;
+
+    if (impl->days != 0){
+        increment_monthday(impl,days);
+    }
+}
+
+void increment_minute(struct icalrecur_iterator_impl* impl, int inc)
+{
+    short hours;
+
+    impl->last.minute+=inc;
+
+    hours = impl->last.minute / 60;
+     impl->last.minute =  impl->last.minute % 60;
+
+     if (hours != 0){
+        increment_hour(impl,hours);
+    }
+
+}
+
+void increment_second(struct icalrecur_iterator_impl* impl, int inc)
+{
+    short minutes;
+
+    impl->last.second+=inc;
+    
+    minutes = impl->last.second / 60;
+    impl->last.second = impl->last.second % 60;
+    
+    if (minutes != 0)
+    {
+        increment_minute(impl, minutes);
+    }                 
+}
+
+#if 0
+#include "ical.h"
+void test_increment()
+{
+    struct icalrecur_iterator_impl impl;
+
+    impl.last =  icaltime_from_string("20000101T000000Z");
+
+    printf("Orig: %s\n",icaltime_as_ctime(impl.last));
+    
+    increment_second(&impl,5);
+    printf("+ 5 sec    : %s\n",icaltime_as_ctime(impl.last));
+
+    increment_second(&impl,355);
+    printf("+ 355 sec  : %s\n",icaltime_as_ctime(impl.last));
+
+    increment_minute(&impl,5);
+    printf("+ 5 min    : %s\n",icaltime_as_ctime(impl.last));
+
+    increment_minute(&impl,360);
+    printf("+ 360 min  : %s\n",icaltime_as_ctime(impl.last));
+    increment_hour(&impl,5);
+    printf("+ 5 hours  : %s\n",icaltime_as_ctime(impl.last));
+    increment_hour(&impl,43);
+    printf("+ 43 hours : %s\n",icaltime_as_ctime(impl.last));
+    increment_monthday(&impl,3);
+    printf("+ 3 days   : %s\n",icaltime_as_ctime(impl.last));
+    increment_monthday(&impl,600);
+    printf("+ 600 days  : %s\n",icaltime_as_ctime(impl.last));
+        
+}
+
+#endif 
+
+short next_second(struct icalrecur_iterator_impl* impl)
+{
+
+  short has_by_data = (impl->by_ptrs[BY_SECOND][0]!=ICAL_RECURRENCE_ARRAY_MAX);
+  short this_frequency = (impl->rule.freq == ICAL_SECONDLY_RECURRENCE);
+
+  short end_of_data = 0;
+
+  assert(has_by_data || this_frequency);
+
+  if(  has_by_data ){
+      /* Ignore the frequency and use the byrule data */
+
+      impl->by_indices[BY_SECOND]++;
+
+      if (impl->by_ptrs[BY_SECOND][impl->by_indices[BY_SECOND]]
+          ==ICAL_RECURRENCE_ARRAY_MAX){
+          impl->by_indices[BY_SECOND] = 0;
+
+          end_of_data = 1;
+      }
+
+
+      impl->last.second = 
+          impl->by_ptrs[BY_SECOND][impl->by_indices[BY_SECOND]];
+      
+      
+  } else if( !has_by_data &&  this_frequency ){
+      /* Compute the next value from the last time and the frequency interval*/
+      increment_second(impl, impl->rule.interval);
+
+  }
+
+  /* If we have gone through all of the seconds on the BY list, then we
+     need to move to the next minute */
+
+  if(has_by_data && end_of_data && this_frequency ){
+      increment_minute(impl,1);
+  }
+
+  return end_of_data;
+
+}
+
+int next_minute(struct icalrecur_iterator_impl* impl)
+{
+
+  short has_by_data = (impl->by_ptrs[BY_MINUTE][0]!=ICAL_RECURRENCE_ARRAY_MAX);
+  short this_frequency = (impl->rule.freq == ICAL_MINUTELY_RECURRENCE);
+
+  short end_of_data = 0;
+
+  assert(has_by_data || this_frequency);
+
+
+  if (next_second(impl) == 0){
+      return 0;
+  }
+
+  if(  has_by_data ){
+      /* Ignore the frequency and use the byrule data */
+
+      impl->by_indices[BY_MINUTE]++;
+      
+      if (impl->by_ptrs[BY_MINUTE][impl->by_indices[BY_MINUTE]]
+          ==ICAL_RECURRENCE_ARRAY_MAX){
+
+          impl->by_indices[BY_MINUTE] = 0;
+          
+          end_of_data = 1;
+      }
+
+      impl->last.minute = 
+          impl->by_ptrs[BY_MINUTE][impl->by_indices[BY_MINUTE]];
+
+  } else if( !has_by_data &&  this_frequency ){
+      /* Compute the next value from the last time and the frequency interval*/
+      increment_minute(impl,impl->rule.interval);
+  } 
+
+/* If we have gone through all of the minutes on the BY list, then we
+     need to move to the next hour */
+
+  if(has_by_data && end_of_data && this_frequency ){
+      increment_hour(impl,1);
+  }
+
+  return end_of_data;
+}
+
+int next_hour(struct icalrecur_iterator_impl* impl)
+{
+
+  short has_by_data = (impl->by_ptrs[BY_HOUR][0]!=ICAL_RECURRENCE_ARRAY_MAX);
+  short this_frequency = (impl->rule.freq == ICAL_HOURLY_RECURRENCE);
+
+  short end_of_data = 0;
+
+  assert(has_by_data || this_frequency);
+
+  if (next_minute(impl) == 0){
+      return 0;
+  }
+
+  if(  has_by_data ){
+      /* Ignore the frequency and use the byrule data */
+
+      impl->by_indices[BY_HOUR]++;
+      
+      if (impl->by_ptrs[BY_HOUR][impl->by_indices[BY_HOUR]]
+          ==ICAL_RECURRENCE_ARRAY_MAX){
+          impl->by_indices[BY_HOUR] = 0;
+          
+          end_of_data = 1;
+      }
+
+      impl->last.hour = 
+          impl->by_ptrs[BY_HOUR][impl->by_indices[BY_HOUR]];
+
+  } else if( !has_by_data &&  this_frequency ){
+      /* Compute the next value from the last time and the frequency interval*/
+      increment_hour(impl,impl->rule.interval);
+
+  }
+
+  /* If we have gone through all of the hours on the BY list, then we
+     need to move to the next day */
+
+  if(has_by_data && end_of_data && this_frequency ){
+      increment_monthday(impl,1);
+  }
+
+  return end_of_data;
+
+}
+
+int next_day(struct icalrecur_iterator_impl* impl)
+{
+
+  short has_by_data = (impl->by_ptrs[BY_DAY][0]!=ICAL_RECURRENCE_ARRAY_MAX);
+  short this_frequency = (impl->rule.freq == ICAL_DAILY_RECURRENCE);
+
+  assert(has_by_data || this_frequency);
+
+  if (next_hour(impl) == 0){
+      return 0;
+  }
+
+  /* Always increment through the interval, since this routine is not
+     called by any other next_* routine, and the days that are
+     excluded will be taken care of by restriction filtering */
+
+  if(this_frequency){
+      increment_monthday(impl,impl->rule.interval);
+  } else {
+      increment_monthday(impl,1);
+  }
+
+
+  return 0;
+
+}
+
+
+int next_yearday(struct icalrecur_iterator_impl* impl)
+{
+
+  short has_by_data = (impl->by_ptrs[BY_YEAR_DAY][0]!=ICAL_RECURRENCE_ARRAY_MAX);
+
+  short end_of_data = 0;
+
+  assert(has_by_data );
+
+  if (next_hour(impl) == 0){
+      return 0;
+  }
+
+  impl->by_indices[BY_YEAR_DAY]++;
+  
+  if (impl->by_ptrs[BY_YEAR_DAY][impl->by_indices[BY_YEAR_DAY]]
+      ==ICAL_RECURRENCE_ARRAY_MAX){
+      impl->by_indices[BY_YEAR_DAY] = 0;
+      
+      end_of_data = 1;
+  }
+  
+  impl->last.day = 
+      impl->by_ptrs[BY_YEAR_DAY][impl->by_indices[BY_YEAR_DAY]];
+  
+  if(has_by_data && end_of_data){
+      increment_year(impl,1);
+  }
+
+  return end_of_data;
+
+}
+
+/* This routine is only called by next_week. It is certain that BY_DAY
+has data */
+
+int next_weekday_by_week(struct icalrecur_iterator_impl* impl)
+{
+
+  short end_of_data = 0;
+  short start_of_week, dow;
+  struct icaltimetype next;
+
+  if (next_hour(impl) == 0){
+      return 0;
+  }
+
+  assert( impl->by_ptrs[BY_DAY][0]!=ICAL_RECURRENCE_ARRAY_MAX);
+
+  while(1) {
+
+      impl->by_indices[BY_DAY]++; /* Look at next elem in BYDAY array */
+      
+      /* Are we at the end of the BYDAY array? */
+      if (impl->by_ptrs[BY_DAY][impl->by_indices[BY_DAY]]
+          ==ICAL_RECURRENCE_ARRAY_MAX){
+          
+          impl->by_indices[BY_DAY] = 0; /* Reset to 0 */      
+          end_of_data = 1; /* Signal that we're at the end */
+      }
+      
+      /* Add the day of week offset to to the start of this week, and use
+         that to get the next day */
+      dow = impl->by_ptrs[BY_DAY][impl->by_indices[BY_DAY]];  
+      start_of_week = icaltime_start_doy_of_week(impl->last);
+      
+      dow--; /*Sun is 1, not 0 */
+
+      if(dow+start_of_week <1 && !end_of_data){
+          /* The selected date is in the previous year. */
+          continue;
+      }
+
+      next = icaltime_from_day_of_year(start_of_week + dow,impl->last.year);
+
+      impl->last.day =  next.day;
+      impl->last.month =  next.month;
+      impl->last.year =  next.year;
+  
+      return end_of_data;
+  }
+
+}
+
+int nth_weekday(short dow, short pos, struct icaltimetype t){
+
+    short days_in_month = icaltime_days_in_month(t.month,t.year);
+    short end_dow, start_dow;
+    short wd;
+
+    if(pos >= 0){
+        t.day = 1;
+        start_dow = icaltime_day_of_week(t);        
+        
+        if (pos != 0) {
+            pos--;
+        }
+         
+        /* find month day of first occurrence of dow -- such as the
+           month day of the first monday */
+
+        wd = dow-start_dow+1;
+
+        if (wd <= 0){
+            wd = wd + 7;
+        }
+
+        wd = wd + pos * 7;
+        
+    } else {
+        t.day = days_in_month;
+        end_dow = icaltime_day_of_week(t);
+
+        pos++;
+
+        /* find month day of last occurrence of dow -- such as the
+           month day of the last monday */
+
+        wd = (end_dow - dow);
+
+        if (wd < 0){
+            wd = wd+ 7;
+        }
+
+        wd = days_in_month - wd;
+
+        wd = wd + pos * 7;
+    }
+        
+    return wd;
+}
+
+
+int next_month(struct icalrecur_iterator_impl* impl)
+{
+    int data_valid = 1;
+    
+    short this_frequency = (impl->rule.freq == ICAL_MONTHLY_RECURRENCE);
+    
+    assert( has_by_data(impl,BY_MONTH) || this_frequency);
+  
+    /* Iterate through the occurrences within a day. If we don't get to
+       the end of the intra-day data, don't bother going to the next
+       month */
+    
+    if (next_hour(impl) == 0){
+        return data_valid; /* Signal that the data is valid */
+    }
+    
+    
+    /* Now iterate through the occurrences within a month -- by days,
+       weeks or weekdays.  */
+    
+    if(has_by_data(impl,BY_DAY) && has_by_data(impl,BY_MONTH_DAY)){
+      /* Cases like: FREQ=MONTHLY;INTERVAL=1;BYDAY=FR;BYMONTHDAY=13 */
+      short day, idx,j;
+      short days_in_month = icaltime_days_in_month(impl->last.month,
+                                                   impl->last.year);
+      /* Iterate through the remaining days in the month and check if
+         each day is listed in the BY_DAY array and in the BY_MONTHDAY
+         array. This seems very inneficient, but I think it is the
+         simplest way to account for both BYDAY=1FR (First friday in
+         month) and BYDAY=FR ( every friday in month ) */
+
+      for(day = impl->last.day+1; day <= days_in_month; day++){
+          for(idx = 0; BYDAYPTR[idx] != ICAL_RECURRENCE_ARRAY_MAX; idx++){
+              for(j = 0; BYMDPTR[j]!=ICAL_RECURRENCE_ARRAY_MAX; j++){
+                  short dow = 
+                      icalrecurrencetype_day_day_of_week(BYDAYPTR[idx]);  
+                  short pos =  icalrecurrencetype_day_position(BYDAYPTR[idx]);  
+                  short mday = BYMDPTR[j];
+                  short this_dow;
+                  
+                  impl->last.day = day;
+                  this_dow = icaltime_day_of_week(impl->last);
+                  
+                  if( (pos == 0 &&  dow == this_dow && mday == day) || 
+                      (nth_weekday(dow,pos,impl->last) == day && mday==day)){
+                      goto MDEND;
+                  }
+              }
+          }
+      }
+
+  MDEND:
+
+      if ( day > days_in_month){
+          impl->last.day = 1;
+          increment_month(impl);
+          data_valid = 0; /* signal that impl->last is invalid */
+      }
+
+      
+  }  else if(has_by_data(impl,BY_DAY)){
+      /* Cases like: FREQ=MONTHLY;INTERVAL=1;BYDAY=FR */
+      /* For this case, the weekdays are relative to the
+         month. BYDAY=FR -> First Friday in month, etc. */
+
+      short day, idx;
+      short days_in_month = icaltime_days_in_month(impl->last.month,
+                                                   impl->last.year);
+
+      assert( BYDAYPTR[0]!=ICAL_RECURRENCE_ARRAY_MAX);
+
+      /* Iterate through the remaining days in the month and check if
+         each day is listed in the BY_DAY array. This seems very
+         inneficient, but I think it is the simplest way to account
+         for both BYDAY=1FR (First friday in month) and BYDAY=FR (
+         every friday in month ) */
+
+      for(day = impl->last.day+1; day <= days_in_month; day++){
+          for(idx = 0; BYDAYPTR[idx] != ICAL_RECURRENCE_ARRAY_MAX; idx++){
+              short dow = icalrecurrencetype_day_day_of_week(BYDAYPTR[idx]);  
+              short pos =  icalrecurrencetype_day_position(BYDAYPTR[idx]);  
+              short this_dow;
+              
+              impl->last.day = day;
+              this_dow = icaltime_day_of_week(impl->last);
+              
+              if( (pos == 0 &&  dow == this_dow ) || 
+                  (nth_weekday(dow,pos,impl->last) == day)){
+                  goto DEND;
+              }
+          }
+      }
+
+  DEND:
+
+      if ( day > days_in_month){
+          impl->last.day = 1;
+          increment_month(impl);
+          data_valid = 0; /* signal that impl->last is invalid */
+      }
+
+  } else if (has_by_data(impl,BY_MONTH_DAY)) {
+      /* Cases like: FREQ=MONTHLY;COUNT=10;BYMONTHDAY=-3  */
+      short day;
+
+      assert( BYMDPTR[0]!=ICAL_RECURRENCE_ARRAY_MAX);
+
+      BYMDIDX++;
+          
+      /* Are we at the end of the BYDAY array? */
+      if (BYMDPTR[BYMDIDX] ==ICAL_RECURRENCE_ARRAY_MAX){
+          
+          BYMDIDX = 0; /* Reset to 0 */      
+          increment_month(impl);          
+      }
+      
+      day = BYMDPTR[BYMDIDX];
+      
+      if (day < 0) {
+          day = icaltime_days_in_month(impl->last.month,impl->last.year)+
+              day + 1;
+      }
+      
+      impl->last.day = day;
+
+  } else {
+      increment_month(impl);
+  }
+
+  return data_valid; /* Signal that the data is valid */
+
+}
+
+
+int next_week(struct icalrecur_iterator_impl* impl)
+{
+  short has_by_data = (impl->by_ptrs[BY_WEEK_NO][0]!=ICAL_RECURRENCE_ARRAY_MAX);
+  short this_frequency = (impl->rule.freq == ICAL_WEEKLY_RECURRENCE);
+  short end_of_data = 0;
+
+  /* Increment to the next week day */
+  if (next_weekday_by_week(impl) == 0){
+      return 0; /* Have not reached end of week yet */
+  }
+
+  /* If we get here, we have incremented through the entire week, and
+     can increment to the next week */
+
+
+  if( has_by_data){
+    /* Use the Week Number byrule data */
+      int week_no;
+      struct icaltimetype t;
+      
+      impl->by_indices[BY_WEEK_NO]++;
+      
+      if (impl->by_ptrs[BY_WEEK_NO][impl->by_indices[BY_WEEK_NO]]
+          ==ICAL_RECURRENCE_ARRAY_MAX){
+          impl->by_indices[BY_WEEK_NO] = 0;
+          
+          end_of_data = 1;
+      }
+      
+      t = impl->last;
+      t.month=1; /* HACK, should be setting to the date of the first week of year*/
+      t.day=1;
+      
+      week_no = impl->by_ptrs[BY_WEEK_NO][impl->by_indices[BY_WEEK_NO]];
+      
+      impl->last.day += week_no*7;
+
+      impl->last = icaltime_normalize(impl->last);
+      
+  } else if( !has_by_data &&  this_frequency ){
+      /* If there is no BY_WEEK_NO data, just jump forward 7 days. */
+      increment_monthday(impl,7*impl->rule.interval);
+  }
+
+
+  if(has_by_data && end_of_data && this_frequency ){
+      increment_year(impl,1);
+  }
+
+  return end_of_data;
+  
+}
+
+/* Expand the BYDAY rule part and return a pointer to a newly allocated list of days. */
+pvl_list expand_by_day(struct icalrecur_iterator_impl* impl,short year)
+{
+    /* Try to calculate each of the occurrences. */
+    int i;
+    pvl_list days_list = pvl_newlist();
+
+    short start_dow, end_dow, end_year_day, start_doy;
+    struct icaltimetype tmp = impl->last;
+    
+    tmp.year= year;
+    tmp.month = 1;
+    tmp.day = 1;
+    tmp.is_date = 1;
+    
+    start_dow = icaltime_day_of_week(tmp);
+    start_doy =  icaltime_start_doy_of_week(tmp);
+    
+    /* Get the last day of the year*/
+    tmp.year++;
+    tmp = icaltime_normalize(tmp);
+    tmp.day--;
+    tmp = icaltime_normalize(tmp);
+    
+    end_dow =  icaltime_day_of_week(tmp);
+    end_year_day = icaltime_day_of_year(tmp);
+    
+    for(i = 0; BYDAYPTR[i] != ICAL_RECURRENCE_ARRAY_MAX; i++){
+        short dow = 
+            icalrecurrencetype_day_day_of_week(BYDAYPTR[i]);  
+        short pos =  icalrecurrencetype_day_position(BYDAYPTR[i]);
+        
+        if(pos == 0){
+            /* The day was specified without a position -- it is just
+               a bare day of the week ( BYDAY=SU) so add all of the
+               days of the year with this day-of-week*/
+            int week;
+            for(week = 0; week < 52 ; week ++){
+                short doy = start_doy + (week * 7) + dow-1;
+                
+                if(doy > end_year_day){
+                    break;
+                } else {
+                    pvl_push(days_list,(void*)(int)doy);
+                }
+            }         
+        } else if ( pos > 0) {
+            int first;
+            /* First occurrence of dow in year */
+            if( dow >= start_dow) {
+                first = dow - start_dow + 1;
+            } else {
+                first = dow - start_dow + 8;
+            }
+
+            /* THen just multiple the position times 7 to get the pos'th day in the year */
+            pvl_push(days_list,(void*)(first+  (pos-1) * 7));
+            
+        } else { /* pos < 0 */ 
+            int last;
+            pos = -pos;
+
+            /* last occurrence of dow in year */
+            if( dow <= end_dow) {
+                last = end_year_day - end_dow + dow;
+            } else {
+                last = end_year_day - end_dow + dow - 7;
+            }
+
+            pvl_push(days_list,(void*)(last - (pos-1) * 7));
+        }
+    }
+    return days_list;
+}
+
+
+/* For INTERVAL=YEARLY, set up the days[] array in the iterator to
+   list all of the days of the current year that are specified in this
+   rule. */
+
+int expand_year_days(struct icalrecur_iterator_impl* impl,short year)
+{
+    int j,k;
+    int days_index=0;
+    struct icaltimetype t;
+    int flags;
+
+    t = icaltime_null_time();
+
+#define HBD(x) has_by_data(impl,x)
+
+    t.is_date = 1; /* Needed to make day_of_year routines work property */
+
+    memset(&t,0,sizeof(t));
+    memset(impl->days,ICAL_RECURRENCE_ARRAY_MAX_BYTE,sizeof(impl->days));
+    
+    flags = (HBD(BY_DAY) ? 1<<BY_DAY : 0) + 
+        (HBD(BY_WEEK_NO) ? 1<<BY_WEEK_NO : 0) + 
+        (HBD(BY_MONTH_DAY) ? 1<<BY_MONTH_DAY : 0) + 
+        (HBD(BY_MONTH) ? 1<<BY_MONTH : 0) + 
+        (HBD(BY_YEAR_DAY) ? 1<<BY_YEAR_DAY : 0);
+
+    
+    switch(flags) {
+        
+    case 0: {
+        /* FREQ=YEARLY; */
+        
+        break;
+    }
+    case 1<<BY_MONTH: {
+        /* FREQ=YEARLY; BYMONTH=3,11*/
+        
+        for(j=0;impl->by_ptrs[BY_MONTH][j]!=ICAL_RECURRENCE_ARRAY_MAX;j++){
+            struct icaltimetype t;
+                    short month = impl->by_ptrs[BY_MONTH][j];    
+            short doy;
+
+            t = impl->dtstart;
+            t.year = year;
+            t.month = month;
+            t.is_date = 1;
+
+            doy = icaltime_day_of_year(t);
+            
+            impl->days[days_index++] = doy;
+
+        }
+        break;
+    }
+
+    case 1<<BY_MONTH_DAY:  {
+        /* FREQ=YEARLY; BYMONTHDAY=1,15*/
+        for(k=0;impl->by_ptrs[BY_MONTH_DAY][k]!=ICAL_RECURRENCE_ARRAY_MAX;k++)
+            {
+                short month_day = impl->by_ptrs[BY_MONTH_DAY][k];
+                short doy;
+
+                t = impl->dtstart;
+                t.day = month_day;
+                t.year = year;
+                t.is_date = 1;
+
+                doy = icaltime_day_of_year(t);
+
+                impl->days[days_index++] = doy;
+
+            }
+        break;
+    }
+
+    case (1<<BY_MONTH_DAY) + (1<<BY_MONTH): {
+        /* FREQ=YEARLY; BYMONTHDAY=1,15; BYMONTH=10 */
+
+        for(j=0;impl->by_ptrs[BY_MONTH][j]!=ICAL_RECURRENCE_ARRAY_MAX;j++){
+            for(k=0;impl->by_ptrs[BY_MONTH_DAY][k]!=ICAL_RECURRENCE_ARRAY_MAX;k++)
+           {
+                short month = impl->by_ptrs[BY_MONTH][j];
+                short month_day = impl->by_ptrs[BY_MONTH_DAY][k];
+                short doy;
+
+                t.day = month_day;
+                t.month = month;
+                t.year = year;
+                t.is_date = 1;
+
+                doy = icaltime_day_of_year(t);
+
+                impl->days[days_index++] = doy;
+
+            }
+        }
+
+        break;
+    }
+
+    case 1<<BY_WEEK_NO: {
+        /* FREQ=YEARLY; BYWEEKNO=20,50 */
+
+        struct icaltimetype t;
+        short dow;
+
+        t.day = impl->dtstart.day;
+        t.month = impl->dtstart.month;
+        t.year = year;
+        t.is_date = 1;
+
+        dow = icaltime_day_of_week(t);
+        /* HACK Not finished */ 
+
+        icalerror_set_errno(ICAL_UNIMPLEMENTED_ERROR);
+        
+        break;
+    }
+
+    case (1<<BY_WEEK_NO) + (1<<BY_MONTH_DAY): {
+        /*FREQ=YEARLY; WEEKNO=20,50; BYMONTH= 6,11 */
+        icalerror_set_errno(ICAL_UNIMPLEMENTED_ERROR);
+        break;
+    }
+
+    case 1<<BY_DAY: {
+        /*FREQ=YEARLY; BYDAY=TH,20MO,-10FR*/
+        int days_index = 0;
+        pvl_elem i;
+        pvl_list days = expand_by_day(impl,year);
+
+
+        for(i=pvl_head(days);i!=0;i=pvl_next(i)){
+            short day = (short)(int)pvl_data(i);
+            impl->days[days_index++] = day;
+        }
+
+        pvl_free(days);
+
+        break;
+    }
+
+    case (1<<BY_DAY)+(1<<BY_MONTH): {
+        /*FREQ=YEARLY; BYDAY=TH,20MO,-10FR; BYMONTH = 12*/
+
+        int days_index = 0;
+        pvl_elem itr;
+        pvl_list days = expand_by_day(impl,year);
+
+        for(itr=pvl_head(days);itr!=0;itr=pvl_next(itr)){
+            short doy = (short)(int)pvl_data(itr);
+            struct icaltimetype tt; 
+            short j;
+            
+            tt = icaltime_from_day_of_year(doy,year);
+              
+            for(j=0;
+                impl->by_ptrs[BY_MONTH][j]!=ICAL_RECURRENCE_ARRAY_MAX;
+                j++){
+                short month = impl->by_ptrs[BY_MONTH][j];
+
+                if(tt.month == month){
+                    impl->days[days_index++] = doy;
+                }
+            }
+
+        }
+
+        pvl_free(days);
+
+        break;
+    }
+
+    case (1<<BY_DAY) + (1<<BY_MONTH_DAY) : {
+        /*FREQ=YEARLY; BYDAY=TH,20MO,-10FR; BYMONTHDAY=1,15*/
+
+        int days_index = 0;
+        pvl_elem itr;
+        pvl_list days = expand_by_day(impl,year);
+
+        for(itr=pvl_head(days);itr!=0;itr=pvl_next(itr)){
+            short day = (short)(int)pvl_data(itr);
+            struct icaltimetype tt; 
+            short j;
+            
+            tt = icaltime_from_day_of_year(day,year);
+            
+            for(j = 0; BYMDPTR[j]!=ICAL_RECURRENCE_ARRAY_MAX; j++){
+                    short mday = BYMDPTR[j];
+                    
+                    if(tt.day == mday){
+                        impl->days[days_index++] = day;
+                    }
+            }
+            
+        }
+
+        pvl_free(days);
+       
+        break;
+    }
+
+    case (1<<BY_DAY) + (1<<BY_MONTH_DAY) + (1<<BY_MONTH): {
+        /*FREQ=YEARLY; BYDAY=TH,20MO,-10FR; BYMONTHDAY=10; MYMONTH=6,11*/
+
+        int days_index = 0;
+        pvl_elem itr;
+        pvl_list days = expand_by_day(impl,year);
+
+        for(itr=pvl_head(days);itr!=0;itr=pvl_next(itr)){
+            short day = (short)(int)pvl_data(itr);
+            struct icaltimetype tt; 
+            short i,j;
+            
+            tt = icaltime_from_day_of_year(day,year);
+            
+            for(i = 0; BYMONPTR[i] != ICAL_RECURRENCE_ARRAY_MAX; i++){
+                for(j = 0; BYMDPTR[j]!=ICAL_RECURRENCE_ARRAY_MAX; j++){
+                    short mday = BYMDPTR[j];
+                    short month = BYMONPTR[i];
+                    
+                    if(tt.month == month  && tt.day == mday){
+                        impl->days[days_index++] = day;
+                    }
+                }
+            }
+
+        }
+
+        pvl_free(days);
+
+       break;
+
+    }
+
+    case (1<<BY_DAY) + (1<<BY_WEEK_NO) : {
+        /*FREQ=YEARLY; BYDAY=TH,20MO,-10FR;  WEEKNO=20,50*/
+       
+        int days_index = 0;
+        pvl_elem itr;
+        pvl_list days = expand_by_day(impl,year);
+
+        for(itr=pvl_head(days);itr!=0;itr=pvl_next(itr)){
+            short day = (short)(int)pvl_data(itr);
+            struct icaltimetype tt; 
+            short i;
+            
+            tt = icaltime_from_day_of_year(day,year);
+            
+            for(i = 0; BYWEEKPTR[i] != ICAL_RECURRENCE_ARRAY_MAX; i++){
+                    short weekno = BYWEEKPTR[i];
+                    
+                    if(weekno== icaltime_week_number(tt)){
+                        impl->days[days_index++] = day;
+                    }
+            }
+                    
+        }
+
+        pvl_free(days);
+        break;
+    }
+
+    case (1<<BY_DAY) + (1<<BY_WEEK_NO) + (1<<BY_MONTH_DAY): {
+        /*FREQ=YEARLY; BYDAY=TH,20MO,-10FR;  WEEKNO=20,50; BYMONTHDAY=1,15*/
+        icalerror_set_errno(ICAL_UNIMPLEMENTED_ERROR);
+        break;
+    }
+
+    case 1<<BY_YEAR_DAY: {
+        for(j=0;impl->by_ptrs[BY_YEAR_DAY][j]!=ICAL_RECURRENCE_ARRAY_MAX;j++){
+            short doy = impl->by_ptrs[BY_YEAR_DAY][j];
+            impl->days[days_index++] = doy;
+        }
+        break;
+    }
+
+    default: {
+        icalerror_set_errno(ICAL_UNIMPLEMENTED_ERROR);
+        break;
+    }
+
+    }
+
+    return 0;
+}                                  
+
+
+int next_year(struct icalrecur_iterator_impl* impl)
+{
+    struct icaltimetype next;
+
+    /* Next_year does it's own interatio in days, so the next level down is hours */
+    if (next_hour(impl) == 0){
+        return 1;
+    }
+
+    if (impl->days[++impl->days_index] == ICAL_RECURRENCE_ARRAY_MAX){
+        impl->days_index = 0;
+        increment_year(impl,impl->rule.interval);
+        expand_year_days(impl,impl->last.year);
+    }
+
+    if(impl->days[0] == ICAL_RECURRENCE_ARRAY_MAX) {
+        return 0;
+    }
+
+    next = icaltime_from_day_of_year(impl->days[impl->days_index],impl->last.year);
+    
+    impl->last.day =  next.day;
+    impl->last.month =  next.month;
+  
+    return 1;
+}
+
+int icalrecur_check_rulepart(struct icalrecur_iterator_impl* impl,
+                      short v, enum byrule byrule)
+{
+    int itr;
+
+    if(impl->by_ptrs[byrule][0]!=ICAL_RECURRENCE_ARRAY_MAX){
+        for(itr=0; impl->by_ptrs[byrule][itr]!=ICAL_RECURRENCE_ARRAY_MAX;itr++){
+            if(impl->by_ptrs[byrule][itr] == v){
+                return 1;
+            }
+        }
+    } 
+
+    return 0;
+}
+
+int check_contract_restriction(struct icalrecur_iterator_impl* impl,
+                      enum byrule byrule, short v)
+{
+    int pass = 0;
+    int itr;
+    icalrecurrencetype_frequency freq = impl->rule.freq;
+
+    if(impl->by_ptrs[byrule][0]!=ICAL_RECURRENCE_ARRAY_MAX &&
+        expand_map[freq].map[byrule] == CONTRACT){
+        for(itr=0; impl->by_ptrs[byrule][itr]!=ICAL_RECURRENCE_ARRAY_MAX;itr++){
+            if(impl->by_ptrs[byrule][itr] == v){
+                pass=1;
+                break;
+            }
+        }
+
+        return pass;
+    } else {
+        /* This is not a contracting byrule, or it has no data, so the
+           test passes*/
+        return 1;
+    }
+}
+
+
+int check_contracting_rules(struct icalrecur_iterator_impl* impl)
+{
+
+    int day_of_week=0;
+    int week_no=0;
+    int year_day=0;
+
+    if (
+        check_contract_restriction(impl,BY_SECOND,impl->last.second) &&
+        check_contract_restriction(impl,BY_MINUTE,impl->last.minute) &&
+        check_contract_restriction(impl,BY_HOUR,impl->last.hour) &&
+        check_contract_restriction(impl,BY_DAY,day_of_week) &&
+        check_contract_restriction(impl,BY_WEEK_NO,week_no) &&
+        check_contract_restriction(impl,BY_MONTH_DAY,impl->last.day) &&
+        check_contract_restriction(impl,BY_MONTH,impl->last.month) &&
+        check_contract_restriction(impl,BY_YEAR_DAY,year_day) )
+    {
+
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+struct icaltimetype icalrecur_iterator_next(icalrecur_iterator *itr)
+{
+    int valid = 1;
+    struct icalrecur_iterator_impl* impl = 
+        (struct icalrecur_iterator_impl*)itr;
+    
+    if( (impl->rule.count!=0 &&impl->occurrence_no >= impl->rule.count) ||
+       (!icaltime_is_null_time(impl->rule.until) && 
+        icaltime_compare(impl->last,impl->rule.until) > 0)) {
+        return icaltime_null_time();
+    }
+
+    if(impl->occurrence_no == 0 
+       &&  icaltime_compare(impl->last,impl->dtstart) >= 0){
+
+        impl->occurrence_no++;
+        return impl->last;
+    }
+
+    do {
+        valid = 1;
+        switch(impl->rule.freq){
+            
+            case ICAL_SECONDLY_RECURRENCE: {
+                next_second(impl);
+                break;
+            }
+            case ICAL_MINUTELY_RECURRENCE: {
+                next_minute(impl);
+                break;
+            }
+            case ICAL_HOURLY_RECURRENCE: {
+                next_hour(impl);
+                break;
+            }
+            case ICAL_DAILY_RECURRENCE: {
+                next_day(impl);
+                break;
+            }
+            case ICAL_WEEKLY_RECURRENCE: {
+                next_week(impl);
+                break;
+            }
+            case ICAL_MONTHLY_RECURRENCE: {
+                valid = next_month(impl);
+                break;
+            }
+            case ICAL_YEARLY_RECURRENCE:{
+                valid = next_year(impl);
+                break;
+            }
+            default:{
+                icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+                return icaltime_null_time();
+            }
+        }    
+        
+        if(impl->last.year >= 2038 ){
+            /* HACK */
+            return icaltime_null_time();
+        }
+        
+    } while(!check_contracting_rules(impl) 
+            || icaltime_compare(impl->last,impl->dtstart) <= 0
+            || valid == 0);
+    
+    
+/* Ignore null times and times that are after the until time */
+    if( !icaltime_is_null_time(impl->rule.until) && 
+        icaltime_compare(impl->last,impl->rule.until) > 0 ) {
+        return icaltime_null_time();
+    }
+
+    impl->occurrence_no++;
+
+    return impl->last;
+}
+
+
+/************************** Type Routines **********************/
+
+
+void icalrecurrencetype_clear(struct icalrecurrencetype *recur)
+{
+    memset(recur,ICAL_RECURRENCE_ARRAY_MAX_BYTE,
+           sizeof(struct icalrecurrencetype));
+
+    recur->week_start = ICAL_MONDAY_WEEKDAY;
+    recur->freq = ICAL_NO_RECURRENCE;
+    recur->interval = 1;
+    memset(&(recur->until),0,sizeof(struct icaltimetype));
+    recur->count = 0;
+}
+
+/* The 'day' element of icalrecurrencetype_weekday is encoded to allow
+reporesentation of both the day of the week ( Monday, Tueday), but
+also the Nth day of the week ( First tuesday of the month, last
+thursday of the year) These routines decode the day values. 
+
+The day's position in the period ( Nth-ness) and the numerical value
+of the day are encoded together as: pos*7 + dow
+
+A position of 0 means 'any' or 'every'
+
+ */
+
+enum icalrecurrencetype_weekday icalrecurrencetype_day_day_of_week(short day)
+{
+    return abs(day)%8;
+}
+
+short icalrecurrencetype_day_position(short day)
+{
+    short wd, pos;
+
+    wd = icalrecurrencetype_day_day_of_week(day);
+
+    pos = (abs(day)-wd)/8 * ((day<0)?-1:1);
+
+
+    return pos;
+}
+
+
+/****************** Enumeration Routines ******************/
+
+struct {icalrecurrencetype_weekday wd; const char * str; } 
+wd_map[] = {
+    {ICAL_SUNDAY_WEEKDAY,"SU"},
+    {ICAL_MONDAY_WEEKDAY,"MO"},
+    {ICAL_TUESDAY_WEEKDAY,"TU"},
+    {ICAL_WEDNESDAY_WEEKDAY,"WE"},
+    {ICAL_THURSDAY_WEEKDAY,"TH"},
+    {ICAL_FRIDAY_WEEKDAY,"FR"},
+    {ICAL_SATURDAY_WEEKDAY,"SA"},
+    {ICAL_NO_WEEKDAY,0}
+};
+
+const char* icalrecur_weekday_to_string(icalrecurrencetype_weekday kind)
+{
+    int i;
+
+    for (i=0; wd_map[i].wd  != ICAL_NO_WEEKDAY; i++) {
+        if ( wd_map[i].wd ==  kind) {
+            return wd_map[i].str;
+        }
+    }
+
+    return 0;
+}
+
+icalrecurrencetype_weekday icalrecur_string_to_weekday(const char* str)
+{
+    int i;
+
+    for (i=0; wd_map[i].wd  != ICAL_NO_WEEKDAY; i++) {
+        if ( strcmp(str,wd_map[i].str) == 0){
+            return wd_map[i].wd;
+        }
+    }
+
+    return ICAL_NO_WEEKDAY;
+}
+
+
+
+struct {
+        icalrecurrencetype_frequency kind;
+        const char* str;
+} freq_map[] = {
+    {ICAL_SECONDLY_RECURRENCE,"SECONDLY"},
+    {ICAL_MINUTELY_RECURRENCE,"MINUTELY"},
+    {ICAL_HOURLY_RECURRENCE,"HOURLY"},
+    {ICAL_DAILY_RECURRENCE,"DAILY"},
+    {ICAL_WEEKLY_RECURRENCE,"WEEKLY"},
+    {ICAL_MONTHLY_RECURRENCE,"MONTHLY"},
+    {ICAL_YEARLY_RECURRENCE,"YEARLY"},
+    {ICAL_NO_RECURRENCE,0}
+};
+
+const char* icalrecur_freq_to_string(icalrecurrencetype_frequency kind)
+{
+    int i;
+
+    for (i=0; freq_map[i].kind != ICAL_NO_RECURRENCE ; i++) {
+        if ( freq_map[i].kind == kind ) {
+            return freq_map[i].str;
+        }
+    }
+    return 0;
+}
+
+icalrecurrencetype_frequency icalrecur_string_to_freq(const char* str)
+{
+    int i;
+
+    for (i=0; freq_map[i].kind != ICAL_NO_RECURRENCE ; i++) {
+        if ( strcmp(str,freq_map[i].str) == 0){
+            return freq_map[i].kind;
+        }
+    }
+    return ICAL_NO_RECURRENCE;
+}
+
+/* Fill an array with the 'count' number of occurrences generated by
+   the rrule. Note that the times are returned in UTC, but the times
+   are calculated in local time. YOu will have to convert the results
+   back into local time before using them. */
+
+int icalrecur_expand_recurrence(char* rule, time_t start,
+                                int count, time_t* array)
+{
+    struct icalrecurrencetype recur;
+    icalrecur_iterator* ritr;
+    time_t tt;
+    struct icaltimetype icstart, next;
+    int i = 0;
+
+    memset(array, 0, count*sizeof(time_t));
+
+    icstart = icaltime_from_timet(start,0);
+
+    recur = icalrecurrencetype_from_string(rule);
+
+    for(ritr = icalrecur_iterator_new(recur,icstart),
+        next = icalrecur_iterator_next(ritr);
+        !icaltime_is_null_time(next) && i < count;
+        next = icalrecur_iterator_next(ritr)){
+
+        tt = icaltime_as_timet(next);
+        
+        if (tt >= start ){
+            array[i++] = tt;
+        }
+
+    }
+
+    icalrecur_iterator_free(ritr);
+
+    return 1;
+}
diff --git a/libical/src/libical/icalrecur.h b/libical/src/libical/icalrecur.h
new file mode 100644
index 0000000..5fcdc15
--- a/dev/null
+++ b/libical/src/libical/icalrecur.h
@@ -0,0 +1,189 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalrecur.h
+ CREATOR: eric 20 March 2000
+
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+How to use: 
+
+1) Get a rule and a start time from a component
+        icalproperty rrule;
+        struct icalrecurrencetype recur;
+        struct icaltimetype dtstart;
+
+        rrule = icalcomponent_get_first_property(comp,ICAL_RRULE_PROPERTY);
+        recur = icalproperty_get_rrule(rrule);
+        start = icalproperty_get_dtstart(dtstart);
+
+Or, just make them up: 
+        recur = icalrecurrencetype_from_string("FREQ=YEARLY;BYDAY=SU,WE");
+        dtstart = icaltime_from_string("19970101T123000")
+
+2) Create an iterator
+        icalrecur_iterator* ritr;
+        ritr = icalrecur_iterator_new(recur,start);
+
+3) Iterator over the occurrences
+        struct icaltimetype next;
+        while (next = icalrecur_iterator_next(ritr) 
+               && !icaltime_is_null_time(next){
+                Do something with next
+        }
+
+Note that that the time returned by icalrecur_iterator_next is in
+whatever timezone that dtstart is in.
+
+======================================================================*/
+
+#ifndef ICALRECUR_H
+#define ICALRECUR_H
+
+#include <time.h>
+#include "icaltime.h"
+
+/***********************************************************************
+ * Recurrance enumerations
+**********************************************************************/
+
+typedef enum icalrecurrencetype_frequency
+{
+    /* These enums are used to index an array, so don't change the
+       order or the integers */
+
+    ICAL_SECONDLY_RECURRENCE=0,
+    ICAL_MINUTELY_RECURRENCE=1,
+    ICAL_HOURLY_RECURRENCE=2,
+    ICAL_DAILY_RECURRENCE=3,
+    ICAL_WEEKLY_RECURRENCE=4,
+    ICAL_MONTHLY_RECURRENCE=5,
+    ICAL_YEARLY_RECURRENCE=6,
+    ICAL_NO_RECURRENCE=7
+
+} icalrecurrencetype_frequency;
+
+typedef enum icalrecurrencetype_weekday
+{
+    ICAL_NO_WEEKDAY,
+    ICAL_SUNDAY_WEEKDAY,
+    ICAL_MONDAY_WEEKDAY,
+    ICAL_TUESDAY_WEEKDAY,
+    ICAL_WEDNESDAY_WEEKDAY,
+    ICAL_THURSDAY_WEEKDAY,
+    ICAL_FRIDAY_WEEKDAY,
+    ICAL_SATURDAY_WEEKDAY
+} icalrecurrencetype_weekday;
+
+enum {
+    ICAL_RECURRENCE_ARRAY_MAX = 0x7f7f,
+    ICAL_RECURRENCE_ARRAY_MAX_BYTE = 0x7f
+};
+
+
+
+/********************** Recurrence type routines **************/
+
+/* See RFC 2445 Section 4.3.10, RECUR Value, for an explaination of
+   the values and fields in struct icalrecurrencetype */
+
+#define ICAL_BY_SECOND_SIZE 61
+#define ICAL_BY_MINUTE_SIZE 61
+#define ICAL_BY_HOUR_SIZE 25
+#define ICAL_BY_DAY_SIZE 364 /* 7 days * 52 weeks */
+#define ICAL_BY_MONTHDAY_SIZE 32
+#define ICAL_BY_YEARDAY_SIZE 367
+#define ICAL_BY_WEEKNO_SIZE 54
+#define ICAL_BY_MONTH_SIZE 13
+#define ICAL_BY_SETPOS_SIZE 367
+
+/* Main struct for holding digested recurrence rules */
+struct icalrecurrencetype 
+{
+        icalrecurrencetype_frequency freq;
+
+
+        /* until and count are mutually exclusive. */
+               struct icaltimetype until; 
+        int count;
+
+        short interval;
+        
+        icalrecurrencetype_weekday week_start;
+        
+        /* The BY* parameters can each take a list of values. Here I
+         * assume that the list of values will not be larger than the
+         * range of the value -- that is, the client will not name a
+         * value more than once. 
+         
+         * Each of the lists is terminated with the value
+         * ICAL_RECURRENCE_ARRAY_MAX unless the the list is full.
+         */
+
+        short by_second[ICAL_BY_SECOND_SIZE];
+        short by_minute[ICAL_BY_MINUTE_SIZE];
+        short by_hour[ICAL_BY_HOUR_SIZE];
+        short by_day[ICAL_BY_DAY_SIZE]; /* Encoded value, see below */
+        short by_month_day[ICAL_BY_MONTHDAY_SIZE];
+        short by_year_day[ ICAL_BY_YEARDAY_SIZE];
+        short by_week_no[ICAL_BY_WEEKNO_SIZE];
+        short by_month[ICAL_BY_MONTH_SIZE];
+        short by_set_pos[ICAL_BY_SETPOS_SIZE];
+};
+
+
+void icalrecurrencetype_clear(struct icalrecurrencetype *r);
+
+/* The 'day' element of the by_day array is encoded to allow
+representation of both the day of the week ( Monday, Tueday), but also
+the Nth day of the week ( First tuesday of the month, last thursday of
+the year) These routines decode the day values */
+
+/* 1 == Monday, etc. */
+enum icalrecurrencetype_weekday icalrecurrencetype_day_day_of_week(short day);
+
+/* 0 == any of day of week. 1 == first, 2 = second, -2 == second to last, etc */
+short icalrecurrencetype_day_position(short day);
+
+
+/***********************************************************************
+ * Recurrance rule parser
+**********************************************************************/
+
+/* Convert between strings ans recurrencetype structures. */
+struct icalrecurrencetype icalrecurrencetype_from_string(const char* str);
+char* icalrecurrencetype_as_string(struct icalrecurrencetype *recur);
+
+
+/********** recurrence iteration routines ********************/
+
+typedef void icalrecur_iterator;
+
+/* Create a new recurrence rule iterator */
+icalrecur_iterator* icalrecur_iterator_new(struct icalrecurrencetype rule, 
+                                           struct icaltimetype dtstart);
+
+/* Get the next occurrence from an iterator */
+struct icaltimetype icalrecur_iterator_next(icalrecur_iterator*);
+
+/* Free the iterator */
+void icalrecur_iterator_free(icalrecur_iterator*);
+
+/* Fills array up with at most 'count' time_t values, each
+   representing an occurrence time in seconds past the POSIX epoch */
+int icalrecur_expand_recurrence(char* rule, time_t start, 
+                                int count, time_t* array);
+
+
+#endif
diff --git a/libical/src/libical/icalrestriction.c b/libical/src/libical/icalrestriction.c
new file mode 100644
index 0000000..0f863c4
--- a/dev/null
+++ b/libical/src/libical/icalrestriction.c
@@ -0,0 +1,1781 @@
+/*  -*- Mode: C -*- */
+/*  ======================================================================
+  File: icalrestriction.c
+    
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+ ======================================================================*/
+/*#line 7 "icalrestriction.c.in"*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "icalrestriction.h"
+#include "icalenums.h"
+#include "icalerror.h"
+
+#include <assert.h>
+#include <stdio.h> /* For snprintf */   
+
+int snprintf(char *str, size_t n, char const *fmt, ...);
+
+#define TMP_BUF_SIZE 1024
+
+
+/* Define the structs for the restrictions. these data are filled out
+in machine generated code below */
+
+struct icalrestriction_property_record;
+
+typedef char* (*restriction_func)(struct icalrestriction_property_record* rec,icalcomponent* comp,icalproperty* prop);
+
+
+typedef struct icalrestriction_property_record {
+        icalproperty_method method;
+        icalcomponent_kind component;
+        icalproperty_kind property;
+        icalrestriction_kind restriction;
+        restriction_func function;
+} icalrestriction_property_record;
+
+
+typedef struct icalrestriction_component_record {
+        icalproperty_method method;
+        icalcomponent_kind component;
+        icalcomponent_kind subcomponent;
+        icalrestriction_kind restriction;
+        restriction_func function;
+} icalrestriction_component_record;
+
+icalrestriction_property_record*
+icalrestriction_get_property_restriction(icalproperty_method method,
+                                         icalcomponent_kind component,
+                                         icalproperty_kind property);
+icalrestriction_component_record*
+icalrestriction_get_component_restriction(icalproperty_method method,
+                                          icalcomponent_kind component,
+                                          icalcomponent_kind subcomponent);
+
+icalrestriction_component_record icalrestriction_component_records[];
+icalrestriction_property_record icalrestriction_property_records[]; 
+
+icalrestriction_property_record null_prop_record =   {ICAL_METHOD_NONE,ICAL_NO_COMPONENT,ICAL_NO_PROPERTY,ICAL_RESTRICTION_UNKNOWN,0};
+icalrestriction_component_record null_comp_record =   {ICAL_METHOD_NONE,ICAL_NO_COMPONENT,ICAL_NO_COMPONENT,ICAL_RESTRICTION_UNKNOWN,0};
+
+
+/* The each row gives the result of comparing a restriction against a
+   count. The columns in each row represent 0,1,2+. '-1' indicates
+   'invalid, 'don't care' or 'needs more analysis' So, for
+   ICAL_RESTRICTION_ONE, if there is 1 of a property with that
+   restriction, it passes, but if there are 0 or 2+, it fails. */
+
+char compare_map[ICAL_RESTRICTION_UNKNOWN+1][3] = {
+    { 1, 1, 1},/*ICAL_RESTRICTION_NONE*/
+    { 1, 0, 0},/*ICAL_RESTRICTION_ZERO*/
+    { 0, 1, 0},/*ICAL_RESTRICTION_ONE*/
+    { 1, 1, 1},/*ICAL_RESTRICTION_ZEROPLUS*/
+    { 0, 1, 1},/*ICAL_RESTRICTION_ONEPLUS*/
+    { 1, 1, 0},/*ICAL_RESTRICTION_ZEROORONE*/
+    { 1, 1, 0},/*ICAL_RESTRICTION_ONEEXCLUSIVE*/
+    { 1, 1, 0},/*ICAL_RESTRICTION_ONEMUTUAL*/
+    { 1, 1, 1} /*ICAL_RESTRICTION_UNKNOWN*/
+};
+
+char restr_string_map[ICAL_RESTRICTION_UNKNOWN+1][60] = {
+    "unknown number",/*ICAL_RESTRICTION_NONE*/
+    "0",/*ICAL_RESTRICTION_ZERO*/
+    "1",/*ICAL_RESTRICTION_ONE*/
+    "zero or more",/*ICAL_RESTRICTION_ZEROPLUS*/
+    "one or more" ,/*ICAL_RESTRICTION_ONEPLUS*/
+    "zero or one",/*ICAL_RESTRICTION_ZEROORONE*/
+    "zero or one, exclusive with another property",/*ICAL_RESTRICTION_ONEEXCLUSIVE*/
+    "zero or one, mutual with another property",/*ICAL_RESTRICTION_ONEMUTUAL*/
+    "unknown number" /*ICAL_RESTRICTION_UNKNOWN*/
+};
+
+
+int
+icalrestriction_compare(icalrestriction_kind restr, int count){
+
+    if ( restr < ICAL_RESTRICTION_NONE || restr > ICAL_RESTRICTION_UNKNOWN
+         || count < 0){
+        return -1;
+    }
+
+    if (count > 2) {
+        count = 2;
+    }
+
+    return compare_map[restr][count];
+
+}
+
+/* Special case routines */
+
+char* icalrestriction_may_be_draft_final_canceled(
+    icalrestriction_property_record *rec,
+    icalcomponent* comp, 
+    icalproperty* prop)
+{
+
+    icalproperty_status stat = icalproperty_get_status(prop);
+
+    if( !( stat == ICAL_STATUS_DRAFT ||
+           stat == ICAL_STATUS_FINAL ||
+           stat == ICAL_STATUS_CANCELLED )){
+
+        return "Failed iTIP restrictions for STATUS property. Value must be one of DRAFT, FINAL, or CANCELED";
+
+    }
+
+    return 0;    
+}
+
+char* icalrestriction_may_be_comp_need_process(
+    icalrestriction_property_record *rec,
+    icalcomponent* comp, 
+    icalproperty* prop)
+{
+    icalproperty_status stat = icalproperty_get_status(prop);
+
+    if( !( stat == ICAL_STATUS_COMPLETED ||
+           stat == ICAL_STATUS_NEEDSACTION ||
+           stat == ICAL_STATUS_INPROCESS )){
+
+        return "Failed iTIP restrictions for STATUS property. Value must be one of COMPLETED, NEEDS-ACTION or IN-PROCESS";
+
+    }
+
+    return 0;    
+}
+char* icalrestriction_may_be_tent_conf(icalrestriction_property_record *rec,
+                                       icalcomponent* comp, 
+                                       icalproperty* prop){
+    icalproperty_status stat = icalproperty_get_status(prop);
+
+    if( !( stat == ICAL_STATUS_TENTATIVE ||
+           stat == ICAL_STATUS_CONFIRMED )){
+
+        return "Failed iTIP restrictions for STATUS property. Value must be one of TENTATIVE or CONFIRMED";
+
+    }
+
+    return 0;    
+}
+char* icalrestriction_may_be_tent_conf_cancel(
+    icalrestriction_property_record *rec,
+    icalcomponent* comp, 
+    icalproperty* prop)
+{
+    icalproperty_status stat = icalproperty_get_status(prop);
+
+    if( !( stat == ICAL_STATUS_TENTATIVE ||
+           stat == ICAL_STATUS_CONFIRMED ||
+           stat == ICAL_STATUS_CANCELLED )){
+
+        return "Failed iTIP restrictions for STATUS property. Value must be one of TENTATIVE, CONFIRMED or CANCELED";
+
+    }
+
+    return 0;    
+}
+
+char* icalrestriction_must_be_cancel_if_present(
+    icalrestriction_property_record *rec,
+    icalcomponent* comp, 
+    icalproperty* prop)
+{
+    /* This routine will not be called if prop == 0 */
+    icalproperty_status stat = icalproperty_get_status(prop);
+
+    if( stat != ICAL_STATUS_CANCELLED)
+    {
+        return "Failed iTIP restrictions for STATUS property. Value must be CANCELLED";
+
+    }
+ 
+
+    return 0;    
+}
+
+char* icalrestriction_must_be_canceled_no_attendee(
+    icalrestriction_property_record *rec,
+    icalcomponent* comp, 
+    icalproperty* prop)
+{
+
+    /* Hack. see rfc2446, 3.2.5 CANCEL for porperty STATUS. I don't
+       understand the note */
+
+    return 0;    
+}
+char* icalrestriction_must_be_recurring(icalrestriction_property_record *rec,
+                                        icalcomponent* comp, 
+                                        icalproperty* prop){
+    /* Hack */
+    return 0;    
+}
+char* icalrestriction_must_have_duration(icalrestriction_property_record *rec,
+                                         icalcomponent* comp, 
+                                         icalproperty* prop){
+    
+    if( !icalcomponent_get_first_property(comp,ICAL_DURATION_PROPERTY)){
+
+        return "Failed iTIP restrictions for STATUS property. This component must have a DURATION property";
+
+    }
+
+    return 0;    
+}
+char* icalrestriction_must_have_repeat(icalrestriction_property_record *rec,
+                                       icalcomponent* comp, 
+                                       icalproperty* prop){
+    if( !icalcomponent_get_first_property(comp,ICAL_REPEAT_PROPERTY)){
+
+        return "Failed iTIP restrictions for STATUS property. This component must have a REPEAT property";
+
+    }
+
+    return 0;    
+}
+char* icalrestriction_must_if_tz_ref(icalrestriction_property_record *rec,
+                                     icalcomponent* comp, 
+                                     icalproperty* prop){
+
+    /* Hack */
+    return 0;    
+}
+char* icalrestriction_no_dtend(icalrestriction_property_record *rec,
+                               icalcomponent* comp, 
+                               icalproperty* prop){
+
+    if( !icalcomponent_get_first_property(comp,ICAL_DTEND_PROPERTY)){
+
+        return "Failed iTIP restrictions for STATUS property. The component must not have both DURATION and DTEND";
+
+    }
+
+    return 0;    
+}
+char* icalrestriction_no_duration(icalrestriction_property_record *rec,
+                                icalcomponent* comp, 
+                                  icalproperty* prop){
+
+    /* _no_dtend takes care of this one */
+    return 0;    
+}                                     
+
+
+int icalrestriction_check_component(icalproperty_method method,
+                                    icalcomponent* comp)
+{
+    icalproperty_kind kind;
+    icalcomponent_kind comp_kind;
+    icalrestriction_kind restr;
+    icalrestriction_property_record *prop_record = 0L;
+    icalrestriction_component_record *comp_record = 0L;
+    char* funcr = 0;
+    icalproperty *prop;
+
+    int count;
+    int compare;
+    int valid = 1;
+
+    comp_kind = icalcomponent_isa(comp);
+
+    /* Check all of the properties in this component */
+
+    for(kind = ICAL_ANY_PROPERTY+1; kind != ICAL_NO_PROPERTY; kind++){
+        count = icalcomponent_count_properties(comp, kind);
+        
+        prop_record = icalrestriction_get_property_restriction(method, 
+                                                         comp_kind,
+                                                         kind);
+
+        restr = prop_record->restriction;
+
+        if(restr == ICAL_RESTRICTION_ONEEXCLUSIVE ||
+            restr == ICAL_RESTRICTION_ONEMUTUAL) {
+
+            /* First treat is as a 0/1 restriction */
+            restr = ICAL_RESTRICTION_ZEROORONE;
+            compare = icalrestriction_compare(restr,count);
+
+        } else {
+
+            compare = icalrestriction_compare(restr,count);
+        }
+
+        assert(compare != -1);
+
+        if (compare == 0){
+            char temp[TMP_BUF_SIZE];
+            
+            snprintf(temp, TMP_BUF_SIZE,"Failed iTIP restrictions for %s property. Expected %s instances of the property and got %d",
+                    icalenum_property_kind_to_string(kind),
+                    restr_string_map[restr], count);
+            
+            icalcomponent_add_property
+                (comp,
+                 icalproperty_vanew_xlicerror(
+                     temp,
+                     icalparameter_new_xlicerrortype(ICAL_XLICERRORTYPE_INVALIDITIP),
+                     0));   
+        } 
+
+
+        prop = icalcomponent_get_first_property(comp, kind);
+
+        if (prop != 0 && prop_record->function !=0  ){
+            funcr =  prop_record->function(prop_record,comp,prop);
+        }
+
+        if(funcr !=0){
+            icalcomponent_add_property
+                (comp,
+                 icalproperty_vanew_xlicerror(
+                     funcr,
+                     icalparameter_new_xlicerrortype(
+                         ICAL_XLICERRORTYPE_INVALIDITIP),
+                     0));   
+
+            compare = 0;
+        }
+
+        valid = valid && compare;
+    }
+
+
+
+    return valid;
+
+
+}
+
+int icalrestriction_check(icalcomponent* outer_comp)
+{
+    icalcomponent_kind comp_kind;
+    icalproperty_method method;
+    icalcomponent* inner_comp;
+    icalproperty *method_prop;
+    int valid;
+    
+    icalerror_check_arg_rz( (outer_comp!=0), "outer comp");
+
+
+    /* Get the Method value from the outer component */
+
+    comp_kind = icalcomponent_isa(outer_comp);
+
+    if (comp_kind != ICAL_VCALENDAR_COMPONENT){
+        icalerror_set_errno(ICAL_BADARG_ERROR);
+        return 0;
+    }
+
+    method_prop = icalcomponent_get_first_property(outer_comp,
+                                                   ICAL_METHOD_PROPERTY);
+
+    if (method_prop == 0){
+        method = ICAL_METHOD_NONE;
+    } else {
+        method = icalproperty_get_method(method_prop);
+    }
+   
+
+    /* Check the VCALENDAR wrapper */
+    valid = icalrestriction_check_component(ICAL_METHOD_NONE,outer_comp);
+
+
+    /* Now check the inner components */
+
+    for(inner_comp= icalcomponent_get_first_component(outer_comp,
+                                                      ICAL_ANY_COMPONENT);
+        inner_comp != 0;
+        inner_comp= icalcomponent_get_next_component(outer_comp,
+                                                     ICAL_ANY_COMPONENT)){
+
+        valid = valid && icalrestriction_check_component(method,inner_comp);
+
+    }
+
+
+    return valid;
+
+}
+
+icalrestriction_property_record*
+icalrestriction_get_property_restriction(icalproperty_method method,
+                                         icalcomponent_kind component,
+                                         icalproperty_kind property)
+{
+    int i;
+
+    for(i = 0;
+        icalrestriction_property_records[i].restriction != ICAL_RESTRICTION_NONE;
+        i++){
+
+        if (method == icalrestriction_property_records[i].method &&
+            component == icalrestriction_property_records[i].component &&
+            property ==  icalrestriction_property_records[i].property ){
+            return  &icalrestriction_property_records[i];
+        }
+    }
+        
+    return &null_prop_record;
+}
+
+
+icalrestriction_component_record*
+icalrestriction_get_component_restriction(icalproperty_method method,
+                                          icalcomponent_kind component,
+                                          icalcomponent_kind subcomponent)
+{
+
+    int i;
+
+    for(i = 0;
+        icalrestriction_component_records[i].restriction != ICAL_RESTRICTION_NONE;
+        i++){
+
+        if (method == icalrestriction_component_records[i].method &&
+            component == icalrestriction_component_records[i].component &&
+            subcomponent ==  icalrestriction_component_records[i].subcomponent ){
+            return  &icalrestriction_component_records[i];
+        }
+    }
+        
+    return &null_comp_record;
+}
+
+/* Everything below this line is machine generated. Do not edit. */
+icalrestriction_property_record icalrestriction_property_records[] = {
+    {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,icalrestriction_must_be_recurring},
+    {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROPLUS ,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,icalrestriction_may_be_tent_conf_cancel},
+    {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ONEPLUS,0},
+    {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROPLUS ,0},
+    {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ONEEXCLUSIVE,icalrestriction_no_duration},
+    {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ONEEXCLUSIVE,icalrestriction_no_dtend},
+    {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,icalrestriction_must_be_recurring},
+    {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,icalrestriction_may_be_tent_conf},
+    {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,icalrestriction_must_be_recurring},
+    {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROPLUS ,0},
+    {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ONEEXCLUSIVE,icalrestriction_no_duration},
+    {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ONEEXCLUSIVE,icalrestriction_no_dtend},
+    {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROPLUS ,0},
+    {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ONEEXCLUSIVE,icalrestriction_no_duration},
+    {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ONEEXCLUSIVE,icalrestriction_no_duration},
+    {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,icalrestriction_may_be_tent_conf},
+    {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZERO,icalrestriction_must_be_recurring},
+    {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROPLUS ,0},
+    {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ONEEXCLUSIVE ,icalrestriction_no_duration},
+    {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ONEEXCLUSIVE,icalrestriction_no_duration},
+    {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,icalrestriction_must_be_recurring},
+    {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,icalrestriction_must_be_canceled_no_attendee},
+    {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,icalrestriction_must_be_recurring},
+    {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROPLUS ,0},
+    {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ONEEXCLUSIVE,icalrestriction_no_duration},
+    {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ONEEXCLUSIVE,icalrestriction_no_duration},
+    {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,icalrestriction_must_be_recurring},
+    {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,icalrestriction_may_be_tent_conf_cancel},
+    {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,icalrestriction_must_be_recurring},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ONEPLUS,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ONEPLUS,0},
+    {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ONEPLUS,0},
+    {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROPLUS ,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,icalrestriction_must_be_recurring},
+    {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ONEPLUS,0},
+    {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROPLUS ,0},
+    {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,icalrestriction_must_be_recurring},
+    {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,icalrestriction_may_be_comp_need_process},
+    {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ONEPLUS,0},
+    {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ONEPLUS,0},
+    {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROPLUS ,0},
+    {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,icalrestriction_must_be_recurring},
+    {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,icalrestriction_may_be_comp_need_process},
+    {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZERO,icalrestriction_must_be_recurring},
+    {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROPLUS ,0},
+    {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,icalrestriction_must_be_recurring},
+    {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,icalrestriction_must_be_canceled_no_attendee},
+    {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,icalrestriction_must_be_recurring},
+    {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ONEPLUS,0},
+    {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROPLUS ,0},
+    {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,icalrestriction_must_be_recurring},
+    {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,icalrestriction_may_be_comp_need_process},
+    {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ONEPLUS,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROPLUS ,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,icalrestriction_must_be_recurring},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROPLUS ,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,icalrestriction_must_be_recurring},
+    {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,icalrestriction_may_be_draft_final_canceled},
+    {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROPLUS ,0},
+    {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROPLUS ,0},
+    {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,icalrestriction_must_be_recurring},
+    {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,icalrestriction_must_be_cancel_if_present},
+    {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_ACTION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_CALSCALE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_COMPLETED_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_METHOD_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_PRODID_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_REPEAT_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_TRIGGER_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_TZID_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_TZNAME_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_TZOFFSETFROM_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_TZOFFSETTO_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_TZURL_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_VERSION_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_NONE,ICAL_VCALENDAR_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_ACTION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_CALSCALE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_COMPLETED_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ONEEXCLUSIVE,icalrestriction_no_duration},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ONEEXCLUSIVE,icalrestriction_no_duration},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_METHOD_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_PRODID_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,icalrestriction_must_be_recurring},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_REPEAT_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_TRIGGER_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_TZID_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_TZNAME_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_TZOFFSETFROM_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_TZOFFSETTO_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_TZURL_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_VERSION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VEVENT_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_ACTION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_CALSCALE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_COMPLETED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ONEEXCLUSIVE,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ONEEXCLUSIVE,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_METHOD_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_PRODID_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,icalrestriction_must_be_recurring},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_REPEAT_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_TRIGGER_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_TZID_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_TZNAME_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_TZOFFSETFROM_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_TZOFFSETTO_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_TZURL_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_VERSION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTODO_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_ACTION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_CALSCALE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_COMPLETED_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ONEEXCLUSIVE,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ONEEXCLUSIVE,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_METHOD_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_PRODID_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,icalrestriction_must_be_recurring},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_REPEAT_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_TRIGGER_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_TZID_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_TZNAME_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_TZOFFSETFROM_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_TZOFFSETTO_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_TZURL_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_VERSION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VJOURNAL_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_ACTION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_CALSCALE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_COMPLETED_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_METHOD_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_PRODID_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_REPEAT_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_TRIGGER_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_TZID_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_TZNAME_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_TZOFFSETFROM_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_TZOFFSETTO_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_TZURL_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_VERSION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VFREEBUSY_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_ACTION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_CALSCALE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_COMPLETED_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_METHOD_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_PRODID_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_REPEAT_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_TRIGGER_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_TZID_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_TZNAME_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_TZOFFSETFROM_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_TZOFFSETTO_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_TZURL_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_VERSION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_VTIMEZONE_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_ACTION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_CALSCALE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_COMPLETED_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_METHOD_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_PRODID_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_REPEAT_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_TRIGGER_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_TZID_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_TZNAME_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_TZOFFSETFROM_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_TZOFFSETTO_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_TZURL_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_VERSION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XSTANDARD_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_ACTION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_CALSCALE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_COMPLETED_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_METHOD_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_PRODID_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_REPEAT_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_TRIGGER_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_TZID_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_TZNAME_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_TZOFFSETFROM_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_TZOFFSETTO_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_TZURL_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_VERSION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDAYLIGHT_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_ACTION_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_CALSCALE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_COMPLETED_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ONEMUTUAL,icalrestriction_must_have_repeat},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_REPEAT_PROPERTY,ICAL_RESTRICTION_ONEMUTUAL,icalrestriction_must_have_duration},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_METHOD_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_PRODID_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_TRIGGER_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_TZID_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_TZNAME_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_TZOFFSETFROM_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_TZOFFSETTO_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_TZURL_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_VERSION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_ACTION_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_CALSCALE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_COMPLETED_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ONEMUTUAL,icalrestriction_must_have_repeat},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_REPEAT_PROPERTY,ICAL_RESTRICTION_ONEMUTUAL,icalrestriction_must_have_duration},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_METHOD_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_PRODID_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_TRIGGER_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_TZID_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_TZNAME_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_TZOFFSETFROM_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_TZOFFSETTO_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_TZURL_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_VERSION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_ACTION_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ONEPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_CALSCALE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_COMPLETED_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ONEMUTUAL,icalrestriction_must_have_repeat},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_REPEAT_PROPERTY,ICAL_RESTRICTION_ONEMUTUAL,icalrestriction_must_have_duration},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_METHOD_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_PRODID_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_TRIGGER_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_TZID_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_TZNAME_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_TZOFFSETFROM_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_TZOFFSETTO_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_TZURL_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_VERSION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_ACTION_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_ATTACH_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_ATTENDEE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_CALSCALE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_CATEGORIES_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_CLASS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_COMMENT_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_COMPLETED_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_CONTACT_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_CREATED_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_DESCRIPTION_PROPERTY,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_DTEND_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_DTSTAMP_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_DTSTART_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_DUE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ONEMUTUAL,icalrestriction_must_have_repeat},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_REPEAT_PROPERTY,ICAL_RESTRICTION_ONEMUTUAL,icalrestriction_must_have_duration},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_EXDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_EXRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_FREEBUSY_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_GEO_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_LASTMODIFIED_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_LOCATION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_METHOD_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_ORGANIZER_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_PERCENTCOMPLETE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_PRIORITY_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_PRODID_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_RDATE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_RECURRENCEID_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_RELATEDTO_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_REQUESTSTATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_RESOURCES_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_RRULE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_SEQUENCE_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_STATUS_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_SUMMARY_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_TRANSP_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_TRIGGER_PROPERTY,ICAL_RESTRICTION_ONE,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_TZID_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_TZNAME_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_TZOFFSETFROM_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_TZOFFSETTO_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_TZURL_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_UID_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_URL_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_VERSION_PROPERTY,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_X_PROPERTY,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_NONE,ICAL_NO_COMPONENT,ICAL_NO_PROPERTY,ICAL_RESTRICTION_NONE}
+};
+icalrestriction_component_record icalrestriction_component_records[] = {
+    {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_VJOURNAL_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_VTODO_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,icalrestriction_must_if_tz_ref},
+    {ICAL_METHOD_PUBLISH,ICAL_VEVENT_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,icalrestriction_must_if_tz_ref},
+    {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_VJOURNAL_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_VTODO_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROORONE,icalrestriction_must_if_tz_ref},
+    {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_VJOURNAL_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REPLY,ICAL_VEVENT_COMPONENT,ICAL_VTODO_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,icalrestriction_must_if_tz_ref},
+    {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_VTODO_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_VJOURNAL_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,icalrestriction_must_if_tz_ref},
+    {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_VTODO_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_VJOURNAL_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_CANCEL,ICAL_VEVENT_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_VTODO_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_VJOURNAL_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZERO,icalrestriction_must_if_tz_ref},
+    {ICAL_METHOD_REFRESH,ICAL_VEVENT_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,icalrestriction_must_if_tz_ref},
+    {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_VTODO_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_VJOURNAL_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_VTODO_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_VJOURNAL_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZERO,icalrestriction_must_if_tz_ref},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VEVENT_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_VEVENT_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_VTODO_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_VJOURNAL_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZERO,icalrestriction_must_if_tz_ref},
+    {ICAL_METHOD_PUBLISH,ICAL_VFREEBUSY_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_VEVENT_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_VTODO_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_VJOURNAL_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REQUEST,ICAL_VFREEBUSY_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_VEVENT_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_VTODO_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_VJOURNAL_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REPLY,ICAL_VFREEBUSY_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_VEVENT_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VTODO_COMPONENT,ICAL_VJOURNAL_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_VEVENT_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REQUEST,ICAL_VTODO_COMPONENT,ICAL_VJOURNAL_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_VEVENT_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REPLY,ICAL_VTODO_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_VEVENT_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_VJOURNAL_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_ADD,ICAL_VTODO_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_VEVENT_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_CANCEL,ICAL_VTODO_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_VEVENT_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_REFRESH,ICAL_VTODO_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_VEVENT_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_COUNTER,ICAL_VTODO_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_VEVENT_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_DECLINECOUNTER,ICAL_VTODO_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_VEVENT_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_PUBLISH,ICAL_VJOURNAL_COMPONENT,ICAL_VTODO_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROORONE,0},
+    {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_VEVENT_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_ADD,ICAL_VJOURNAL_COMPONENT,ICAL_VTODO_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_VTIMEZONE_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_X_COMPONENT,ICAL_RESTRICTION_ZEROPLUS,0},
+    {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_VALARM_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_VEVENT_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_VFREEBUSY_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_CANCEL,ICAL_VJOURNAL_COMPONENT,ICAL_VTODO_COMPONENT,ICAL_RESTRICTION_ZERO,0},
+    {ICAL_METHOD_NONE,ICAL_NO_COMPONENT,ICAL_NO_COMPONENT,ICAL_RESTRICTION_NONE}
+};
diff --git a/libical/src/libical/icalrestriction.c.in b/libical/src/libical/icalrestriction.c.in
new file mode 100644
index 0000000..4544425
--- a/dev/null
+++ b/libical/src/libical/icalrestriction.c.in
@@ -0,0 +1,447 @@
+/*  -*- Mode: C -*- */
+/*  ======================================================================
+  File: icalrestriction.c
+    
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+ ======================================================================*/
+/*#line 7 "icalrestriction.c.in"*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "icalrestriction.h"
+#include "icalenums.h"
+#include "icalerror.h"
+
+#include <assert.h>
+#include <stdio.h> /* For snprintf */   
+
+#define TMP_BUF_SIZE 1024
+
+
+/* Define the structs for the restrictions. these data are filled out
+in machine generated code below */
+
+struct icalrestriction_property_record;
+
+typedef char* (*restriction_func)(struct icalrestriction_property_record* rec,icalcomponent* comp,icalproperty* prop);
+
+
+typedef struct icalrestriction_property_record {
+        icalproperty_method method;
+        icalcomponent_kind component;
+        icalproperty_kind property;
+        icalrestriction_kind restriction;
+        restriction_func function;
+} icalrestriction_property_record;
+
+
+typedef struct icalrestriction_component_record {
+        icalproperty_method method;
+        icalcomponent_kind component;
+        icalcomponent_kind subcomponent;
+        icalrestriction_kind restriction;
+        restriction_func function;
+} icalrestriction_component_record;
+
+icalrestriction_property_record*
+icalrestriction_get_property_restriction(icalproperty_method method,
+                                         icalcomponent_kind component,
+                                         icalproperty_kind property);
+icalrestriction_component_record*
+icalrestriction_get_component_restriction(icalproperty_method method,
+                                          icalcomponent_kind component,
+                                          icalcomponent_kind subcomponent);
+
+icalrestriction_component_record icalrestriction_component_records[];
+icalrestriction_property_record icalrestriction_property_records[]; 
+
+icalrestriction_property_record null_prop_record =   {ICAL_METHOD_NONE,ICAL_NO_COMPONENT,ICAL_NO_PROPERTY,ICAL_RESTRICTION_UNKNOWN,0};
+icalrestriction_component_record null_comp_record =   {ICAL_METHOD_NONE,ICAL_NO_COMPONENT,ICAL_NO_COMPONENT,ICAL_RESTRICTION_UNKNOWN,0};
+
+
+/* The each row gives the result of comparing a restriction against a
+   count. The columns in each row represent 0,1,2+. '-1' indicates
+   'invalid, 'don't care' or 'needs more analysis' So, for
+   ICAL_RESTRICTION_ONE, if there is 1 of a property with that
+   restriction, it passes, but if there are 0 or 2+, it fails. */
+
+char compare_map[ICAL_RESTRICTION_UNKNOWN+1][3] = {
+    { 1, 1, 1},/*ICAL_RESTRICTION_NONE*/
+    { 1, 0, 0},/*ICAL_RESTRICTION_ZERO*/
+    { 0, 1, 0},/*ICAL_RESTRICTION_ONE*/
+    { 1, 1, 1},/*ICAL_RESTRICTION_ZEROPLUS*/
+    { 0, 1, 1},/*ICAL_RESTRICTION_ONEPLUS*/
+    { 1, 1, 0},/*ICAL_RESTRICTION_ZEROORONE*/
+    { 1, 1, 0},/*ICAL_RESTRICTION_ONEEXCLUSIVE*/
+    { 1, 1, 0},/*ICAL_RESTRICTION_ONEMUTUAL*/
+    { 1, 1, 1} /*ICAL_RESTRICTION_UNKNOWN*/
+};
+
+char restr_string_map[ICAL_RESTRICTION_UNKNOWN+1][60] = {
+    "unknown number",/*ICAL_RESTRICTION_NONE*/
+    "0",/*ICAL_RESTRICTION_ZERO*/
+    "1",/*ICAL_RESTRICTION_ONE*/
+    "zero or more",/*ICAL_RESTRICTION_ZEROPLUS*/
+    "one or more" ,/*ICAL_RESTRICTION_ONEPLUS*/
+    "zero or one",/*ICAL_RESTRICTION_ZEROORONE*/
+    "zero or one, exclusive with another property",/*ICAL_RESTRICTION_ONEEXCLUSIVE*/
+    "zero or one, mutual with another property",/*ICAL_RESTRICTION_ONEMUTUAL*/
+    "unknown number" /*ICAL_RESTRICTION_UNKNOWN*/
+};
+
+
+int
+icalrestriction_compare(icalrestriction_kind restr, int count){
+
+    if ( restr < ICAL_RESTRICTION_NONE || restr > ICAL_RESTRICTION_UNKNOWN
+         || count < 0){
+        return -1;
+    }
+
+    if (count > 2) {
+        count = 2;
+    }
+
+    return compare_map[restr][count];
+
+}
+
+/* Special case routines */
+
+char* icalrestriction_may_be_draft_final_canceled(
+    icalrestriction_property_record *rec,
+    icalcomponent* comp, 
+    icalproperty* prop)
+{
+
+    icalproperty_status stat = icalproperty_get_status(prop);
+
+    if( !( stat == ICAL_STATUS_DRAFT ||
+           stat == ICAL_STATUS_FINAL ||
+           stat == ICAL_STATUS_CANCELLED )){
+
+        return "Failed iTIP restrictions for STATUS property. Value must be one of DRAFT, FINAL, or CANCELED";
+
+    }
+
+    return 0;    
+}
+
+char* icalrestriction_may_be_comp_need_process(
+    icalrestriction_property_record *rec,
+    icalcomponent* comp, 
+    icalproperty* prop)
+{
+    icalproperty_status stat = icalproperty_get_status(prop);
+
+    if( !( stat == ICAL_STATUS_COMPLETED ||
+           stat == ICAL_STATUS_NEEDSACTION ||
+           stat == ICAL_STATUS_INPROCESS )){
+
+        return "Failed iTIP restrictions for STATUS property. Value must be one of COMPLETED, NEEDS-ACTION or IN-PROCESS";
+
+    }
+
+    return 0;    
+}
+char* icalrestriction_may_be_tent_conf(icalrestriction_property_record *rec,
+                                       icalcomponent* comp, 
+                                       icalproperty* prop){
+    icalproperty_status stat = icalproperty_get_status(prop);
+
+    if( !( stat == ICAL_STATUS_TENTATIVE ||
+           stat == ICAL_STATUS_CONFIRMED )){
+
+        return "Failed iTIP restrictions for STATUS property. Value must be one of TENTATIVE or CONFIRMED";
+
+    }
+
+    return 0;    
+}
+char* icalrestriction_may_be_tent_conf_cancel(
+    icalrestriction_property_record *rec,
+    icalcomponent* comp, 
+    icalproperty* prop)
+{
+    icalproperty_status stat = icalproperty_get_status(prop);
+
+    if( !( stat == ICAL_STATUS_TENTATIVE ||
+           stat == ICAL_STATUS_CONFIRMED ||
+           stat == ICAL_STATUS_CANCELLED )){
+
+        return "Failed iTIP restrictions for STATUS property. Value must be one of TENTATIVE, CONFIRMED or CANCELED";
+
+    }
+
+    return 0;    
+}
+
+char* icalrestriction_must_be_cancel_if_present(
+    icalrestriction_property_record *rec,
+    icalcomponent* comp, 
+    icalproperty* prop)
+{
+    /* This routine will not be called if prop == 0 */
+    icalproperty_status stat = icalproperty_get_status(prop);
+
+    if( stat != ICAL_STATUS_CANCELLED)
+    {
+        return "Failed iTIP restrictions for STATUS property. Value must be CANCELLED";
+
+    }
+ 
+
+    return 0;    
+}
+
+char* icalrestriction_must_be_canceled_no_attendee(
+    icalrestriction_property_record *rec,
+    icalcomponent* comp, 
+    icalproperty* prop)
+{
+
+    /* Hack. see rfc2446, 3.2.5 CANCEL for porperty STATUS. I don't
+       understand the note */
+
+    return 0;    
+}
+char* icalrestriction_must_be_recurring(icalrestriction_property_record *rec,
+                                        icalcomponent* comp, 
+                                        icalproperty* prop){
+    /* Hack */
+    return 0;    
+}
+char* icalrestriction_must_have_duration(icalrestriction_property_record *rec,
+                                         icalcomponent* comp, 
+                                         icalproperty* prop){
+    
+    if( !icalcomponent_get_first_property(comp,ICAL_DURATION_PROPERTY)){
+
+        return "Failed iTIP restrictions for STATUS property. This component must have a DURATION property";
+
+    }
+
+    return 0;    
+}
+char* icalrestriction_must_have_repeat(icalrestriction_property_record *rec,
+                                       icalcomponent* comp, 
+                                       icalproperty* prop){
+    if( !icalcomponent_get_first_property(comp,ICAL_REPEAT_PROPERTY)){
+
+        return "Failed iTIP restrictions for STATUS property. This component must have a REPEAT property";
+
+    }
+
+    return 0;    
+}
+char* icalrestriction_must_if_tz_ref(icalrestriction_property_record *rec,
+                                     icalcomponent* comp, 
+                                     icalproperty* prop){
+
+    /* Hack */
+    return 0;    
+}
+char* icalrestriction_no_dtend(icalrestriction_property_record *rec,
+                               icalcomponent* comp, 
+                               icalproperty* prop){
+
+    if( !icalcomponent_get_first_property(comp,ICAL_DTEND_PROPERTY)){
+
+        return "Failed iTIP restrictions for STATUS property. The component must not have both DURATION and DTEND";
+
+    }
+
+    return 0;    
+}
+char* icalrestriction_no_duration(icalrestriction_property_record *rec,
+                                icalcomponent* comp, 
+                                  icalproperty* prop){
+
+    /* _no_dtend takes care of this one */
+    return 0;    
+}                                     
+
+
+int icalrestriction_check_component(icalproperty_method method,
+                                    icalcomponent* comp)
+{
+    icalproperty_kind kind;
+    icalcomponent_kind comp_kind;
+    icalrestriction_kind restr;
+    icalrestriction_property_record *prop_record;
+    icalrestriction_component_record *comp_record;
+    char* funcr = 0;
+    icalproperty *prop;
+
+    int count;
+    int compare;
+    int valid = 1;
+
+    comp_kind = icalcomponent_isa(comp);
+
+    /* Check all of the properties in this component */
+
+    for(kind = ICAL_ANY_PROPERTY+1; kind != ICAL_NO_PROPERTY; kind++){
+        count = icalcomponent_count_properties(comp, kind);
+        
+        prop_record = icalrestriction_get_property_restriction(method, 
+                                                         comp_kind,
+                                                         kind);
+
+        restr = prop_record->restriction;
+
+        if(restr == ICAL_RESTRICTION_ONEEXCLUSIVE ||
+            restr == ICAL_RESTRICTION_ONEMUTUAL) {
+
+            /* First treat is as a 0/1 restriction */
+            restr = ICAL_RESTRICTION_ZEROORONE;
+            compare = icalrestriction_compare(restr,count);
+
+        } else {
+
+            compare = icalrestriction_compare(restr,count);
+        }
+
+        assert(compare != -1);
+
+        if (compare == 0){
+            char temp[TMP_BUF_SIZE];
+            
+            snprintf(temp, TMP_BUF_SIZE,"Failed iTIP restrictions for %s property. Expected %s instances of the property and got %d",
+                    icalenum_property_kind_to_string(kind),
+                    restr_string_map[restr], count);
+            
+            icalcomponent_add_property
+                (comp,
+                 icalproperty_vanew_xlicerror(
+                     temp,
+                     icalparameter_new_xlicerrortype(ICAL_XLICERRORTYPE_INVALIDITIP),
+                     0));   
+        } 
+
+
+        prop = icalcomponent_get_first_property(comp, kind);
+
+        if (prop != 0 && prop_record->function !=0  ){
+            funcr =  prop_record->function(prop_record,comp,prop);
+        }
+
+        if(funcr !=0){
+            icalcomponent_add_property
+                (comp,
+                 icalproperty_vanew_xlicerror(
+                     funcr,
+                     icalparameter_new_xlicerrortype(
+                         ICAL_XLICERRORTYPE_INVALIDITIP),
+                     0));   
+
+            compare = 0;
+        }
+
+        valid = valid && compare;
+    }
+
+
+
+    return valid;
+
+
+}
+
+int icalrestriction_check(icalcomponent* outer_comp)
+{
+    icalcomponent_kind comp_kind;
+    icalproperty_method method;
+    icalcomponent* inner_comp;
+    icalproperty *method_prop;
+    int valid;
+    
+    icalerror_check_arg_rz( (outer_comp!=0), "outer comp");
+
+
+    /* Get the Method value from the outer component */
+
+    comp_kind = icalcomponent_isa(outer_comp);
+
+    if (comp_kind != ICAL_VCALENDAR_COMPONENT){
+        icalerror_set_errno(ICAL_BADARG_ERROR);
+        return 0;
+    }
+
+    method_prop = icalcomponent_get_first_property(outer_comp,
+                                                   ICAL_METHOD_PROPERTY);
+
+    if (method_prop == 0){
+        method = ICAL_METHOD_NONE;
+    } else {
+        method = icalproperty_get_method(method_prop);
+    }
+   
+
+    /* Check the VCALENDAR wrapper */
+    valid = icalrestriction_check_component(ICAL_METHOD_NONE,outer_comp);
+
+
+    /* Now check the inner components */
+
+    for(inner_comp= icalcomponent_get_first_component(outer_comp,
+                                                      ICAL_ANY_COMPONENT);
+        inner_comp != 0;
+        inner_comp= icalcomponent_get_next_component(outer_comp,
+                                                     ICAL_ANY_COMPONENT)){
+
+        valid = valid && icalrestriction_check_component(method,inner_comp);
+
+    }
+
+
+    return valid;
+
+}
+
+icalrestriction_property_record*
+icalrestriction_get_property_restriction(icalproperty_method method,
+                                         icalcomponent_kind component,
+                                         icalproperty_kind property)
+{
+    int i;
+
+    for(i = 0;
+        icalrestriction_property_records[i].restriction != ICAL_RESTRICTION_NONE;
+        i++){
+
+        if (method == icalrestriction_property_records[i].method &&
+            component == icalrestriction_property_records[i].component &&
+            property ==  icalrestriction_property_records[i].property ){
+            return  &icalrestriction_property_records[i];
+        }
+    }
+        
+    return &null_prop_record;
+}
+
+
+icalrestriction_component_record*
+icalrestriction_get_component_restriction(icalproperty_method method,
+                                          icalcomponent_kind component,
+                                          icalcomponent_kind subcomponent)
+{
+
+    int i;
+
+    for(i = 0;
+        icalrestriction_component_records[i].restriction != ICAL_RESTRICTION_NONE;
+        i++){
+
+        if (method == icalrestriction_component_records[i].method &&
+            component == icalrestriction_component_records[i].component &&
+            subcomponent ==  icalrestriction_component_records[i].subcomponent ){
+            return  &icalrestriction_component_records[i];
+        }
+    }
+        
+    return &null_comp_record;
+}
+
diff --git a/libical/src/libical/icalrestriction.h b/libical/src/libical/icalrestriction.h
new file mode 100644
index 0000000..409334c
--- a/dev/null
+++ b/libical/src/libical/icalrestriction.h
@@ -0,0 +1,63 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+  FILE: icalrestriction.h
+  CREATOR: eric 24 April 1999
+  
+  $Id$
+
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalrestriction.h
+
+  Contributions from:
+     Graham Davison (g.m.davison@computer.org)
+
+
+======================================================================*/
+
+#include "icalproperty.h"
+#include "icalcomponent.h"
+
+#ifndef ICALRESTRICTION_H
+#define ICALRESTRICTION_H
+
+/* These must stay in this order for icalrestriction_compare to work */
+typedef enum icalrestriction_kind {
+            ICAL_RESTRICTION_NONE=0,    /* 0 */
+            ICAL_RESTRICTION_ZERO,      /* 1 */
+            ICAL_RESTRICTION_ONE,       /* 2 */
+            ICAL_RESTRICTION_ZEROPLUS,  /* 3 */
+            ICAL_RESTRICTION_ONEPLUS,   /* 4 */
+            ICAL_RESTRICTION_ZEROORONE,         /* 5 */
+            ICAL_RESTRICTION_ONEEXCLUSIVE,/* 6 */
+            ICAL_RESTRICTION_ONEMUTUAL,         /* 7 */
+            ICAL_RESTRICTION_UNKNOWN    /* 8 */
+} icalrestriction_kind;
+
+int 
+icalrestriction_compare(icalrestriction_kind restr, int count);
+
+
+int
+icalrestriction_is_parameter_allowed(icalproperty_kind property,
+                                       icalparameter_kind parameter);
+
+int icalrestriction_check(icalcomponent* comp);
+
+
+#endif /* !ICALRESTRICTION_H */
+
+
+
diff --git a/libical/src/libical/icaltime.c b/libical/src/libical/icaltime.c
new file mode 100644
index 0000000..a04ca04
--- a/dev/null
+++ b/libical/src/libical/icaltime.c
@@ -0,0 +1,577 @@
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: icaltime.c
+  CREATOR: eric 02 June 2000
+  
+  $Id$
+  $Locker$
+    
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+ ======================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "icaltime.h"
+#include <assert.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+int snprintf(char *str, size_t n, char const *fmt, ...);
+
+#ifdef ICAL_NO_LIBICAL
+#define icalerror_set_errno(x)
+#define  icalerror_check_arg_rv(x,y)
+#define  icalerror_check_arg_re(x,y,z)
+#else
+#include "icalerror.h"
+#include "icalmemory.h"
+#endif
+
+
+
+
+struct icaltimetype 
+icaltime_from_timet(time_t tm, int is_date)
+{
+    struct icaltimetype tt = icaltime_null_time();
+    struct tm t;
+
+    t = *(gmtime(&tm));
+     
+    if(is_date == 0){ 
+        tt.second = t.tm_sec;
+        tt.minute = t.tm_min;
+        tt.hour = t.tm_hour;
+    } else {
+        tt.second = tt.minute =tt.hour = 0 ;
+    }
+
+    tt.day = t.tm_mday;
+    tt.month = t.tm_mon + 1;
+    tt.year = t.tm_year+ 1900;
+    
+    tt.is_utc = 1;
+    tt.is_date = is_date; 
+
+    return tt;
+}
+
+/* Structure used by set_tz to hold an old value of TZ, and the new
+   value, which is in memory we will have to free in unset_tz */
+struct set_tz_save {char* orig_tzid; char* new_env_str;};
+
+/* Temporarily change the TZ environmental variable. */
+struct set_tz_save set_tz(const char* tzid)
+{
+
+    char *orig_tzid = 0;
+    char *new_env_str;
+    struct set_tz_save savetz;
+    size_t tmp_sz; 
+
+    savetz.orig_tzid = 0;
+    savetz.new_env_str = 0;
+
+    if(getenv("TZ") != 0){
+        orig_tzid = (char*)icalmemory_strdup(getenv("TZ"));
+
+        if(orig_tzid == 0){
+            icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+            return savetz;
+        }
+    }
+
+    tmp_sz =strlen(tzid)+4; 
+    new_env_str = (char*)malloc(tmp_sz);
+
+    if(new_env_str == 0){
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        return savetz;
+    }
+    
+    /* Copy the TZid into a string with the form that putenv expects. */
+    strcpy(new_env_str,"TZ=");
+    strcpy(new_env_str+3,tzid);
+
+    putenv(new_env_str); 
+
+    /* Old value of TZ and the string we will have to free later */
+    savetz.orig_tzid = orig_tzid;
+    savetz.new_env_str = new_env_str;
+    return savetz;
+}
+
+void unset_tz(struct set_tz_save savetz)
+{
+    /* restore the original TZ environment */
+
+    char* orig_tzid = savetz.orig_tzid;
+
+            if(orig_tzid!=0){
+        size_t tmp_sz =strlen(orig_tzid)+4; 
+        char* orig_env_str = (char*)icalmemory_tmp_buffer(tmp_sz);
+
+        if(orig_env_str == 0){
+            icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+            return;
+        }
+        
+        strcpy(orig_env_str,"TZ=");
+        strcpy(orig_env_str+3,orig_tzid);
+#ifndef _WIN32
+    setenv("TZ", savetz.orig_tzid,1 );
+#else
+    putenv("TZ=MEZ");//, savetz.orig_tzid );
+#endif
+        free(orig_tzid);
+    } else {
+#ifdef __FreeBSD__
+        unsetenv("TZ");
+#else
+        putenv("TZ"); /* Delete from environment */
+#endif
+    } 
+
+    if(savetz.new_env_str != 0){
+        free(savetz.new_env_str);
+    }
+}
+
+
+time_t icaltime_as_timet(struct icaltimetype tt)
+{
+    struct tm stm;
+    time_t t;
+
+    memset(&stm,0,sizeof( struct tm));
+
+    if(icaltime_is_null_time(tt)) {
+        return 0;
+    }
+
+    stm.tm_sec = tt.second;
+    stm.tm_min = tt.minute;
+    stm.tm_hour = tt.hour;
+    stm.tm_mday = tt.day;
+    stm.tm_mon = tt.month-1;
+    stm.tm_year = tt.year-1900;
+    stm.tm_isdst = -1;
+
+    if(tt.is_utc == 1 || tt.is_date == 1){
+        struct set_tz_save old_tz = set_tz("UTC");
+        t = mktime(&stm);
+        unset_tz(old_tz);
+    } else {
+        t = mktime(&stm);
+    }
+
+    return t;
+
+}
+
+char* icaltime_as_ical_string(struct icaltimetype tt)
+{
+    size_t size = 17;
+    char* buf = icalmemory_new_buffer(size);
+
+    if(tt.is_date){
+        snprintf(buf, size,"%04d%02d%02d",tt.year,tt.month,tt.day);
+    } else {
+        char* fmt;
+        if(tt.is_utc){
+            fmt = "%04d%02d%02dT%02d%02d%02dZ";
+        } else {
+            fmt = "%04d%02d%02dT%02d%02d%02d";
+        }
+        snprintf(buf, size,fmt,tt.year,tt.month,tt.day,
+                 tt.hour,tt.minute,tt.second);
+    }
+    
+    icalmemory_add_tmp_buffer(buf);
+
+    return buf;
+
+}
+
+
+/* convert tt, of timezone tzid, into a utc time */
+struct icaltimetype icaltime_as_utc(struct icaltimetype tt,const char* tzid)
+{
+    int tzid_offset;
+
+    if(tt.is_utc == 1 || tt.is_date == 1){
+        return tt;
+    }
+
+    tzid_offset = icaltime_utc_offset(tt,tzid);
+
+    tt.second -= tzid_offset;
+
+    tt.is_utc = 1;
+
+    return icaltime_normalize(tt);
+}
+
+/* convert tt, a time in UTC, into a time in timezone tzid */
+struct icaltimetype icaltime_as_zone(struct icaltimetype tt,const char* tzid)
+{
+    int tzid_offset;
+
+    tzid_offset = icaltime_utc_offset(tt,tzid);
+
+    tt.second += tzid_offset;
+
+    tt.is_utc = 0;
+
+    return icaltime_normalize(tt);
+
+}
+
+
+/* Return the offset of the named zone as seconds. tt is a time
+   indicating the date for which you want the offset */
+int icaltime_utc_offset(struct icaltimetype ictt, const char* tzid)
+{
+
+    time_t tt = icaltime_as_timet(ictt);
+    time_t offset_tt;
+    struct tm gtm;
+    struct set_tz_save old_tz; 
+
+    if(tzid != 0){
+        old_tz = set_tz(tzid);
+    }
+ 
+    /* Mis-interpret a UTC broken out time as local time */
+    gtm = *(gmtime(&tt));
+    gtm.tm_isdst = localtime(&tt)->tm_isdst;    
+    offset_tt = mktime(&gtm);
+    
+    if(tzid != 0){
+        unset_tz(old_tz);
+    }
+
+    return tt-offset_tt;
+}
+
+
+
+/* Normalize by converting from localtime to utc and back to local
+   time. This uses localtime because localtime and mktime are inverses
+   of each other */
+
+struct icaltimetype icaltime_normalize(struct icaltimetype tt)
+{
+    struct tm stm;
+    time_t tut;
+
+    memset(&stm,0,sizeof( struct tm));
+
+    stm.tm_sec = tt.second;
+    stm.tm_min = tt.minute;
+    stm.tm_hour = tt.hour;
+    stm.tm_mday = tt.day;
+    stm.tm_mon = tt.month-1;
+    stm.tm_year = tt.year-1900;
+    stm.tm_isdst = -1; /* prevents mktime from changing hour based on
+                          daylight savings */
+
+    tut = mktime(&stm);
+
+    stm = *(localtime(&tut));
+
+    tt.second = stm.tm_sec;
+    tt.minute = stm.tm_min;
+    tt.hour = stm.tm_hour;
+    tt.day = stm.tm_mday;
+    tt.month = stm.tm_mon +1;
+    tt.year = stm.tm_year+1900;
+
+    return tt;
+}
+
+
+#ifndef ICAL_NO_LIBICAL
+#include "icalvalue.h"
+
+struct icaltimetype icaltime_from_string(const char* str)
+{
+    struct icaltimetype tt = icaltime_null_time();
+    int size;
+
+    icalerror_check_arg_re(str!=0,"str",icaltime_null_time());
+
+    size = strlen(str);
+    
+    if(size == 15) { /* floating time */
+        tt.is_utc = 0;
+        tt.is_date = 0;
+    } else if (size == 16) { /* UTC time, ends in 'Z'*/
+        tt.is_utc = 1;
+        tt.is_date = 0;
+
+        if(str[15] != 'Z'){
+            icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+            return icaltime_null_time();
+        }
+            
+    } else if (size == 8) { /* A DATE */
+        tt.is_utc = 1;
+        tt.is_date = 1;
+    } else { /* error */
+        icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+        return icaltime_null_time();
+    }
+
+    if(tt.is_date == 1){
+        sscanf(str,"%04d%02d%02d",&tt.year,&tt.month,&tt.day);
+    } else {
+        char tsep;
+        sscanf(str,"%04d%02d%02d%c%02d%02d%02d",&tt.year,&tt.month,&tt.day,
+               &tsep,&tt.hour,&tt.minute,&tt.second);
+
+        if(tsep != 'T'){
+            icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+            return icaltime_null_time();
+        }
+
+    }
+
+    return tt;    
+}
+#endif
+
+char ctime_str[20];
+char* icaltime_as_ctime(struct icaltimetype t)
+{
+    time_t tt;
+ 
+    tt = icaltime_as_timet(t);
+    sprintf(ctime_str,"%s",ctime(&tt));
+
+    ctime_str[strlen(ctime_str)-1] = 0;
+
+    return ctime_str;
+}
+
+
+short days_in_month[] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
+
+short icaltime_days_in_month(short month,short year)
+{
+
+    int is_leap =0;
+    int days = days_in_month[month];
+
+    assert(month > 0);
+    assert(month <= 12);
+
+    if( (year % 4 == 0 && year % 100 != 0) ||
+        year % 400 == 0){
+        is_leap =1;
+    }
+
+    if( month == 2){
+        days += is_leap;
+    }
+
+    return days;
+}
+
+/* 1-> Sunday, 7->Saturday */
+short icaltime_day_of_week(struct icaltimetype t){
+
+    time_t tt = icaltime_as_timet(t);
+    struct tm *tm;
+
+    if(t.is_utc == 1 || t.is_date == 1){
+        tm = gmtime(&tt);
+    } else {
+        tm = localtime(&tt);
+    }
+
+    return tm->tm_wday+1;
+}
+
+/* Day of the year that the first day of the week (Sunday) is on  */
+short icaltime_start_doy_of_week(struct icaltimetype t){
+    time_t tt = icaltime_as_timet(t);
+    time_t start_tt;
+    struct tm *stm;
+    int syear;
+
+    stm = gmtime(&tt);
+    syear = stm->tm_year;
+
+    start_tt = tt - stm->tm_wday*(60*60*24);
+
+    stm = gmtime(&start_tt);
+    
+    if(syear == stm->tm_year){
+        return stm->tm_yday+1;
+    } else {
+        /* return negative to indicate that start of week is in
+           previous year. */
+        int is_leap = 0;
+        int year = stm->tm_year;
+
+        if( (year % 4 == 0 && year % 100 != 0) ||
+            year % 400 == 0){
+            is_leap =1;
+        }
+
+        return (stm->tm_yday+1)-(365+is_leap);
+    }
+    
+}
+
+short icaltime_week_number(struct icaltimetype ictt)
+{
+    char str[5];
+    time_t t = icaltime_as_timet(ictt);
+    int week_no;
+
+    strftime(str,5,"%V", gmtime(&t));
+
+    week_no = atoi(str);
+
+    return week_no;
+
+}
+
+
+short icaltime_day_of_year(struct icaltimetype t){
+    time_t tt;
+    struct tm *stm;
+    struct set_tz_save old_tz; 
+
+    tt =  icaltime_as_timet(t);
+
+    old_tz = set_tz("UTC");
+    stm = localtime(&tt);
+    unset_tz(old_tz);
+
+    return stm->tm_yday+1;
+    
+}
+
+/* Jan 1 is day #1, not 0 */
+struct icaltimetype icaltime_from_day_of_year(short doy,  short year)
+{
+    struct tm stm; 
+    time_t tt;
+    struct set_tz_save old_tz;
+
+    /* Get the time of january 1 of this year*/
+    memset(&stm,0,sizeof(struct tm)); 
+    stm.tm_year = year-1900;
+    stm.tm_mday = 1;
+
+    old_tz = set_tz("UTC");
+    tt = mktime(&stm);
+    unset_tz(old_tz);
+
+
+    /* Now add in the days */
+
+    doy--;
+    tt += doy *60*60*24;
+
+    return icaltime_from_timet(tt, 1);
+}
+
+struct icaltimetype icaltime_null_time()
+{
+    struct icaltimetype t;
+    memset(&t,0,sizeof(struct icaltimetype));
+
+    return t;
+}
+
+
+int icaltime_is_valid_time(struct icaltimetype t){
+    if(t.is_utc > 1 || t.is_utc < 0 ||
+       t.year < 0 || t.year > 3000 ||
+       t.is_date > 1 || t.is_date < 0){
+        return 0;
+    } else {
+        return 1;
+    }
+
+}
+
+int icaltime_is_null_time(struct icaltimetype t)
+{
+    if (t.second +t.minute+t.hour+t.day+t.month+t.year == 0){
+        return 1;
+    }
+
+    return 0;
+
+}
+
+int icaltime_compare(struct icaltimetype a,struct icaltimetype b)
+{
+    time_t t1 = icaltime_as_timet(a);
+    time_t t2 = icaltime_as_timet(b);
+
+    if (t1 > t2) { 
+        return 1; 
+    } else if (t1 < t2) { 
+        return -1;
+    } else { 
+        return 0; 
+    }
+
+}
+
+int
+icaltime_compare_date_only (struct icaltimetype a, struct icaltimetype b)
+{
+    time_t t1;
+    time_t t2;
+
+    if (a.year == b.year && a.month == b.month && a.day == b.day)
+        return 0;
+
+    t1 = icaltime_as_timet (a);
+    t2 = icaltime_as_timet (b);
+
+    if (t1 > t2) 
+        return 1; 
+    else if (t1 < t2)
+        return -1;
+    else {
+        /* not reached */
+        assert (0);
+        return 0;
+    }
+}
+
+
+/* These are defined in icalduration.c:
+struct icaltimetype  icaltime_add(struct icaltimetype t,
+                                  struct icaldurationtype  d)
+struct icaldurationtype  icaltime_subtract(struct icaltimetype t1,
+                                           struct icaltimetype t2)
+*/
+
diff --git a/libical/src/libical/icaltime.h b/libical/src/libical/icaltime.h
new file mode 100644
index 0000000..0f0379b
--- a/dev/null
+++ b/libical/src/libical/icaltime.h
@@ -0,0 +1,145 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icaltime.h
+ CREATOR: eric 02 June 2000
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+======================================================================*/
+
+#ifndef ICALTIME_H
+#define ICALTIME_H
+
+#include <time.h>
+
+/* icaltime_span is returned by icalcomponent_get_span() */
+struct icaltime_span {
+        time_t start; /* in UTC */
+        time_t end; /* in UTC */
+        int is_busy; /* 1->busy time, 0-> free time */
+};
+
+
+struct icaltimetype
+{
+        int year;
+        int month;
+        int day;
+        int hour;
+        int minute;
+        int second;
+
+        int is_utc; /* 1-> time is in UTC timezone */
+
+        int is_date; /* 1 -> interpret this as date. */
+   
+        const char* zone; /*Ptr to Olsen placename. Libical does not own mem*/
+        };
+
+/* Convert seconds past UNIX epoch to a timetype*/
+struct icaltimetype icaltime_from_timet(time_t v, int is_date);
+
+/* Return the time as seconds past the UNIX epoch */
+time_t icaltime_as_timet(struct icaltimetype);
+
+/* Return a string represention of the time, in RFC2445 format. The
+   string is owned by libical */
+char* icaltime_as_ical_string(struct icaltimetype tt);
+
+/* Like icaltime_from_timet(), except that the input may be in seconds
+   past the epoch in floating time. This routine is deprecated */
+struct icaltimetype icaltime_from_int(int v, int is_date, int is_utc);
+
+/* Like icaltime_as_timet, but in a floating epoch. This routine is deprecated */
+int icaltime_as_int(struct icaltimetype);
+
+/* create a time from an ISO format string */
+struct icaltimetype icaltime_from_string(const char* str);
+
+/* Routines for handling timezones */
+/* Return the offset of the named zone as seconds. tt is a time
+   indicating the date for which you want the offset */
+int icaltime_utc_offset(struct icaltimetype tt, const char* tzid);
+
+/* convert tt, of timezone tzid, into a utc time. Does nothing if the
+   time is already UTC.  */
+struct icaltimetype icaltime_as_utc(struct icaltimetype tt,
+                                    const char* tzid);
+
+/* convert tt, a time in UTC, into a time in timezone tzid */
+struct icaltimetype icaltime_as_zone(struct icaltimetype tt,
+                                     const char* tzid);
+
+/* Return a null time, which indicates no time has been set. This time represent the beginning of the epoch */
+struct icaltimetype icaltime_null_time(void);
+
+/* Return true of the time is null. */
+int icaltime_is_null_time(struct icaltimetype t);
+
+/* Returns false if the time is clearly invalid, but is not null. This
+   is usually the result of creating a new time type buy not clearing
+   it, or setting one of the flags to an illegal value. */
+int icaltime_is_valid_time(struct icaltimetype t);
+
+/* Reset all of the time components to be in their normal ranges. For
+   instance, given a time with minutes=70, the minutes will be reduces
+   to 10, and the hour incremented. This allows the caller to do
+   arithmetic on times without worrying about overflow or
+   underflow. */
+struct icaltimetype icaltime_normalize(struct icaltimetype t);
+
+/* Return the day of the year of the given time */
+short icaltime_day_of_year(struct icaltimetype t);
+
+/* Create a new time, given a day of year and a year. */
+struct icaltimetype icaltime_from_day_of_year(short doy,  short year);
+
+/* Return the day of the week of the given time. Sunday is 1 */
+short icaltime_day_of_week(struct icaltimetype t);
+
+/* Return the day of the year for the Sunday of the week that the
+   given time is within. */
+short icaltime_start_doy_of_week(struct icaltimetype t);
+
+/* Return a string with the time represented in the same format as ctime(). THe string is owned by libical */
+char* icaltime_as_ctime(struct icaltimetype);
+
+/* Return the week number for the week the given time is within */
+short icaltime_week_number(struct icaltimetype t);
+
+/* Create a new time from a weeknumber and a year. */
+struct icaltimetype icaltime_from_week_number(short week_number, short year);
+
+/* Return -1, 0, or 1 to indicate that a<b, a==b or a>b */
+int icaltime_compare(struct icaltimetype a,struct icaltimetype b);
+
+/* like icaltime_compare, but only use the date parts. */
+int icaltime_compare_date_only(struct icaltimetype a, struct icaltimetype b);
+
+/* Return the number of days in the given month */
+short icaltime_days_in_month(short month,short year);
+
+
+#endif /* !ICALTIME_H */
+
+
+
diff --git a/libical/src/libical/icaltypes.c b/libical/src/libical/icaltypes.c
new file mode 100644
index 0000000..8c67deb
--- a/dev/null
+++ b/libical/src/libical/icaltypes.c
@@ -0,0 +1,285 @@
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: icaltypes.c
+  CREATOR: eric 16 May 1999
+  
+  $Id$
+  $Locker$
+    
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icaltypes.c
+
+ ======================================================================*/
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "icaltypes.h"
+#include "icalerror.h"
+#include "icalmemory.h"
+#include <stdlib.h> /* for malloc and abs() */
+#include <errno.h> /* for errno */
+#include <string.h> /* for icalmemory_strdup */
+#include <assert.h>
+
+int snprintf(char *str, size_t n, char const *fmt, ...);
+
+#define TEMP_MAX 1024
+
+void*
+icalattachtype_get_data (struct icalattachtype* type);
+
+struct icalattachtype*
+icalattachtype_new()
+{
+    struct icalattachtype* v;
+
+    if ( ( v = (struct icalattachtype*)
+           malloc(sizeof(struct icalattachtype))) == 0) {
+        errno = ENOMEM;
+        return 0;
+    }
+
+    v->refcount = 1;
+
+    v->binary = 0;
+    v->owns_binary = 0;
+    v->base64 = 0;
+    //fprintf(stderr,"setting base 64 to 0   \n");
+    
+    v->owns_base64 = 0;
+
+    v->url = 0; 
+
+    return v;
+}
+
+
+void
+icalattachtype_free(struct icalattachtype* v)
+{
+    icalerror_check_arg( (v!=0),"v");
+    
+    v->refcount--;
+
+    if (v->refcount <= 0){
+        
+        if (v->base64 != 0 && v->owns_base64 != 0){
+        int val = v->base64 ;
+        if ( val < 255 ) {
+        fprintf(stderr,"Possible error in attachment processing (%d)\nPocssible solution: Remove attachment from file.\n",val  );
+        }
+            free(v->base64);
+        }
+
+        if (v->binary != 0 && v->owns_binary != 0){
+            free(v->binary);
+        }
+        
+        if (v->url != 0){
+            free(v->url);
+        }
+
+        free(v);
+    }
+}
+
+void  icalattachtype_add_reference(struct icalattachtype* v)
+{
+    icalerror_check_arg( (v!=0),"v");
+    v->refcount++;
+}
+
+void icalattachtype_set_url(struct icalattachtype* v, char* url)
+{
+    icalerror_check_arg( (v!=0),"v");
+
+    if (v->url != 0){
+        free (v->url);
+    }
+
+    v->url = icalmemory_strdup(url);
+
+    /* HACK This routine should do something if icalmemory_strdup returns NULL */
+
+}
+
+char* icalattachtype_get_url(struct icalattachtype* v)
+{
+    icalerror_check_arg( (v!=0),"v");
+    return v->url;
+}
+
+void icalattachtype_set_base64(struct icalattachtype* v, char* base64,
+                                int owns)
+{
+    //fprintf(stderr,"1setbase64 %d  \n", base64 );
+    icalerror_check_arg( (v!=0),"v");
+    //fprintf(stderr,"setbase64 %d  \n", base64 );
+    v->base64 = base64;
+    v->owns_base64 = !(owns != 0 );
+    
+}
+
+char* icalattachtype_get_base64(struct icalattachtype* v)
+{
+    icalerror_check_arg( (v!=0),"v");
+    return v->base64;
+}
+
+void icalattachtype_set_binary(struct icalattachtype* v, char* binary,
+                                int owns)
+{
+    icalerror_check_arg( (v!=0),"v");
+
+    v->binary = binary;
+    v->owns_binary = !(owns != 0 );
+
+}
+
+void* icalattachtype_get_binary(struct icalattachtype* v)
+{
+    icalerror_check_arg( (v!=0),"v");
+    return v->binary;
+}
+
+int icaltriggertype_is_null_trigger(struct icaltriggertype tr)
+{
+    if(icaltime_is_null_time(tr.time) && 
+       icaldurationtype_is_null_duration(tr.duration)){
+        return 1;
+    }
+
+    return 0;
+}
+    
+struct icaltriggertype icaltriggertype_from_string(const char* str)
+{
+
+    
+    struct icaltriggertype tr, null_tr;
+    icalerrorstate es;
+    icalerrorenum e;
+
+    tr.time= icaltime_null_time();
+    tr.duration = icaldurationtype_from_int(0);
+
+    null_tr = tr;
+
+    if(str == 0) goto error;
+
+    /* Surpress errors so a failure in icaltime_from_string() does not cause an abort */
+    es = icalerror_get_error_state(ICAL_MALFORMEDDATA_ERROR);
+    icalerror_set_error_state(ICAL_MALFORMEDDATA_ERROR,ICAL_ERROR_NONFATAL);
+    e = icalerrno;
+    icalerror_set_errno(ICAL_NO_ERROR);
+
+    tr.time = icaltime_from_string(str);
+
+    if (icaltime_is_null_time(tr.time)){
+
+        tr.duration = icaldurationtype_from_string(str);
+
+        if(icaldurationtype_as_int(tr.duration) == 0) goto error;
+    } 
+
+    icalerror_set_error_state(ICAL_MALFORMEDDATA_ERROR,es);
+    icalerror_set_errno(e);
+    return tr;
+
+ error:
+    icalerror_set_error_state(ICAL_MALFORMEDDATA_ERROR,es);
+    icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+    return null_tr;
+
+}
+
+
+struct icalreqstattype icalreqstattype_from_string(const char* str)
+{
+  const char *p1,*p2;
+  struct icalreqstattype stat;
+  int major, minor;
+
+  icalerror_check_arg((str != 0),"str");
+
+  stat.code = ICAL_UNKNOWN_STATUS;
+  stat.debug = 0; 
+   stat.desc = 0;
+
+  /* Get the status numbers */
+
+  sscanf(str, "%d.%d",&major, &minor);
+
+  if (major <= 0 || minor < 0){
+    icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+    return stat;
+  }
+
+  stat.code = icalenum_num_to_reqstat(major, minor);
+
+  if (stat.code == ICAL_UNKNOWN_STATUS){
+    icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+    return stat;
+  }
+  
+
+  p1 = strchr(str,';');
+
+  if (p1 == 0){
+/*    icalerror_set_errno(ICAL_BADARG_ERROR);*/
+    return stat;
+  }
+
+  /* Just ignore the second clause; it will be taken from inside the library 
+   */
+
+
+
+  p2 = strchr(p1+1,';');
+  if (p2 != 0 && *p2 != 0){
+    stat.debug = p2+1;
+  } 
+
+  return stat;
+  
+}
+
+const char* icalreqstattype_as_string(struct icalreqstattype stat)
+{
+  char *temp;
+
+  temp = (char*)icalmemory_tmp_buffer(TEMP_MAX);
+
+  icalerror_check_arg_rz((stat.code != ICAL_UNKNOWN_STATUS),"Status");
+  
+  if (stat.desc == 0){
+    stat.desc = icalenum_reqstat_desc(stat.code);
+  }
+  
+  if(stat.debug != 0){
+    snprintf(temp,TEMP_MAX,"%d.%d;%s;%s", icalenum_reqstat_major(stat.code),
+             icalenum_reqstat_minor(stat.code),
+             stat.desc, stat.debug);
+    
+  } else {
+    snprintf(temp,TEMP_MAX,"%d.%d;%s", icalenum_reqstat_major(stat.code),
+             icalenum_reqstat_minor(stat.code),
+             stat.desc);
+  }
+
+  return temp;
+}
diff --git a/libical/src/libical/icaltypes.h b/libical/src/libical/icaltypes.h
new file mode 100644
index 0000000..d61b9f3
--- a/dev/null
+++ b/libical/src/libical/icaltypes.h
@@ -0,0 +1,138 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icaltypes.h
+ CREATOR: eric 20 March 1999
+
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icaltypes.h
+
+======================================================================*/
+
+#ifndef ICALTYPES_H
+#define ICALTYPES_H
+
+#include <time.h>
+#include "icalenums.h"
+#include "icaltime.h"
+#include "icalduration.h"
+#include "icalperiod.h"
+
+
+/* This type type should probably be an opaque type... */
+struct icalattachtype
+{
+        void* binary;
+        int owns_binary; 
+
+        char* base64;
+        int owns_base64;
+
+        char* url;
+
+        int refcount; 
+
+};
+
+/* converts base64 to binary, fetches url and stores as binary, or
+   just returns data */
+
+struct icalattachtype* icalattachtype_new(void);
+void  icalattachtype_add_reference(struct icalattachtype* v);
+void icalattachtype_free(struct icalattachtype* v);
+
+void icalattachtype_set_url(struct icalattachtype* v, char* url);
+char* icalattachtype_get_url(struct icalattachtype* v);
+
+void icalattachtype_set_base64(struct icalattachtype* v, char* base64,
+                                int owns);
+char* icalattachtype_get_base64(struct icalattachtype* v);
+
+void icalattachtype_set_binary(struct icalattachtype* v, char* binary,
+                                int owns);
+void* icalattachtype_get_binary(struct icalattachtype* v);
+
+struct icalgeotype 
+{
+        float lat;
+        float lon;
+};
+
+
+struct icaldatetimeperiodtype 
+{
+        struct icaltimetype time;
+        struct icalperiodtype period;
+};
+
+
+struct icaltriggertype 
+{
+        struct icaltimetype time; 
+        struct icaldurationtype duration;
+};
+
+struct icaltriggertype icaltriggertype_from_string(const char* str);
+
+int icaltriggertype_is_null_trigger(struct icaltriggertype tr);
+
+/* struct icalreqstattype. This struct contains two string pointers,
+but don't try to free either of them. The "desc" string is a pointer
+to a static table inside the library.  Don't try to free it. The
+"debug" string is a pointer into the string that the called passed
+into to icalreqstattype_from_string. Don't try to free it either, and
+don't use it after the original string has been freed.
+
+BTW, you would get that original string from
+*icalproperty_get_requeststatus() or icalvalue_get_text(), when
+operating on a the value of a request_status property. */
+
+struct icalreqstattype {
+
+        icalrequeststatus code;
+        const char* desc;
+        const char* debug;
+};
+
+struct icalreqstattype icalreqstattype_from_string(const char* str);
+const char* icalreqstattype_as_string(struct icalreqstattype);
+
+
+
+struct icaltimezonephase {
+    const char* tzname;
+    int is_stdandard; /* 1 = standard tme, 0 = daylight savings time */
+    struct icaltimetype dtstart;
+    int offsetto;
+    int tzoffsetfrom;
+    const char* comment;
+    struct icaldatetimeperiodtype rdate;
+    const char* rrule;    
+};
+
+
+struct icaltimezonetype {
+    const char* tzid;
+    struct icaltimetype last_mod;
+    const char* tzurl;
+    
+    /* Array of phases. The end of the array is a phase with tzname == 0 */
+    struct icaltimezonephase *phases;
+};
+
+void icaltimezonetype_free(struct icaltimezonetype tzt);
+
+
+#endif /* !ICALTYPES_H */
diff --git a/libical/src/libical/icalvalue.c b/libical/src/libical/icalvalue.c
new file mode 100644
index 0000000..eb5476e
--- a/dev/null
+++ b/libical/src/libical/icalvalue.c
@@ -0,0 +1,1215 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+  FILE: icalvalue.c
+  CREATOR: eric 02 May 1999
+  
+  $Id$
+
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalvalue.c
+
+  Contributions from:
+     Graham Davison (g.m.davison@computer.org)
+
+
+======================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "icalerror.h"
+#include "icalmemory.h"
+#include "icalparser.h"
+#include "icalenums.h"
+#include "icalvalueimpl.h"
+
+#include <stdlib.h> /* for malloc */
+#include <stdio.h> /* for sprintf */
+#include <string.h> /* For memset, others */
+#include <stddef.h> /* For offsetof() macro */
+#include <errno.h>
+#include <time.h> /* for mktime */
+#include <stdlib.h> /* for atoi and atof */
+#include <limits.h> /* for SHRT_MAX */         
+
+int snprintf(char *str, size_t n, char const *fmt, ...);
+
+#if _MAC_OS_
+#include "icalmemory_strdup.h"
+#endif
+
+#define TMP_BUF_SIZE 1024
+
+void print_datetime_to_string(char* str,  struct icaltimetype *data);
+void print_date_to_string(char* str,  struct icaltimetype *data);
+void print_time_to_string(char* str,  struct icaltimetype *data);
+void print_recur_to_string(char* str,  struct icaltimetype *data);
+
+
+struct icalvalue_impl*  icalvalue_new_impl(icalvalue_kind kind){
+
+    struct icalvalue_impl* v;
+
+    if ( ( v = (struct icalvalue_impl*)
+           malloc(sizeof(struct icalvalue_impl))) == 0) {
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        return 0;
+    }
+    
+    strcpy(v->id,"val");
+    
+    v->kind = kind;
+    v->size = 0;
+    v->parent = 0;
+    v->x_value = 0;
+    memset(&(v->data),0,sizeof(v->data));
+    
+    return v;
+
+}
+
+
+
+icalvalue*
+icalvalue_new (icalvalue_kind kind)
+{
+    return (icalvalue*)icalvalue_new_impl(kind);
+}
+
+icalvalue* icalvalue_new_clone(icalvalue* value){
+
+    struct icalvalue_impl* new;
+    struct icalvalue_impl* old = (struct icalvalue_impl*)value;
+
+    new = icalvalue_new_impl(old->kind);
+
+    if (new == 0){
+        return 0;
+    }
+
+    
+    strcpy(new->id, old->id);
+    new->kind = old->kind;
+    new->size = old->size;
+
+    switch (new->kind){
+
+        /* The contents of the attach value may or may not be owned by the 
+         * library. */
+        case ICAL_ATTACH_VALUE: 
+        case ICAL_BINARY_VALUE: 
+        {
+            /* HACK ugh. I don't feel like impleenting this */
+        }
+
+        case ICAL_STRING_VALUE:
+        case ICAL_TEXT_VALUE:
+        case ICAL_CALADDRESS_VALUE:
+        case ICAL_URI_VALUE:
+        {
+            if (old->data.v_string != 0) { 
+                new->data.v_string=icalmemory_strdup(old->data.v_string);
+
+                if ( new->data.v_string == 0 ) {
+                    return 0;
+                        }           
+
+            }
+            break;
+        }
+        case ICAL_RECUR_VALUE:
+        {
+            if(old->data.v_recur != 0){
+                new->data.v_recur = malloc(sizeof(struct icalrecurrencetype));
+
+                if(new->data.v_recur == 0){
+                    return 0;
+                }
+
+                        memcpy(new->data.v_recur, old->data.v_recur,
+                                sizeof(struct icalrecurrencetype));
+            }
+            break;
+        }
+
+        default:
+        {
+            /* all of the other types are stored as values, not
+               pointers, so we can just copy the whole structure. */
+
+            new->data = old->data;
+        }
+    }
+
+    return new;
+}
+
+char* icalmemory_strdup_and_dequote(const char* str)
+{
+    const char* p;
+    char* out = (char*)malloc(sizeof(char) * strlen(str) +1);
+    char* pout;
+
+    if (out == 0){
+        return 0;
+    }
+
+    pout = out;
+
+    for (p = str; *p!=0; p++){
+        
+        if( *p == '\\')
+        {
+            p++;
+            switch(*p){
+                case 0:
+                {
+                    *pout = '\0';
+                    break;
+
+                }
+                case 'n':
+                {
+                    *pout = '\n';
+                    break;
+                }
+                case 'N':
+                {
+                    *pout = '\n';
+                    break;
+                }
+                case '\\':
+                case ',':
+                case ';':
+                {
+                    *pout = *p;
+                    break;
+                }
+                default:
+                {
+                    *pout = ' ';
+                        }       
+            }
+        } else {
+            *pout = *p;
+        }
+
+        pout++;
+        
+    }
+
+    *pout = '\0';
+
+    return out;
+}
+
+icalvalue* icalvalue_new_enum(icalvalue_kind kind, int x_type, const char* str)
+{
+    int e = icalproperty_string_to_enum(str);
+    struct icalvalue_impl *value; 
+
+    if(e != 0 && icalproperty_enum_belongs_to_property(
+                   icalproperty_value_kind_to_kind(kind),e)) {
+        
+        value = icalvalue_new_impl(kind);
+        value->data.v_enum = e;
+    } else {
+        /* Make it an X value */
+        value = icalvalue_new_impl(kind);
+        value->data.v_enum = x_type;
+        icalvalue_set_x(value,str);
+    }
+
+    return value;
+}
+
+
+icalvalue* icalvalue_new_from_string_with_error(icalvalue_kind kind,const char* str,icalproperty** error)
+{
+
+    struct icalvalue_impl *value = 0;
+    struct icalattachtype *attach = 0;
+    
+    icalerror_check_arg_rz(str!=0,"str");
+
+    if (error != 0){
+        *error = 0;
+    }
+
+    switch (kind){
+        
+    case ICAL_ATTACH_VALUE:
+        attach = icalattachtype_new();
+              value = icalvalue_new_attach( attach );
+        icalattachtype_free( attach );
+        icalattachtype_set_url( value->data.v_attach, str );
+        break;
+            case ICAL_BINARY_VALUE:
+    case ICAL_BOOLEAN_VALUE:
+        {
+            /* HACK */
+            value = 0;
+            
+            if (error != 0){
+                char temp[TMP_BUF_SIZE];
+                sprintf(temp,"%s Values are not implemented",
+                        icalparameter_kind_to_string(kind)); 
+                *error = icalproperty_vanew_xlicerror( 
+                                   temp, 
+                                   icalparameter_new_xlicerrortype( 
+                                        ICAL_XLICERRORTYPE_VALUEPARSEERROR), 
+                                   0); 
+            }
+            break;
+        }
+        
+
+    case ICAL_TRANSP_VALUE:
+        value = icalvalue_new_enum(kind, ICAL_TRANSP_X,str);
+        break;
+    case ICAL_METHOD_VALUE:
+        value = icalvalue_new_enum(kind, ICAL_METHOD_X,str);
+        break;
+    case ICAL_STATUS_VALUE:
+        value = icalvalue_new_enum(kind, ICAL_STATUS_X,str);
+        break;
+    case ICAL_ACTION_VALUE:
+        value = icalvalue_new_enum(kind, ICAL_ACTION_X,str);
+        break;
+    case ICAL_CLASS_VALUE:
+        value = icalvalue_new_enum(kind, ICAL_CLASS_X,str);
+        break;
+
+
+    case ICAL_INTEGER_VALUE:
+        {
+            value = icalvalue_new_integer(atoi(str));
+            break;
+        }
+
+    case ICAL_FLOAT_VALUE:
+        {
+            value = icalvalue_new_float((float )atof(str));
+            break;
+        }
+        
+    case ICAL_UTCOFFSET_VALUE:
+        {
+            value = icalparser_parse_value(kind,str,(icalcomponent*)0);
+            break;
+        }
+        
+    case ICAL_TEXT_VALUE:
+        {
+            char* dequoted_str = icalmemory_strdup_and_dequote(str);
+            value = icalvalue_new_text(dequoted_str);
+            free(dequoted_str);
+            break;
+        }
+        
+        
+    case ICAL_STRING_VALUE:
+        {
+            value = icalvalue_new_string(str);
+            break;
+        }
+        
+    case ICAL_CALADDRESS_VALUE:
+        {
+            value = icalvalue_new_caladdress(str);
+            break;
+        }
+        
+    case ICAL_URI_VALUE:
+        {
+            value = icalvalue_new_uri(str);
+            break;
+        }
+        
+        
+    case ICAL_GEO_VALUE:
+        {
+            value = 0;
+            /* HACK */
+            
+            if (error != 0){
+                char temp[TMP_BUF_SIZE];
+                sprintf(temp,"GEO Values are not implemented"); 
+                *error = icalproperty_vanew_xlicerror( 
+                                                      temp, 
+                                                      icalparameter_new_xlicerrortype( 
+                                                                                      ICAL_XLICERRORTYPE_VALUEPARSEERROR), 
+                                                      0); 
+            }
+            
+            /*icalerror_warn("Parsing GEO properties is unimplmeneted");*/
+            
+            break;
+        }
+        
+    case ICAL_RECUR_VALUE:
+        {
+            struct icalrecurrencetype rt;
+            rt = icalrecurrencetype_from_string(str);
+            if(rt.freq != ICAL_NO_RECURRENCE){
+                value = icalvalue_new_recur(rt);
+            }
+            break;
+        }
+        
+    case ICAL_DATE_VALUE:
+    case ICAL_DATETIME_VALUE:
+        {
+            struct icaltimetype tt;
+      
+            tt = icaltime_from_string(str);
+            if(!icaltime_is_null_time(tt)){
+                value = icalvalue_new_impl(kind);
+                value->data.v_time = tt;
+
+                icalvalue_reset_kind(value);
+            }
+            break;
+        }
+        
+    case ICAL_DATETIMEPERIOD_VALUE:
+        {
+            struct icaltimetype tt;
+            struct icalperiodtype p;
+            tt = icaltime_from_string(str);
+            p = icalperiodtype_from_string(str);
+            
+            if(!icaltime_is_null_time(tt)){
+                value = icalvalue_new_datetime(tt);
+            } else if (!icalperiodtype_is_null_period(p)){
+                value = icalvalue_new_period(p);
+            }            
+            
+            break;
+        }
+        
+    case ICAL_DURATION_VALUE:
+        {
+            struct icaldurationtype dur = icaldurationtype_from_string(str);
+            
+            if(icaldurationtype_is_null_duration(dur)){
+                value = 0;
+            } else {
+                value = icalvalue_new_duration(dur);
+            }
+            
+            break;
+        }
+        
+    case ICAL_PERIOD_VALUE:
+        {
+            struct icalperiodtype p;
+            p = icalperiodtype_from_string(str);  
+            
+            if(!icalperiodtype_is_null_period(p)){
+                value = icalvalue_new_period(p);
+            }
+            break; 
+        }
+        
+    case ICAL_TRIGGER_VALUE:
+        {
+            struct icaltriggertype tr = icaltriggertype_from_string(str);
+            if (!icaltriggertype_is_null_trigger(tr)){
+                value = icalvalue_new_trigger(tr);
+            }
+            break;
+        }
+        
+    case ICAL_REQUESTSTATUS_VALUE:
+        {
+            struct icalreqstattype rst = icalreqstattype_from_string(str);
+            if(rst.code != ICAL_UNKNOWN_STATUS){
+                value = icalvalue_new_requeststatus(rst);
+            }
+            break;
+
+        }
+    default:
+        {
+            
+            if (error != 0 ){
+                char temp[TMP_BUF_SIZE];
+                
+                snprintf(temp,TMP_BUF_SIZE,"Unknown type for \'%s\'",str);
+                            
+                *error = icalproperty_vanew_xlicerror( 
+                    temp, 
+                    icalparameter_new_xlicerrortype( 
+                        ICAL_XLICERRORTYPE_VALUEPARSEERROR), 
+                    0); 
+            }
+
+            icalerror_warn("icalvalue_new_from_string got an unknown value type");
+            value=0;
+        }
+    }
+
+
+    if (error != 0 && *error == 0 && value == 0){
+        char temp[TMP_BUF_SIZE];
+        
+        snprintf(temp,TMP_BUF_SIZE,"Failed to parse value: \'%s\'",str);
+        
+        *error = icalproperty_vanew_xlicerror( 
+            temp, 
+            icalparameter_new_xlicerrortype( 
+                ICAL_XLICERRORTYPE_VALUEPARSEERROR), 
+            0); 
+    }
+
+
+    return value;
+
+}
+
+icalvalue* icalvalue_new_from_string(icalvalue_kind kind,const char* str)
+{
+    return icalvalue_new_from_string_with_error(kind,str,(icalproperty*)0);
+}
+
+
+
+void
+icalvalue_free (icalvalue* value)
+{
+    struct icalvalue_impl* v = (struct icalvalue_impl*)value;
+
+    icalerror_check_arg_rv((value != 0),"value");
+
+#ifdef ICAL_FREE_ON_LIST_IS_ERROR
+    icalerror_assert( (v->parent ==0),"This value is still attached to a property");
+    
+#else
+    if(v->parent !=0){
+        return;
+    }
+#endif
+
+    if(v->x_value != 0){
+        free(v->x_value);
+    }
+
+    switch (v->kind){
+        case ICAL_ATTACH_VALUE:
+            icalattachtype_free( v->data.v_attach );
+            break;
+        case ICAL_BINARY_VALUE: {
+            /* HACK ugh. This will be tough to implement */
+        }
+        case ICAL_TEXT_VALUE:
+        case ICAL_CALADDRESS_VALUE:
+        case ICAL_URI_VALUE:
+        {
+            if (v->data.v_string != 0) { 
+                free((void*)v->data.v_string);
+                v->data.v_string = 0;
+            }
+            break;
+        }
+        case ICAL_RECUR_VALUE:
+        {
+            if(v->data.v_recur != 0){
+                free((void*)v->data.v_recur);
+                v->data.v_recur = 0;
+            }
+            break;
+        }
+
+        default:
+        {
+            /* Nothing to do */
+        }
+    }
+
+    v->kind = ICAL_NO_VALUE;
+    v->size = 0;
+    v->parent = 0;
+    memset(&(v->data),0,sizeof(v->data));
+    v->id[0] = 'X';
+    free(v);
+}
+
+int
+icalvalue_is_valid (icalvalue* value)
+{
+    /*struct icalvalue_impl* v = (struct icalvalue_impl*)value;*/
+    
+    if(value == 0){
+        return 0;
+    }
+    
+    return 1;
+}
+
+char* icalvalue_binary_as_ical_string(icalvalue* value) {
+
+    const char* data;
+    char* str;
+    icalerror_check_arg_rz( (value!=0),"value");
+
+    data = icalvalue_get_binary(value);
+
+    str = (char*)icalmemory_tmp_buffer(60);
+    sprintf(str,"icalvalue_binary_as_ical_string is not implemented yet");
+
+    return str;
+}
+
+#ifndef _WIN32
+#define MAX_INT_DIGITS 12 /* Enough for 2^32 + sign*/ 
+char* icalvalue_int_as_ical_string(icalvalue* value) {
+    
+    int data;
+    char* str = (char*)icalmemory_tmp_buffer(MAX_INT_DIGITS); 
+
+    icalerror_check_arg_rz( (value!=0),"value");
+
+    data = icalvalue_get_integer(value);
+        
+    snprintf(str,MAX_INT_DIGITS,"%d",data);
+
+    return str;
+}
+#else
+// snprintf not working on wintendo
+
+#define MAX_INT_DIGITS 32 /* Enough for 2^32 + sign*/ 
+char* icalvalue_int_as_ical_string(icalvalue* value) {
+    
+    int data;
+    char* str = (char*)icalmemory_tmp_buffer(MAX_INT_DIGITS); 
+
+    icalerror_check_arg_rz( (value!=0),"value");
+
+    data = icalvalue_get_integer(value);
+        
+    sprintf(str,"%d",data);
+
+    return str;
+}
+
+#endif
+char* icalvalue_utcoffset_as_ical_string(icalvalue* value)
+{    
+    int data,h,m,s;
+    char sign;
+    char* str = (char*)icalmemory_tmp_buffer(9);
+
+    icalerror_check_arg_rz( (value!=0),"value");
+
+    data = icalvalue_get_utcoffset(value);
+
+    if (abs(data) == data){
+        sign = '+';
+    } else {
+        sign = '-';
+    }
+
+    h = data/3600;
+    m = (data - (h*3600))/ 60;
+    s = (data - (h*3600) - (m*60));
+
+    sprintf(str,"%c%02d%02d%02d",sign,abs(h),abs(m),abs(s));
+
+    return str;
+}
+
+char* icalvalue_string_as_ical_string(icalvalue* value) {
+
+    const char* data;
+    char* str = 0;
+    icalerror_check_arg_rz( (value!=0),"value");
+
+    data = ((struct icalvalue_impl*)value)->data.v_string;
+
+    str = (char*)icalmemory_tmp_buffer(strlen(data)+1);   
+
+    strcpy(str,data);
+
+    return str;
+}
+
+
+char* icalvalue_recur_as_ical_string(icalvalue* value) 
+{
+    struct icalvalue_impl *impl = (struct icalvalue_impl*)value;
+    struct icalrecurrencetype *recur = impl->data.v_recur;
+
+    return icalrecurrencetype_as_string(recur);
+}
+
+char* icalvalue_text_as_ical_string(icalvalue* value) {
+
+    char *str;
+    char *str_p;
+    char *rtrn;
+    const char *p;
+    size_t buf_sz;
+    int line_length;
+
+    line_length = 0;
+
+    buf_sz = strlen(((struct icalvalue_impl*)value)->data.v_string)+1;
+
+    str_p = str = (char*)icalmemory_new_buffer(buf_sz);
+
+    if (str_p == 0){
+      return 0;
+    }
+
+    for(p=((struct icalvalue_impl*)value)->data.v_string; *p!=0; p++){
+
+        switch(*p){
+            case '\n': {
+                icalmemory_append_string(&str,&str_p,&buf_sz,"\\n");
+                line_length+=3;
+                break;
+            }
+
+            case '\t': {
+                icalmemory_append_string(&str,&str_p,&buf_sz,"\\t");
+                line_length+=3;
+                break;
+            }
+            case '\r': {
+                icalmemory_append_string(&str,&str_p,&buf_sz,"\\r");
+                line_length+=3;
+                break;
+            }
+            case '\b': {
+                icalmemory_append_string(&str,&str_p,&buf_sz,"\\b");
+                line_length+=3;
+                break;
+            }
+            case '\f': {
+                icalmemory_append_string(&str,&str_p,&buf_sz,"\\f");
+                line_length+=3;
+                break;
+            }
+
+            case ';':
+            case ',':{
+                icalmemory_append_char(&str,&str_p,&buf_sz,'\\');
+                icalmemory_append_char(&str,&str_p,&buf_sz,*p);
+                line_length+=3;
+                break;
+            }
+
+            default: {
+                icalmemory_append_char(&str,&str_p,&buf_sz,*p);
+                line_length++;
+            }
+        }
+
+        if (line_length > 65 && *p == ' '){
+            icalmemory_append_string(&str,&str_p,&buf_sz,"\n ");
+            line_length=0;
+        }
+
+
+        if (line_length > 75){
+            icalmemory_append_string(&str,&str_p,&buf_sz,"\n ");
+            line_length=0;
+        }
+
+    }
+
+    /* Assume the last character is not a '\0' and add one. We could
+       check *str_p != 0, but that would be an uninitialized memory
+       read. */
+
+
+    icalmemory_append_char(&str,&str_p,&buf_sz,'\0');
+
+    rtrn = icalmemory_tmp_copy(str);
+
+    icalmemory_free_buffer(str);
+
+    return rtrn;
+}
+
+
+char* icalvalue_attach_as_ical_string(icalvalue* value) {
+
+    struct icalattachtype *a;
+    char * str;
+
+    icalerror_check_arg_rz( (value!=0),"value");
+
+    a = icalvalue_get_attach(value);
+
+    if (a->binary != 0) {
+        return  icalvalue_binary_as_ical_string(value);
+    } else if (a->base64 != 0) {
+        str = (char*)icalmemory_tmp_buffer(strlen(a->base64)+1);
+        strcpy(str,a->base64);
+        return str;
+    } else if (a->url != 0){
+        icalvalue *v = icalvalue_new_text( a->url );
+              char *icalstring = icalvalue_string_as_ical_string(v);
+        icalvalue_free( v );
+        return icalstring;
+    } else {
+        icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+        return 0;
+    }
+}
+
+
+char* icalvalue_duration_as_ical_string(icalvalue* value) {
+
+    struct icaldurationtype data;
+
+    icalerror_check_arg_rz( (value!=0),"value");
+    data = icalvalue_get_duration(value);
+
+    return icaldurationtype_as_ical_string(data);
+}
+
+void print_time_to_string(char* str,  struct icaltimetype *data)
+{
+    char temp[20];
+
+    if (data->is_utc == 1){
+        sprintf(temp,"%02d%02d%02dZ",data->hour,data->minute,data->second);
+    } else {
+        sprintf(temp,"%02d%02d%02d",data->hour,data->minute,data->second);
+    }   
+
+    strcat(str,temp);
+}
+
+ 
+void print_date_to_string(char* str,  struct icaltimetype *data)
+{
+    char temp[20];
+
+    sprintf(temp,"%04d%02d%02d",data->year,data->month,data->day);
+
+    strcat(str,temp);
+}
+
+char* icalvalue_date_as_ical_string(icalvalue* value) {
+
+    struct icaltimetype data;
+    char* str;
+    icalerror_check_arg_rz( (value!=0),"value");
+    data = icalvalue_get_date(value);
+
+    str = (char*)icalmemory_tmp_buffer(9);
+ 
+    str[0] = 0;
+    print_date_to_string(str,&data);
+   
+    return str;
+}
+
+void print_datetime_to_string(char* str,  struct icaltimetype *data)
+{
+    print_date_to_string(str,data);
+    strcat(str,"T");
+    print_time_to_string(str,data);
+
+}
+
+const char* icalvalue_datetime_as_ical_string(icalvalue* value) {
+    
+    struct icaltimetype data;
+    char* str;
+    icalvalue_kind kind = icalvalue_isa(value);    
+
+    icalerror_check_arg_rz( (value!=0),"value");
+
+
+    if( !(kind == ICAL_DATE_VALUE || kind == ICAL_DATETIME_VALUE ))
+        {
+            icalerror_set_errno(ICAL_BADARG_ERROR);
+            return 0;
+        }
+
+    data = icalvalue_get_datetime(value);
+
+    str = (char*)icalmemory_tmp_buffer(20);
+ 
+    str[0] = 0;
+
+    print_datetime_to_string(str,&data);
+   
+    return str;
+
+}
+
+char* icalvalue_float_as_ical_string(icalvalue* value) {
+
+    float data;
+    char* str;
+    icalerror_check_arg_rz( (value!=0),"value");
+    data = icalvalue_get_float(value);
+
+    str = (char*)icalmemory_tmp_buffer(15);
+
+    sprintf(str,"%f",data);
+
+    return str;
+}
+
+char* icalvalue_geo_as_ical_string(icalvalue* value) {
+
+    struct icalgeotype data;
+    char* str;
+    icalerror_check_arg_rz( (value!=0),"value");
+
+    data = icalvalue_get_geo(value);
+
+    str = (char*)icalmemory_tmp_buffer(25);
+
+    sprintf(str,"%f;%f",data.lat,data.lon);
+
+    return str;
+}
+
+const char* icalvalue_datetimeperiod_as_ical_string(icalvalue* value) {
+    struct icaldatetimeperiodtype dtp = icalvalue_get_datetimeperiod(value);
+
+    icalerror_check_arg_rz( (value!=0),"value");
+
+    if(!icaltime_is_null_time(dtp.time)){
+        return icaltime_as_ical_string(dtp.time);
+    } else {
+        return icalperiodtype_as_ical_string(dtp.period);
+    }
+}
+
+const char* icalvalue_period_as_ical_string(icalvalue* value) {
+    struct icalperiodtype data;
+    icalerror_check_arg_rz( (value!=0),"value");
+    data = icalvalue_get_period(value);
+
+    return icalperiodtype_as_ical_string(data);
+
+}
+
+char* icalvalue_trigger_as_ical_string(icalvalue* value) {
+
+    struct icaltriggertype data;
+
+    icalerror_check_arg_rz( (value!=0),"value");
+    data = icalvalue_get_trigger(value);
+
+    if(!icaltime_is_null_time(data.time)){
+        return icaltime_as_ical_string(data.time);
+    } else {
+        return icaldurationtype_as_ical_string(data.duration);
+    }   
+
+}
+
+const char*
+icalvalue_as_ical_string (icalvalue* value)
+{
+    struct icalvalue_impl* v = (struct icalvalue_impl*)value;
+
+    v=v;
+
+    if(value == 0){
+        return 0;
+    }
+
+    switch (v->kind){
+
+    case ICAL_ATTACH_VALUE:
+        return icalvalue_attach_as_ical_string(value);
+        
+    case ICAL_BINARY_VALUE:
+        return icalvalue_binary_as_ical_string(value);
+        
+    case ICAL_BOOLEAN_VALUE:
+    case ICAL_INTEGER_VALUE:
+        return icalvalue_int_as_ical_string(value);                  
+        
+    case ICAL_UTCOFFSET_VALUE:
+        return icalvalue_utcoffset_as_ical_string(value);                  
+        
+    case ICAL_TEXT_VALUE:
+        return icalvalue_text_as_ical_string(value);
+        
+    case ICAL_STRING_VALUE:
+    case ICAL_URI_VALUE:
+    case ICAL_CALADDRESS_VALUE:
+        return icalvalue_string_as_ical_string(value);
+        
+    case ICAL_DATE_VALUE:
+        return icalvalue_date_as_ical_string(value);
+    case ICAL_DATETIME_VALUE:
+        return icalvalue_datetime_as_ical_string(value);
+    case ICAL_DURATION_VALUE:
+        return icalvalue_duration_as_ical_string(value);
+        
+    case ICAL_PERIOD_VALUE:
+        return icalvalue_period_as_ical_string(value);
+    case ICAL_DATETIMEPERIOD_VALUE:
+        return icalvalue_datetimeperiod_as_ical_string(value);
+        
+    case ICAL_FLOAT_VALUE:
+        return icalvalue_float_as_ical_string(value);
+        
+    case ICAL_GEO_VALUE:
+        return icalvalue_geo_as_ical_string(value);
+        
+    case ICAL_RECUR_VALUE:
+        return icalvalue_recur_as_ical_string(value);
+        
+    case ICAL_TRIGGER_VALUE:
+        return icalvalue_trigger_as_ical_string(value);
+
+    case ICAL_REQUESTSTATUS_VALUE:
+        return icalreqstattype_as_string(v->data.v_requeststatus);
+        
+    case ICAL_ACTION_VALUE:
+    case ICAL_METHOD_VALUE:
+    case ICAL_STATUS_VALUE:
+    case ICAL_TRANSP_VALUE:
+    case ICAL_CLASS_VALUE:
+        if(v->x_value !=0){
+            return icalmemory_tmp_copy(v->x_value);
+        }
+
+        return icalproperty_enum_to_string(v->data.v_enum);
+        
+    case ICAL_X_VALUE: 
+        return icalmemory_tmp_copy(v->x_value);
+
+    case ICAL_NO_VALUE:
+    default:
+        {
+            return 0;
+        }
+    }
+}
+
+
+icalvalue_kind
+icalvalue_isa (icalvalue* value)
+{
+    struct icalvalue_impl* v = (struct icalvalue_impl*)value;
+
+    if(value == 0){
+        return ICAL_NO_VALUE;
+    }
+
+    return v->kind;
+}
+
+
+int
+icalvalue_isa_value (void* value)
+{
+    struct icalvalue_impl *impl = (struct icalvalue_impl *)value;
+
+    icalerror_check_arg_rz( (value!=0), "value");
+
+    if (strcmp(impl->id,"val") == 0) {
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+
+int icalvalue_is_time(icalvalue* a) {
+    icalvalue_kind kind = icalvalue_isa(a);
+
+    if(kind == ICAL_DATETIME_VALUE ||
+       kind == ICAL_DATE_VALUE ){
+        return 1;
+    }
+
+    return 0;
+
+}
+
+icalparameter_xliccomparetype
+icalvalue_compare(icalvalue* a, icalvalue *b)
+{
+    struct icalvalue_impl *impla = (struct icalvalue_impl *)a;
+    struct icalvalue_impl *implb = (struct icalvalue_impl *)b;
+
+    icalerror_check_arg_rz( (a!=0), "a");
+    icalerror_check_arg_rz( (b!=0), "b");
+
+    /* Not the same type; they can only be unequal */
+    if( ! (icalvalue_is_time(a) && icalvalue_is_time(b)) &&
+        icalvalue_isa(a) != icalvalue_isa(b)){
+        return ICAL_XLICCOMPARETYPE_NOTEQUAL;
+    }
+
+    switch (icalvalue_isa(a)){
+
+        case ICAL_ATTACH_VALUE:
+        case ICAL_BINARY_VALUE:
+
+        case ICAL_BOOLEAN_VALUE:
+        {
+            if (icalvalue_get_boolean(a) == icalvalue_get_boolean(b)){
+                return ICAL_XLICCOMPARETYPE_EQUAL;
+            } else {
+                return ICAL_XLICCOMPARETYPE_NOTEQUAL;
+            }
+        }
+
+        case ICAL_FLOAT_VALUE:
+        {
+            if (impla->data.v_float > implb->data.v_float){
+                return ICAL_XLICCOMPARETYPE_GREATER;
+            } else if (impla->data.v_float < implb->data.v_float){
+                return ICAL_XLICCOMPARETYPE_LESS;
+            } else {
+                return ICAL_XLICCOMPARETYPE_EQUAL;
+            }
+        }
+
+        case ICAL_INTEGER_VALUE:
+        case ICAL_UTCOFFSET_VALUE:
+        {
+            if (impla->data.v_int > implb->data.v_int){
+                return ICAL_XLICCOMPARETYPE_GREATER;
+            } else if (impla->data.v_int < implb->data.v_int){
+                return ICAL_XLICCOMPARETYPE_LESS;
+            } else {
+                return ICAL_XLICCOMPARETYPE_EQUAL;
+            }
+        }
+
+        case ICAL_DURATION_VALUE: 
+        {
+            int a = icaldurationtype_as_int(impla->data.v_duration);
+            int b = icaldurationtype_as_int(implb->data.v_duration);
+
+            if (a > b){
+                return ICAL_XLICCOMPARETYPE_GREATER;
+            } else if (a < b){
+                return ICAL_XLICCOMPARETYPE_LESS;
+            } else {
+                return ICAL_XLICCOMPARETYPE_EQUAL;
+            }
+                }    
+
+
+        case ICAL_TEXT_VALUE:
+        case ICAL_URI_VALUE:
+        case ICAL_CALADDRESS_VALUE:
+        case ICAL_TRIGGER_VALUE:
+        case ICAL_DATE_VALUE:
+        case ICAL_DATETIME_VALUE:
+        case ICAL_DATETIMEPERIOD_VALUE:
+        {
+            int r;
+
+            r =  strcmp(icalvalue_as_ical_string(a),
+                          icalvalue_as_ical_string(b));
+
+                    if (r > 0) { 
+                return ICAL_XLICCOMPARETYPE_GREATER;
+            } else if (r < 0){
+                return ICAL_XLICCOMPARETYPE_LESS;
+            } else {
+                return ICAL_XLICCOMPARETYPE_EQUAL;
+            }
+
+                
+        }
+
+        case ICAL_METHOD_VALUE:
+        {
+            if (icalvalue_get_method(a) == icalvalue_get_method(b)){
+                return ICAL_XLICCOMPARETYPE_EQUAL;
+            } else {
+                return ICAL_XLICCOMPARETYPE_NOTEQUAL;
+            }
+
+        }
+
+        case ICAL_STATUS_VALUE:
+        {
+            if (icalvalue_get_status(a) == icalvalue_get_status(b)){
+                return ICAL_XLICCOMPARETYPE_EQUAL;
+            } else {
+                return ICAL_XLICCOMPARETYPE_NOTEQUAL;
+            }
+
+        }
+
+        case ICAL_PERIOD_VALUE:
+        case ICAL_GEO_VALUE:
+        case ICAL_RECUR_VALUE:
+        case ICAL_NO_VALUE:
+        default:
+        {
+            icalerror_warn("Comparison not implemented for value type");
+            return ICAL_XLICCOMPARETYPE_REGEX+1; /* HACK */
+        }
+    }   
+
+}
+
+/* Examine the value and possiby chage the kind to agree with the value */
+void icalvalue_reset_kind(icalvalue* value)
+{
+    struct icalvalue_impl* impl = (struct icalvalue_impl*)value;
+
+    if( (impl->kind==ICAL_DATETIME_VALUE || impl->kind==ICAL_DATE_VALUE )&&
+        !icaltime_is_null_time(impl->data.v_time) ) {
+        
+        if( impl->data.v_time.is_date == 1){
+            impl->kind = ICAL_DATE_VALUE;
+        } else {
+            impl->kind = ICAL_DATETIME_VALUE;
+        }
+    }
+       
+}
+
+void icalvalue_set_parent(icalvalue* value,
+                             icalproperty* property)
+{
+    struct icalvalue_impl* v = (struct icalvalue_impl*)value;
+
+    v->parent = property;
+
+}
+
+icalproperty* icalvalue_get_parent(icalvalue* value)
+{
+    struct icalvalue_impl* v = (struct icalvalue_impl*)value;
+
+
+    return v->parent;
+}
+
+
+
+/* The remaining interfaces are 'new', 'set' and 'get' for each of the value
+   types */
+
+
+/* Everything below this line is machine generated. Do not edit. */
diff --git a/libical/src/libical/icalvalue.h b/libical/src/libical/icalvalue.h
new file mode 100644
index 0000000..6983c23
--- a/dev/null
+++ b/libical/src/libical/icalvalue.h
@@ -0,0 +1,85 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+  FILE: icalvalue.h
+  CREATOR: eric 20 March 1999
+
+
+  $Id$
+  $Locker$
+
+  
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalvalue.h
+
+  ======================================================================*/
+
+#ifndef ICALVALUE_H
+#define ICALVALUE_H
+
+#include <time.h>
+#include "icalenums.h"
+#include "icaltypes.h"
+#include "icalrecur.h"
+#include "icalduration.h"
+#include "icalperiod.h"
+#include "icalderivedproperty.h" /* For icalproperty_method, etc. */
+#include "icalderivedparameter.h"
+#include "icalderivedvalue.h"
+                          
+/* Defined in icalderivedvalue.h */
+/*typedef void icalvalue;*/
+
+icalvalue* icalvalue_new(icalvalue_kind kind);
+
+icalvalue* icalvalue_new_clone(icalvalue* value);
+
+icalvalue* icalvalue_new_from_string(icalvalue_kind kind, const char* str);
+
+void icalvalue_free(icalvalue* value);
+
+int icalvalue_is_valid(icalvalue* value);
+
+const char* icalvalue_as_ical_string(icalvalue* value);
+
+icalvalue_kind icalvalue_isa(icalvalue* value);
+
+int icalvalue_isa_value(void*);
+
+icalparameter_xliccomparetype icalvalue_compare(icalvalue* a, icalvalue *b);
+
+
+/* Special, non autogenerated value accessors */
+
+icalvalue* icalvalue_new_recur (struct icalrecurrencetype v);
+void icalvalue_set_recur(icalvalue* value, struct icalrecurrencetype v);
+struct icalrecurrencetype icalvalue_get_recur(icalvalue* value);
+
+icalvalue* icalvalue_new_trigger (struct icaltriggertype v);
+void icalvalue_set_trigger(icalvalue* value, struct icaltriggertype v);
+struct icaltriggertype icalvalue_get_trigger(icalvalue* value);
+
+icalvalue* icalvalue_new_datetimeperiod (struct icaldatetimeperiodtype v);
+void icalvalue_set_datetimeperiod(icalvalue* value, 
+                                  struct icaldatetimeperiodtype v);
+struct icaldatetimeperiodtype icalvalue_get_datetimeperiod(icalvalue* value);
+
+/* Convert enumerations */
+
+icalvalue_kind icalvalue_string_to_kind(const char* str);
+const char* icalvalue_kind_to_string(icalvalue_kind kind);
+
+
+#endif /*ICALVALUE_H*/
diff --git a/libical/src/libical/icalvalueimpl.h b/libical/src/libical/icalvalueimpl.h
new file mode 100644
index 0000000..116535d
--- a/dev/null
+++ b/libical/src/libical/icalvalueimpl.h
@@ -0,0 +1,93 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+  FILE: icalvalue.c
+  CREATOR: eric 02 May 1999
+  
+  $Id$
+
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalvalue.c
+
+  Contributions from:
+     Graham Davison (g.m.davison@computer.org)
+
+
+======================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#ifndef ICALVALUEIMPL_H
+#define ICALVALUEIMPL_H
+
+#include "icalenums.h"
+
+
+struct icalvalue_impl {
+    icalvalue_kind kind; /*this is the kind that is visible from the outside*/
+
+    char id[5];
+    int size;
+    icalproperty* parent;
+    const char* x_value;
+
+    union data {
+                struct icalattachtype *v_attach;        
+        /* void *v_binary; */ /* use v_attach */
+        const char *v_string;
+        /*char *v_text;*/
+        /*char *v_caladdress;*/
+        /*char *v_uri;*/
+        float v_float;
+        int v_int;
+        /*int v_boolean;*/
+        /*int v_integer;*/
+        struct icaldurationtype v_duration;
+        /*int v_utcoffset;*/
+        
+        struct icalperiodtype v_period;
+        /*struct icalperiodtype v_datetimeperiod;*/
+        struct icalgeotype v_geo;
+        /*time_t v_time;*/
+        struct icaltimetype v_time;
+        /*struct icaltimetype v_date;*/
+        /*struct icaltimetype v_datetime;*/
+        /*struct icaltimetype v_datetimedate;*/
+        
+        struct icalreqstattype v_requeststatus;
+
+        /* struct icalrecurrencetype was once included
+           directly ( not referenced ) in this union, but it
+           contributes 2000 bytes to every value, so now it is
+           a reference*/
+        
+        struct icalrecurrencetype *v_recur;
+        struct icaltriggertype v_trigger;
+
+        int v_enum;
+        /* v_enum takes care of several enumerated types including: 
+        icalproperty_method v_method;
+        icalproperty_status v_status;
+        icalproperty_action v_action;
+        icalproperty_class v_class;
+        icalproperty_transp v_transp;
+        */
+
+    } data;
+};
+
+#endif
diff --git a/libical/src/libical/icalversion.h b/libical/src/libical/icalversion.h
new file mode 100644
index 0000000..beae8e0
--- a/dev/null
+++ b/libical/src/libical/icalversion.h
@@ -0,0 +1,7 @@
+#ifndef ICAL_VERSION_H
+#define ICAL_VERSION_H
+
+#define ICAL_PACKAGE "libical"
+#define ICAL_VERSION "0.23"
+
+#endif
diff --git a/libical/src/libical/icalversion.h.in b/libical/src/libical/icalversion.h.in
new file mode 100644
index 0000000..5d21369
--- a/dev/null
+++ b/libical/src/libical/icalversion.h.in
@@ -0,0 +1,7 @@
+#ifndef ICAL_VERSION_H
+#define ICAL_VERSION_H
+
+#define ICAL_PACKAGE "@PACKAGE@"
+#define ICAL_VERSION "@VERSION@"
+
+#endif
diff --git a/libical/src/libical/icalyacc.c b/libical/src/libical/icalyacc.c
new file mode 100644
index 0000000..d0b9a10
--- a/dev/null
+++ b/libical/src/libical/icalyacc.c
@@ -0,0 +1,1447 @@
+
+/*  A Bison parser, made from ../../../../libical/src/libical/icalyacc.y
+    by GNU Bison version 1.28  */
+
+#define YYBISON 1  /* Identify Bison output.  */
+
+#define yyparse ical_yyparse
+#define yylex ical_yylex
+#define yyerror ical_yyerror
+#define yylval ical_yylval
+#define yychar ical_yychar
+#define yydebug ical_yydebug
+#define yynerrs ical_yynerrs
+        #define         DIGITS257
+        #define         INTNUMBER258
+        #define         FLOATNUMBER259
+        #define         STRING260
+        #define         EOL261
+        #define         EQUALS262
+        #define         CHARACTER263
+        #define         COLON264
+        #define         COMMA265
+        #define         SEMICOLON266
+        #define         MINUS267
+        #define         TIMESEPERATOR268
+        #define         TRUE269
+        #define         FALSE270
+        #define         FREQ271
+        #define         BYDAY272
+        #define         BYHOUR273
+        #define         BYMINUTE274
+        #define         BYMONTH275
+        #define         BYMONTHDAY276
+        #define         BYSECOND277
+        #define         BYSETPOS278
+        #define         BYWEEKNO279
+        #define         BYYEARDAY280
+        #define         DAILY281
+        #define         MINUTELY282
+        #define         MONTHLY283
+        #define         SECONDLY284
+        #define         WEEKLY285
+        #define         HOURLY286
+        #define         YEARLY287
+        #define         INTERVAL288
+        #define         COUNT289
+        #define         UNTIL290
+        #define         WKST291
+        #define         MO292
+        #define         SA293
+        #define         SU294
+        #define         TU295
+        #define         WE296
+        #define         TH297
+        #define         FR298
+        #define         BIT8299
+        #define         ACCEPTED300
+        #define         ADD301
+        #define         AUDIO302
+        #define         BASE64303
+        #define         BINARY304
+        #define         BOOLEAN305
+        #define         BUSY306
+        #define         BUSYTENTATIVE307
+        #define         BUSYUNAVAILABLE308
+        #define         CALADDRESS309
+        #define         CANCEL310
+        #define         CANCELLED311
+        #define         CHAIR312
+        #define         CHILD313
+        #define         COMPLETED314
+        #define         CONFIDENTIAL315
+        #define         CONFIRMED316
+        #define         COUNTER317
+        #define         DATE318
+        #define         DATETIME319
+        #define         DECLINECOUNTER320
+        #define         DECLINED321
+        #define         DELEGATED322
+        #define         DISPLAY323
+        #define         DRAFT324
+        #define         DURATION325
+        #define         EMAIL326
+        #define         END327
+        #define         FINAL328
+        #define         FLOAT329
+        #define         FREE330
+        #define         GREGORIAN331
+        #define         GROUP332
+        #define         INDIVIDUAL333
+        #define         INPROCESS334
+        #define         INTEGER335
+        #define         NEEDSACTION336
+        #define         NONPARTICIPANT337
+        #define         OPAQUE338
+        #define         OPTPARTICIPANT339
+        #define         PARENT340
+        #define         PERIOD341
+        #define         PRIVATE342
+        #define         PROCEDURE343
+        #define         PUBLIC344
+        #define         PUBLISH345
+        #define         RECUR346
+        #define         REFRESH347
+        #define         REPLY348
+        #define         REQPARTICIPANT349
+        #define         REQUEST350
+        #define         RESOURCE351
+        #define         ROOM352
+        #define         SIBLING353
+        #define         START354
+        #define         TENTATIVE355
+        #define         TEXT356
+        #define         THISANDFUTURE357
+        #define         THISANDPRIOR358
+        #define         TIME359
+        #define         TRANSPAENT360
+        #define         UNKNOWN361
+        #define         UTCOFFSET362
+        #define         XNAME363
+        #define         ALTREP364
+        #define         CN365
+        #define         CUTYPE366
+        #define         DAYLIGHT367
+        #define         DIR368
+        #define         ENCODING369
+        #define         EVENT370
+        #define         FBTYPE371
+        #define         FMTTYPE372
+        #define         LANGUAGE373
+        #define         MEMBER374
+        #define         PARTSTAT375
+        #define         RANGE376
+        #define         RELATED377
+        #define         RELTYPE378
+        #define         ROLE379
+        #define         RSVP380
+        #define         SENTBY381
+        #define         STANDARD382
+        #define         URI383
+        #define         TIME_CHAR384
+        #define         UTC_CHAR385
+
+#line 1 "../../../../libical/src/libical/icalyacc.y"
+
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: icalitip.y
+  CREATOR: eric 10 June 1999
+  
+  DESCRIPTION:
+  
+  $Id$
+  $Locker$
+
+  (C) COPYRIGHT 1999 Eric Busboom 
+  http://www.softwarestudio.org
+
+  The contents of this file are subject to the Mozilla Public License
+  Version 1.0 (the "License"); you may not use this file except in
+  compliance with the License. You may obtain a copy of the License at
+  http://www.mozilla.org/MPL/
+ 
+  Software distributed under the License is distributed on an "AS IS"
+  basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+  the License for the specific language governing rights and
+  limitations under the License.
+
+  The original author is Eric Busboom
+  The original code is icalitip.y
+
+
+
+  =======================================================================*/
+
+#include <stdlib.h>
+#include <string.h> /* for strdup() */
+#include "icalparser.h"
+#include "pvl.h"
+
+icalvalue *icalparser_yy_value; /* Current Value */
+
+void ical_yyerror(char* s);
+void icalparser_clear_flex_input();  
+int ical_yy_lex(void);
+
+/* Globals for UTCOFFSET values */
+int utc; 
+int utc_b; 
+int utcsign;
+
+/* Globals for DURATION values */
+struct icaldurationtype duration;
+
+/* Globals for TRIGGER values */
+struct icaltriggertype trigger;
+
+void copy_list(short* array, size_t size);
+void add_prop(icalproperty_kind);
+void icalparser_fill_date(struct tm* t, char* dstr);
+void icalparser_fill_time(struct tm* t, char* tstr);
+void set_value_type(icalvalue_kind kind);
+void set_parser_value_state();
+struct icaltimetype fill_datetime(char* d, char* t);
+void ical_yy_error(char *s); /* Don't know why I need this.... */
+int yylex(void); /* Or this. */
+
+
+
+/* Set the state of the lexer so it will interpret values ( iCAL
+   VALUEs, that is, ) correctly. */
+
+
+#line 71 "../../../../libical/src/libical/icalyacc.y"
+typedef union {
+        float v_float;
+        int   v_int;
+        char* v_string;
+} YYSTYPE;
+#ifndef YYDEBUG
+#define YYDEBUG 1
+#endif
+
+#include <stdio.h>
+
+#ifndef __cplusplus
+#ifndef __STDC__
+#define const
+#endif
+#endif
+
+
+
+        #define         YYFINAL         51
+        #define         YYFLAG  -32768
+        #define         YYNTBASE141
+
+#define YYTRANSLATE(x) ((unsigned)(x) <= 385 ? yytranslate[x] : 158)
+
+static const short yytranslate[] = {     0,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,   137,     2,   138,     2,   140,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,   136,     2,     2,
+     2,   133,     2,     2,     2,     2,   134,     2,     2,   139,
+     2,     2,   135,     2,     2,     2,   132,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+     2,     2,     2,     2,     2,     1,     3,     4,     5,     6,
+     7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
+    17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
+    27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
+    37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
+    47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
+    57,    58,    59,    60,    61,    62,    63,    64,    65,    66,
+    67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
+    77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
+    87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
+    97,    98,    99,   100,   101,   102,   103,   104,   105,   106,
+   107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
+   117,   118,   119,   120,   121,   122,   123,   124,   125,   126,
+   127,   128,   129,   130,   131
+};
+
+#if YYDEBUG != 0
+static const short yyprhs[] = {     0,
+     0,     2,     4,     6,     8,    10,    12,    14,    15,    17,
+    18,    20,    25,    27,    30,    33,    36,    39,    42,    45,
+    49,    52,    56,    59,    62,    63,    65,    67,    71,    75,
+    79,    89,    96,    97,    99,   101,   105
+};
+
+static const short yyrhs[] = {   142,
+     0,   145,     0,   154,     0,   155,     0,   157,     0,     1,
+     0,     3,     0,     0,   131,     0,     0,   131,     0,     3,
+   130,     3,   143,     0,   152,     0,   152,   148,     0,     3,
+   132,     0,   130,   149,     0,   130,   150,     0,   130,   151,
+     0,     3,   133,     0,     3,   133,   150,     0,     3,   134,
+     0,     3,   134,   151,     0,     3,   135,     0,     3,   136,
+     0,     0,   137,     0,   138,     0,   153,   139,   146,     0,
+   153,   139,   148,     0,   153,   139,   147,     0,     3,   130,
+     3,   143,   140,     3,   130,     3,   144,     0,     3,   130,
+     3,   143,   140,   154,     0,     0,   137,     0,   138,     0,
+   156,     4,     4,     0,   156,     4,     4,     4,     0
+};
+
+#endif
+
+#if YYDEBUG != 0
+static const short yyrline[] = { 0,
+   177,   179,   180,   181,   182,   183,   190,   205,   207,   210,
+   212,   214,   230,   231,   233,   238,   241,   244,   248,   252,
+   257,   261,   266,   271,   276,   280,   284,   289,   294,   299,
+   308,   329,   358,   364,   365,   367,   373
+};
+#endif
+
+
+#if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
+
+static const char * const yytname[] = {   "$","error","$undefined.","DIGITS",
+"INTNUMBER","FLOATNUMBER","STRING","EOL","EQUALS","CHARACTER","COLON","COMMA",
+"SEMICOLON","MINUS","TIMESEPERATOR","TRUE","FALSE","FREQ","BYDAY","BYHOUR","BYMINUTE",
+"BYMONTH","BYMONTHDAY","BYSECOND","BYSETPOS","BYWEEKNO","BYYEARDAY","DAILY",
+"MINUTELY","MONTHLY","SECONDLY","WEEKLY","HOURLY","YEARLY","INTERVAL","COUNT",
+"UNTIL","WKST","MO","SA","SU","TU","WE","TH","FR","BIT8","ACCEPTED","ADD","AUDIO",
+"BASE64","BINARY","BOOLEAN","BUSY","BUSYTENTATIVE","BUSYUNAVAILABLE","CALADDRESS",
+"CANCEL","CANCELLED","CHAIR","CHILD","COMPLETED","CONFIDENTIAL","CONFIRMED",
+"COUNTER","DATE","DATETIME","DECLINECOUNTER","DECLINED","DELEGATED","DISPLAY",
+"DRAFT","DURATION","EMAIL","END","FINAL","FLOAT","FREE","GREGORIAN","GROUP",
+"INDIVIDUAL","INPROCESS","INTEGER","NEEDSACTION","NONPARTICIPANT","OPAQUE","OPTPARTICIPANT",
+"PARENT","PERIOD","PRIVATE","PROCEDURE","PUBLIC","PUBLISH","RECUR","REFRESH",
+"REPLY","REQPARTICIPANT","REQUEST","RESOURCE","ROOM","SIBLING","START","TENTATIVE",
+"TEXT","THISANDFUTURE","THISANDPRIOR","TIME","TRANSPAENT","UNKNOWN","UTCOFFSET",
+"XNAME","ALTREP","CN","CUTYPE","DAYLIGHT","DIR","ENCODING","EVENT","FBTYPE",
+"FMTTYPE","LANGUAGE","MEMBER","PARTSTAT","RANGE","RELATED","RELTYPE","ROLE",
+"RSVP","SENTBY","STANDARD","URI","TIME_CHAR","UTC_CHAR","'W'","'H'","'M'","'S'",
+"'D'","'+'","'-'","'P'","'/'","value","date_value","utc_char","utc_char_b","datetime_value",
+"dur_date","dur_week","dur_time","dur_hour","dur_minute","dur_second","dur_day",
+"dur_prefix","duration_value","period_value","plusminus","utcoffset_value", NULL
+};
+#endif
+
+static const short yyr1[] = {     0,
+   141,   141,   141,   141,   141,   141,   142,   143,   143,   144,
+   144,   145,   146,   146,   147,   148,   148,   148,   149,   149,
+   150,   150,   151,   152,   153,   153,   153,   154,   154,   154,
+   155,   155,    -1,   156,   156,   157,   157
+};
+
+static const short yyr2[] = {     0,
+     1,     1,     1,     1,     1,     1,     1,     0,     1,     0,
+     1,     4,     1,     2,     2,     2,     2,     2,     2,     3,
+     2,     3,     2,     2,     0,     1,     1,     3,     3,     3,
+     9,     6,     0,     1,     1,     3,     4
+};
+
+static const short yydefact[] = {     0,
+     6,     7,    26,    27,     1,     2,     0,     3,     4,     0,
+     5,     0,     0,     0,     8,     0,     0,    28,    30,    29,
+    13,    36,     9,    12,    15,    24,     0,    16,    17,    18,
+    14,    37,    25,    19,    21,    23,     0,    26,    27,    32,
+     0,    20,     0,    22,     0,    10,    11,    31,     0,     0,
+     0
+};
+
+static const short yydefgoto[] = {    49,
+     5,    24,    48,     6,    18,    19,    20,    28,    29,    30,
+    21,     7,     8,     9,    10,    11
+};
+
+static const short yypact[] = {    -1,
+-32768,  -126,     7,     8,-32768,-32768,  -133,-32768,-32768,     9,
+-32768,    11,    -2,    12,  -116,  -129,    14,-32768,-32768,-32768,
+  -112,    15,-32768,  -120,-32768,-32768,  -125,-32768,-32768,-32768,
+-32768,-32768,     2,    18,    19,-32768,  -107,-32768,-32768,-32768,
+  -110,-32768,  -109,-32768,    22,  -104,-32768,-32768,    28,    29,
+-32768
+};
+
+static const short yypgoto[] = {-32768,
+-32768,-32768,-32768,-32768,-32768,-32768,    10,-32768,    -4,    -3,
+-32768,-32768,     0,-32768,-32768,-32768
+};
+
+
+        #define         YYLAST  140
+
+
+static const short yytable[] = {     1,
+    16,     2,    25,    12,    37,    13,    26,    34,    35,    36,
+   -34,   -35,    14,    15,    23,    22,    27,    17,    32,    33,
+    41,    43,    45,    35,    46,    36,    47,    50,    51,    42,
+    31,    44,    40,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+     0,     0,     0,     0,     0,     0,     0,    17,     0,     0,
+     0,     0,     0,     0,     0,     3,     4,   -25,    38,    39
+};
+
+static const short yycheck[] = {     1,
+     3,     3,   132,   130,     3,   139,   136,   133,   134,   135,
+     4,     4,     4,     3,   131,     4,     3,   130,     4,   140,
+     3,     3,   130,   134,     3,   135,   131,     0,     0,    34,
+    21,    35,    33,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,    -1,    -1,   130,    -1,    -1,
+    -1,    -1,    -1,    -1,    -1,   137,   138,   139,   137,   138
+};
+/* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
+#line 3 "/usr/share/bison.simple"
+/* This file comes from bison-1.28.  */
+
+/* Skeleton output parser for bison,
+   Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+/* As a special exception, when this file is copied by Bison into a
+   Bison output file, you may use that output file without restriction.
+   This special exception was added by the Free Software Foundation
+   in version 1.24 of Bison.  */
+
+/* This is the parser code that is written into each bison parser
+  when the %semantic_parser declaration is not specified in the grammar.
+  It was written by Richard Stallman by simplifying the hairy parser
+  used when %semantic_parser is specified.  */
+
+#ifndef YYPARSE_RETURN_TYPE
+#define YYPARSE_RETURN_TYPE int
+#endif
+
+
+#ifndef YYSTACK_USE_ALLOCA
+#ifdef alloca
+#define YYSTACK_USE_ALLOCA
+#else /* alloca not defined */
+#ifdef __GNUC__
+#define YYSTACK_USE_ALLOCA
+#define alloca __builtin_alloca
+#else /* not GNU C.  */
+#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))
+#define YYSTACK_USE_ALLOCA
+#include <alloca.h>
+#else /* not sparc */
+/* We think this test detects Watcom and Microsoft C.  */
+/* This used to test MSDOS, but that is a bad idea
+   since that symbol is in the user namespace.  */
+#if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)
+#if 0 /* No need for malloc.h, which pollutes the namespace;
+         instead, just don't use alloca.  */
+#include <malloc.h>
+#endif
+#else /* not MSDOS, or __TURBOC__ */
+#if defined(_AIX)
+/* I don't know what this was needed for, but it pollutes the namespace.
+   So I turned it off.   rms, 2 May 1997.  */
+/* #include <malloc.h>  */
+ #pragma alloca
+#define YYSTACK_USE_ALLOCA
+#else /* not MSDOS, or __TURBOC__, or _AIX */
+#if 0
+#ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up,
+                 and on HPUX 10.  Eventually we can turn this on.  */
+#define YYSTACK_USE_ALLOCA
+#define alloca __builtin_alloca
+#endif /* __hpux */
+#endif
+#endif /* not _AIX */
+#endif /* not MSDOS, or __TURBOC__ */
+#endif /* not sparc */
+#endif /* not GNU C */
+#endif /* alloca not defined */
+#endif /* YYSTACK_USE_ALLOCA not defined */
+
+#ifdef YYSTACK_USE_ALLOCA
+#define YYSTACK_ALLOC alloca
+#else
+#define YYSTACK_ALLOC malloc
+#endif
+
+/* Note: there must be only one dollar sign in this file.
+   It is replaced by the list of actions, each action
+   as one case of the switch.  */
+
+        #define yyerrok         (yyerrstatus = 0)
+        #define yyclearin(yychar = YYEMPTY)
+        #define YYEMPTY         -2
+        #define YYEOF   0
+        #define YYACCEPTgoto yyacceptlab
+        #define YYABORT goto yyabortlab
+        #define YYERROR         goto yyerrlab1
+/* Like YYERROR except do call yyerror.
+   This remains here temporarily to ease the
+   transition to the new meaning of YYERROR, for GCC.
+   Once GCC version 2 has supplanted version 1, this can go.  */
+        #define YYFAIL  goto yyerrlab
+#define YYRECOVERING()  (!!yyerrstatus)
+#define YYBACKUP(token, value) \
+        do                                                      \
+          if (yychar == YYEMPTY && yylen == 1)                  \
+            { yychar = (token), yylval = (value);               \
+              yychar1 = YYTRANSLATE (yychar);                   \
+              YYPOPSTACK;                                       \
+              goto yybackup;                                    \
+            }                                                   \
+          else                                                  \
+            { yyerror ("syntax error: cannot back up"); YYERROR; }\
+while (0)
+
+        #define YYTERROR1
+        #define YYERRCODE256
+
+#ifndef YYPURE
+        #define YYLEX   yylex()
+#endif
+
+#ifdef YYPURE
+#ifdef YYLSP_NEEDED
+#ifdef YYLEX_PARAM
+        #define YYLEX   yylex(&yylval, &yylloc, YYLEX_PARAM)
+#else
+        #define YYLEX   yylex(&yylval, &yylloc)
+#endif
+#else /* not YYLSP_NEEDED */
+#ifdef YYLEX_PARAM
+        #define YYLEX   yylex(&yylval, YYLEX_PARAM)
+#else
+        #define YYLEX   yylex(&yylval)
+#endif
+#endif /* not YYLSP_NEEDED */
+#endif
+
+/* If nonreentrant, generate the variables here */
+
+#ifndef YYPURE
+
+        int     yychar;                         /*  the lookahead symbol        */
+        YYSTYPE         yylval;                         /*  the semantic value of the   */
+                                        /*  lookahead symbol            */
+
+#ifdef YYLSP_NEEDED
+        YYLTYPE yylloc;                         /*  location data for the lookahead*/
+                                        /*  symbol                      */
+#endif
+
+        int yynerrs;            /*  number of parse errors so far       */
+#endif  /* not YYPURE */
+
+#if YYDEBUG != 0
+        int yydebug;                    /*  nonzero means print parse trace*/
+/* Since this is uninitialized, it does not stop multiple parsers
+   from coexisting.  */
+#endif
+
+        /*  YYINITDEPTH indicates the initial size of the parser's stacks*/
+
+        #ifndefYYINITDEPTH
+#define YYINITDEPTH 200
+#endif
+
+/*  YYMAXDEPTH is the maximum size the stacks can grow to
+    (effective only if the built-in stack extension method is used).  */
+
+#if YYMAXDEPTH == 0
+#undef YYMAXDEPTH
+#endif
+
+#ifndef YYMAXDEPTH
+#define YYMAXDEPTH 10000
+#endif
+
+/* Define __yy_memcpy.  Note that the size argument
+   should be passed with type unsigned int, because that is what the non-GCC
+   definitions require.  With GCC, __builtin_memcpy takes an arg
+   of type size_t, but it can handle unsigned int.  */
+
+        #if __GNUC__ > 1        /* GNU C and GNU C++ define this.  */
+        #define __yy_memcpy(TO,FROM,COUNT)__builtin_memcpy(TO,FROM,COUNT)
+        #else                   /* not GNU C or C++ */
+#ifndef __cplusplus
+
+/* This is the most reliable way to avoid incompatibilities
+   in available built-in functions on various systems.  */
+static void
+__yy_memcpy (to, from, count)
+     char *to;
+     char *from;
+     unsigned int count;
+{
+  register char *f = from;
+  register char *t = to;
+  register int i = count;
+
+  while (i-- > 0)
+    *t++ = *f++;
+}
+
+#else /* __cplusplus */
+
+/* This is the most reliable way to avoid incompatibilities
+   in available built-in functions on various systems.  */
+static void
+__yy_memcpy (char *to, char *from, unsigned int count)
+{
+  register char *t = to;
+  register char *f = from;
+  register int i = count;
+
+  while (i-- > 0)
+    *t++ = *f++;
+}
+
+#endif
+#endif
+
+#line 222 "/usr/share/bison.simple"
+
+/* The user can define YYPARSE_PARAM as the name of an argument to be passed
+   into yyparse.  The argument should have type void *.
+   It should actually point to an object.
+   Grammar actions can access the variable by casting it
+   to the proper pointer type.  */
+
+#ifdef YYPARSE_PARAM
+#ifdef __cplusplus
+#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
+#define YYPARSE_PARAM_DECL
+#else /* not __cplusplus */
+#define YYPARSE_PARAM_ARG YYPARSE_PARAM
+#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
+#endif /* not __cplusplus */
+#else /* not YYPARSE_PARAM */
+#define YYPARSE_PARAM_ARG
+#define YYPARSE_PARAM_DECL
+#endif /* not YYPARSE_PARAM */
+
+/* Prevent warning if -Wstrict-prototypes.  */
+#ifdef __GNUC__
+#ifdef YYPARSE_PARAM
+YYPARSE_RETURN_TYPE
+yyparse (void *);
+#else
+YYPARSE_RETURN_TYPE
+yyparse (void);
+#endif
+#endif
+
+YYPARSE_RETURN_TYPE
+yyparse(YYPARSE_PARAM_ARG)
+     YYPARSE_PARAM_DECL
+{
+  register int yystate;
+  register int yyn;
+  register short *yyssp;
+  register YYSTYPE *yyvsp;
+          int yyerrstatus;/*  number of tokens to shift before error messages enabled */
+          int yychar1 = 0;      /*  lookahead token as an internal (translated) token number */
+
+          short         yyssa[YYINITDEPTH];     /*  the state stack             */
+          YYSTYPE yyvsa[YYINITDEPTH];   /*  the semantic value stack    */
+
+          short *yyss = yyssa;  /*  refer to the stacks thru separate pointers */
+          YYSTYPE *yyvs = yyvsa;/*  to allow yyoverflow to reallocate them elsewhere */
+
+#ifdef YYLSP_NEEDED
+          YYLTYPE yylsa[YYINITDEPTH];   /*  the location stack          */
+  YYLTYPE *yyls = yylsa;
+  YYLTYPE *yylsp;
+
+#define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
+#else
+#define YYPOPSTACK   (yyvsp--, yyssp--)
+#endif
+
+  int yystacksize = YYINITDEPTH;
+#ifndef YYSTACK_USE_ALLOCA
+  int yyfree_stacks = 0;
+#endif
+
+#ifdef YYPURE
+  int yychar;
+  YYSTYPE yylval;
+  int yynerrs;
+#ifdef YYLSP_NEEDED
+  YYLTYPE yylloc;
+#endif
+#endif
+
+          YYSTYPE yyval;                /*  the variable used to return         */
+                                        /*  semantic values from the action*/
+                                        /*  routines                    */
+
+  int yylen;
+
+#if YYDEBUG != 0
+  if (yydebug)
+    fprintf(stderr, "Starting parse\n");
+#endif
+
+  yystate = 0;
+  yyerrstatus = 0;
+  yynerrs = 0;
+          yychar = YYEMPTY;     /* Cause a token to be read.  */
+
+  /* Initialize stack pointers.
+     Waste one element of value and location stack
+     so that they stay on the same level as the state stack.
+     The wasted elements are never initialized.  */
+
+  yyssp = yyss - 1;
+  yyvsp = yyvs;
+#ifdef YYLSP_NEEDED
+  yylsp = yyls;
+#endif
+
+/* Push a new state, which is found in  yystate  .  */
+/* In all cases, when you get here, the value and location stacks
+   have just been pushed. so pushing a state here evens the stacks.  */
+yynewstate:
+
+  *++yyssp = yystate;
+
+  if (yyssp >= yyss + yystacksize - 1)
+    {
+      /* Give user a chance to reallocate the stack */
+      /* Use copies of these so that the &'s don't force the real ones into memory. */
+      YYSTYPE *yyvs1 = yyvs;
+      short *yyss1 = yyss;
+#ifdef YYLSP_NEEDED
+      YYLTYPE *yyls1 = yyls;
+#endif
+
+      /* Get the current used size of the three stacks, in elements.  */
+      int size = yyssp - yyss + 1;
+
+#ifdef yyoverflow
+      /* Each stack pointer address is followed by the size of
+         the data in use in that stack, in bytes.  */
+#ifdef YYLSP_NEEDED
+      /* This used to be a conditional around just the two extra args,
+         but that might be undefined if yyoverflow is a macro.  */
+      yyoverflow("parser stack overflow",
+                 &yyss1, size * sizeof (*yyssp),
+                 &yyvs1, size * sizeof (*yyvsp),
+                 &yyls1, size * sizeof (*yylsp),
+                 &yystacksize);
+#else
+      yyoverflow("parser stack overflow",
+                 &yyss1, size * sizeof (*yyssp),
+                 &yyvs1, size * sizeof (*yyvsp),
+                 &yystacksize);
+#endif
+
+      yyss = yyss1; yyvs = yyvs1;
+#ifdef YYLSP_NEEDED
+      yyls = yyls1;
+#endif
+#else /* no yyoverflow */
+      /* Extend the stack our own way.  */
+      if (yystacksize >= YYMAXDEPTH)
+        {
+          yyerror("parser stack overflow");
+#ifndef YYSTACK_USE_ALLOCA
+          if (yyfree_stacks)
+            {
+              free (yyss);
+              free (yyvs);
+#ifdef YYLSP_NEEDED
+              free (yyls);
+#endif
+            }
+        #endif    
+          return 2;
+        }
+      yystacksize *= 2;
+      if (yystacksize > YYMAXDEPTH)
+        yystacksize = YYMAXDEPTH;
+#ifndef YYSTACK_USE_ALLOCA
+      yyfree_stacks = 1;
+#endif
+      yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));
+      __yy_memcpy ((char *)yyss, (char *)yyss1,
+                   size * (unsigned int) sizeof (*yyssp));
+      yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));
+      __yy_memcpy ((char *)yyvs, (char *)yyvs1,
+                   size * (unsigned int) sizeof (*yyvsp));
+#ifdef YYLSP_NEEDED
+      yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));
+      __yy_memcpy ((char *)yyls, (char *)yyls1,
+                   size * (unsigned int) sizeof (*yylsp));
+#endif
+#endif /* no yyoverflow */
+
+      yyssp = yyss + size - 1;
+      yyvsp = yyvs + size - 1;
+#ifdef YYLSP_NEEDED
+      yylsp = yyls + size - 1;
+#endif
+
+#if YYDEBUG != 0
+      if (yydebug)
+        fprintf(stderr, "Stack size increased to %d\n", yystacksize);
+#endif
+
+      if (yyssp >= yyss + yystacksize - 1)
+        YYABORT;
+    }
+
+#if YYDEBUG != 0
+  if (yydebug)
+    fprintf(stderr, "Entering state %d\n", yystate);
+#endif
+
+  goto yybackup;
+ yybackup:
+
+/* Do appropriate processing given the current state.  */
+/* Read a lookahead token if we need one and don't already have one.  */
+/* yyresume: */
+
+  /* First try to decide what to do without reference to lookahead token.  */
+
+  yyn = yypact[yystate];
+  if (yyn == YYFLAG)
+    goto yydefault;
+
+  /* Not known => get a lookahead token if don't already have one.  */
+
+  /* yychar is either YYEMPTY or YYEOF
+     or a valid token in external form.  */
+
+  if (yychar == YYEMPTY)
+    {
+#if YYDEBUG != 0
+      if (yydebug)
+        fprintf(stderr, "Reading a token: ");
+#endif
+      yychar = YYLEX;
+    }
+
+  /* Convert token to internal form (in yychar1) for indexing tables with */
+
+          if (yychar <= 0)      /* This means end of input. */
+    {
+      yychar1 = 0;
+              yychar = YYEOF;   /* Don't call YYLEX any more */
+
+#if YYDEBUG != 0
+      if (yydebug)
+        fprintf(stderr, "Now at end of input.\n");
+#endif
+    }
+  else
+    {
+      yychar1 = YYTRANSLATE(yychar);
+
+#if YYDEBUG != 0
+      if (yydebug)
+        {
+          fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
+          /* Give the individual parser a way to print the precise meaning
+             of a token, for further debugging info.  */
+#ifdef YYPRINT
+          YYPRINT (stderr, yychar, yylval);
+#endif
+          fprintf (stderr, ")\n");
+        }
+#endif
+    }
+
+  yyn += yychar1;
+  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
+    goto yydefault;
+
+  yyn = yytable[yyn];
+
+  /* yyn is what to do for this token type in this state.
+     Negative => reduce, -yyn is rule number.
+     Positive => shift, yyn is new state.
+       New state is final state => don't bother to shift,
+       just return success.
+     0, or most negative number => error.  */
+
+  if (yyn < 0)
+    {
+      if (yyn == YYFLAG)
+        goto yyerrlab;
+      yyn = -yyn;
+      goto yyreduce;
+    }
+  else if (yyn == 0)
+    goto yyerrlab;
+
+  if (yyn == YYFINAL)
+    YYACCEPT;
+
+  /* Shift the lookahead token.  */
+
+#if YYDEBUG != 0
+  if (yydebug)
+    fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
+#endif
+
+  /* Discard the token being shifted unless it is eof.  */
+  if (yychar != YYEOF)
+    yychar = YYEMPTY;
+
+  *++yyvsp = yylval;
+#ifdef YYLSP_NEEDED
+  *++yylsp = yylloc;
+#endif
+
+  /* count tokens shifted since error; after three, turn off error status.  */
+  if (yyerrstatus) yyerrstatus--;
+
+  yystate = yyn;
+  goto yynewstate;
+
+/* Do the default action for the current state.  */
+yydefault:
+
+  yyn = yydefact[yystate];
+  if (yyn == 0)
+    goto yyerrlab;
+
+/* Do a reduction.  yyn is the number of a rule to reduce with.  */
+yyreduce:
+  yylen = yyr2[yyn];
+  if (yylen > 0)
+    yyval = yyvsp[1-yylen]; /* implement default value of the action */
+
+#if YYDEBUG != 0
+  if (yydebug)
+    {
+      int i;
+
+      fprintf (stderr, "Reducing via rule %d (line %d), ",
+               yyn, yyrline[yyn]);
+
+      /* Print the symbols being reduced, and their result.  */
+      for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
+        fprintf (stderr, "%s ", yytname[yyrhs[i]]);
+      fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
+    }
+#endif
+
+
+  switch (yyn) {
+
+case 6:
+#line 183 "../../../../libical/src/libical/icalyacc.y"
+{ 
+                  icalparser_yy_value = 0;
+                  icalparser_clear_flex_input();
+                  yyclearin;
+                  ;
+    break;}
+case 7:
+#line 191 "../../../../libical/src/libical/icalyacc.y"
+{
+            struct icaltimetype stm;
+
+            stm = fill_datetime(yyvsp[0].v_string,0);
+
+            stm.hour = -1;
+            stm.minute = -1;
+            stm.second = -1;
+            stm.is_utc = 0;
+            stm.is_date = 1;
+
+            icalparser_yy_value = icalvalue_new_date(stm);
+        ;
+    break;}
+case 8:
+#line 206 "../../../../libical/src/libical/icalyacc.y"
+{utc = 0;;
+    break;}
+case 9:
+#line 207 "../../../../libical/src/libical/icalyacc.y"
+{utc = 1;;
+    break;}
+case 10:
+#line 211 "../../../../libical/src/libical/icalyacc.y"
+{utc_b = 0;;
+    break;}
+case 11:
+#line 212 "../../../../libical/src/libical/icalyacc.y"
+{utc_b = 1;;
+    break;}
+case 12:
+#line 216 "../../../../libical/src/libical/icalyacc.y"
+{
+            struct  icaltimetype stm;
+            stm = fill_datetime(yyvsp[-3].v_string, yyvsp[-1].v_string);
+            stm.is_utc = utc;
+            stm.is_date = 0;
+
+            icalparser_yy_value = 
+                icalvalue_new_datetime(stm);
+        ;
+    break;}
+case 15:
+#line 234 "../../../../libical/src/libical/icalyacc.y"
+{
+            duration.weeks = atoi(yyvsp[-1].v_string);
+        ;
+    break;}
+case 16:
+#line 239 "../../../../libical/src/libical/icalyacc.y"
+{
+        ;
+    break;}
+case 17:
+#line 242 "../../../../libical/src/libical/icalyacc.y"
+{
+        ;
+    break;}
+case 18:
+#line 245 "../../../../libical/src/libical/icalyacc.y"
+{
+        ;
+    break;}
+case 19:
+#line 249 "../../../../libical/src/libical/icalyacc.y"
+{
+            duration.hours = atoi(yyvsp[-1].v_string);
+        ;
+    break;}
+case 20:
+#line 253 "../../../../libical/src/libical/icalyacc.y"
+{
+            duration.hours = atoi(yyvsp[-2].v_string);
+        ;
+    break;}
+case 21:
+#line 258 "../../../../libical/src/libical/icalyacc.y"
+{
+            duration.minutes = atoi(yyvsp[-1].v_string);
+        ;
+    break;}
+case 22:
+#line 262 "../../../../libical/src/libical/icalyacc.y"
+{
+            duration.minutes = atoi(yyvsp[-2].v_string);
+        ;
+    break;}
+case 23:
+#line 267 "../../../../libical/src/libical/icalyacc.y"
+{
+            duration.seconds = atoi(yyvsp[-1].v_string);
+        ;
+    break;}
+case 24:
+#line 272 "../../../../libical/src/libical/icalyacc.y"
+{
+            duration.days = atoi(yyvsp[-1].v_string);
+        ;
+    break;}
+case 25:
+#line 277 "../../../../libical/src/libical/icalyacc.y"
+{
+            duration.is_neg = 0;
+        ;
+    break;}
+case 26:
+#line 281 "../../../../libical/src/libical/icalyacc.y"
+{
+            duration.is_neg = 0;
+        ;
+    break;}
+case 27:
+#line 285 "../../../../libical/src/libical/icalyacc.y"
+{ 
+            duration.is_neg = 1;
+        ;
+    break;}
+case 28:
+#line 290 "../../../../libical/src/libical/icalyacc.y"
+{ 
+            icalparser_yy_value = icalvalue_new_duration(duration); 
+            memset(&duration,0, sizeof(duration));
+        ;
+    break;}
+case 29:
+#line 295 "../../../../libical/src/libical/icalyacc.y"
+{ 
+            icalparser_yy_value = icalvalue_new_duration(duration); 
+            memset(&duration,0, sizeof(duration));
+        ;
+    break;}
+case 30:
+#line 300 "../../../../libical/src/libical/icalyacc.y"
+{ 
+            icalparser_yy_value = icalvalue_new_duration(duration); 
+            memset(&duration,0, sizeof(duration));
+        ;
+    break;}
+case 31:
+#line 309 "../../../../libical/src/libical/icalyacc.y"
+{
+            struct icalperiodtype p;
+        
+            p.start = fill_datetime(yyvsp[-8].v_string,yyvsp[-6].v_string);
+            p.start.is_utc = utc;
+            p.start.is_date = 0;
+
+
+            p.end = fill_datetime(yyvsp[-3].v_string,yyvsp[-1].v_string);
+            p.end.is_utc = utc_b;
+            p.end.is_date = 0;
+                
+            p.duration.days = -1;
+            p.duration.weeks = -1;
+            p.duration.hours = -1;
+            p.duration.minutes = -1;
+            p.duration.seconds = -1;
+
+            icalparser_yy_value = icalvalue_new_period(p);
+        ;
+    break;}
+case 32:
+#line 330 "../../../../libical/src/libical/icalyacc.y"
+{
+            struct icalperiodtype p;
+            
+            p.start = fill_datetime(yyvsp[-5].v_string,yyvsp[-3].v_string);
+            p.start.is_utc = utc;
+            p.start.is_date = 0;
+
+            p.end.year = -1;
+            p.end.month = -1;
+            p.end.day = -1;
+            p.end.hour = -1;
+            p.end.minute = -1;
+            p.end.second = -1;
+                   
+            /* The duration_value rule setes the global 'duration'
+               variable, but it also creates a new value in
+               icalparser_yy_value. So, free that, then copy
+               'duration' into the icalperiodtype struct. */
+
+            p.duration = icalvalue_get_duration(icalparser_yy_value);
+            icalvalue_free(icalparser_yy_value);
+            icalparser_yy_value = 0;
+
+            icalparser_yy_value = icalvalue_new_period(p);
+
+        ;
+    break;}
+case 34:
+#line 364 "../../../../libical/src/libical/icalyacc.y"
+{ utcsign = 1; ;
+    break;}
+case 35:
+#line 365 "../../../../libical/src/libical/icalyacc.y"
+{ utcsign = -1; ;
+    break;}
+case 36:
+#line 369 "../../../../libical/src/libical/icalyacc.y"
+{
+            icalparser_yy_value = icalvalue_new_utcoffset( utcsign * (yyvsp[-1].v_int*3600) + (yyvsp[0].v_int*60) );
+          ;
+    break;}
+case 37:
+#line 374 "../../../../libical/src/libical/icalyacc.y"
+{
+            icalparser_yy_value = icalvalue_new_utcoffset(utcsign * (yyvsp[-2].v_int*3600) + (yyvsp[-1].v_int*60) +(yyvsp[0].v_int));
+          ;
+    break;}
+}
+   /* the action file gets copied in in place of this dollarsign */
+#line 554 "/usr/share/bison.simple"
+
+  yyvsp -= yylen;
+  yyssp -= yylen;
+#ifdef YYLSP_NEEDED
+  yylsp -= yylen;
+#endif
+
+#if YYDEBUG != 0
+  if (yydebug)
+    {
+      short *ssp1 = yyss - 1;
+      fprintf (stderr, "state stack now");
+      while (ssp1 != yyssp)
+        fprintf (stderr, " %d", *++ssp1);
+      fprintf (stderr, "\n");
+    }
+#endif
+
+  *++yyvsp = yyval;
+
+#ifdef YYLSP_NEEDED
+  yylsp++;
+  if (yylen == 0)
+    {
+      yylsp->first_line = yylloc.first_line;
+      yylsp->first_column = yylloc.first_column;
+      yylsp->last_line = (yylsp-1)->last_line;
+      yylsp->last_column = (yylsp-1)->last_column;
+      yylsp->text = 0;
+    }
+  else
+    {
+      yylsp->last_line = (yylsp+yylen-1)->last_line;
+      yylsp->last_column = (yylsp+yylen-1)->last_column;
+    }
+#endif
+
+  /* Now "shift" the result of the reduction.
+     Determine what state that goes to,
+     based on the state we popped back to
+     and the rule number reduced by.  */
+
+  yyn = yyr1[yyn];
+
+  yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
+  if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
+    yystate = yytable[yystate];
+  else
+    yystate = yydefgoto[yyn - YYNTBASE];
+
+  goto yynewstate;
+
+yyerrlab:   /* here on detecting error */
+
+  if (! yyerrstatus)
+    /* If not already recovering from an error, report this error.  */
+    {
+      ++yynerrs;
+
+#ifdef YYERROR_VERBOSE
+      yyn = yypact[yystate];
+
+      if (yyn > YYFLAG && yyn < YYLAST)
+        {
+          int size = 0;
+          char *msg;
+          int x, count;
+
+          count = 0;
+          /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
+          for (x = (yyn < 0 ? -yyn : 0);
+               x < (sizeof(yytname) / sizeof(char *)); x++)
+            if (yycheck[x + yyn] == x)
+              size += strlen(yytname[x]) + 15, count++;
+          msg = (char *) malloc(size + 15);
+          if (msg != 0)
+            {
+              strcpy(msg, "parse error");
+
+              if (count < 5)
+                {
+                  count = 0;
+                  for (x = (yyn < 0 ? -yyn : 0);
+                       x < (sizeof(yytname) / sizeof(char *)); x++)
+                    if (yycheck[x + yyn] == x)
+                      {
+                        strcat(msg, count == 0 ? ", expecting `" : " or `");
+                        strcat(msg, yytname[x]);
+                        strcat(msg, "'");
+                        count++;
+                      }
+                }
+              yyerror(msg);
+              free(msg);
+            }
+          else
+            yyerror ("parse error; also virtual memory exceeded");
+        }
+      else
+#endif /* YYERROR_VERBOSE */
+        yyerror("parse error");
+    }
+
+  goto yyerrlab1;
+yyerrlab1:   /* here on error raised explicitly by an action */
+
+  if (yyerrstatus == 3)
+    {
+      /* if just tried and failed to reuse lookahead token after an error, discard it.  */
+
+      /* return failure if at end of input */
+      if (yychar == YYEOF)
+        YYABORT;
+
+#if YYDEBUG != 0
+      if (yydebug)
+        fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
+#endif
+
+      yychar = YYEMPTY;
+    }
+
+  /* Else will try to reuse lookahead token
+     after shifting the error token.  */
+
+          yyerrstatus = 3;      /* Each real token shifted decrements this */
+
+  goto yyerrhandle;
+
+yyerrdefault:  /* current state does not do anything special for the error token. */
+
+#if 0
+  /* This is wrong; only states that explicitly want error tokens
+     should shift them.  */
+  yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
+  if (yyn) goto yydefault;
+#endif
+
+yyerrpop:   /* pop the current state because it cannot handle the error token */
+
+  if (yyssp == yyss) YYABORT;
+  yyvsp--;
+  yystate = *--yyssp;
+#ifdef YYLSP_NEEDED
+  yylsp--;
+#endif
+
+#if YYDEBUG != 0
+  if (yydebug)
+    {
+      short *ssp1 = yyss - 1;
+      fprintf (stderr, "Error: state stack now");
+      while (ssp1 != yyssp)
+        fprintf (stderr, " %d", *++ssp1);
+      fprintf (stderr, "\n");
+    }
+#endif
+
+yyerrhandle:
+
+  yyn = yypact[yystate];
+  if (yyn == YYFLAG)
+    goto yyerrdefault;
+
+  yyn += YYTERROR;
+  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
+    goto yyerrdefault;
+
+  yyn = yytable[yyn];
+  if (yyn < 0)
+    {
+      if (yyn == YYFLAG)
+        goto yyerrpop;
+      yyn = -yyn;
+      goto yyreduce;
+    }
+  else if (yyn == 0)
+    goto yyerrpop;
+
+  if (yyn == YYFINAL)
+    YYACCEPT;
+
+#if YYDEBUG != 0
+  if (yydebug)
+    fprintf(stderr, "Shifting error token, ");
+#endif
+
+  *++yyvsp = yylval;
+#ifdef YYLSP_NEEDED
+  *++yylsp = yylloc;
+#endif
+
+  yystate = yyn;
+  goto yynewstate;
+
+ yyacceptlab:
+  /* YYACCEPT comes here.  */
+#ifndef YYSTACK_USE_ALLOCA
+  if (yyfree_stacks)
+    {
+      free (yyss);
+      free (yyvs);
+#ifdef YYLSP_NEEDED
+      free (yyls);
+#endif
+    }
+#endif
+  return 0;
+
+ yyabortlab:
+  /* YYABORT comes here.  */
+#ifndef YYSTACK_USE_ALLOCA
+  if (yyfree_stacks)
+    {
+      free (yyss);
+      free (yyvs);
+#ifdef YYLSP_NEEDED
+      free (yyls);
+#endif
+    }
+#endif    
+  return 1;
+}
+#line 378 "../../../../libical/src/libical/icalyacc.y"
+
+
+struct icaltimetype fill_datetime(char* datestr, char* timestr)
+{
+            struct icaltimetype stm;
+
+            memset(&stm,0,sizeof(stm));
+
+            if (datestr != 0){
+                sscanf(datestr,"%4d%2d%2d",&(stm.year), &(stm.month), 
+                       &(stm.day));
+            }
+
+            if (timestr != 0){
+                sscanf(timestr,"%2d%2d%2d", &(stm.hour), &(stm.minute), 
+                       &(stm.second));
+            }
+
+            return stm;
+
+}
+
+void ical_yyerror(char* s)
+{
+    /*fprintf(stderr,"Parse error \'%s\'\n", s);*/
+}
+
diff --git a/libical/src/libical/icalyacc.h b/libical/src/libical/icalyacc.h
new file mode 100644
index 0000000..f6d66bc
--- a/dev/null
+++ b/libical/src/libical/icalyacc.h
@@ -0,0 +1,137 @@
+typedef union {
+        float v_float;
+        int   v_int;
+        char* v_string;
+} YYSTYPE;
+        #define         DIGITS257
+        #define         INTNUMBER258
+        #define         FLOATNUMBER259
+        #define         STRING260
+        #define         EOL261
+        #define         EQUALS262
+        #define         CHARACTER263
+        #define         COLON264
+        #define         COMMA265
+        #define         SEMICOLON266
+        #define         MINUS267
+        #define         TIMESEPERATOR268
+        #define         TRUE269
+        #define         FALSE270
+        #define         FREQ271
+        #define         BYDAY272
+        #define         BYHOUR273
+        #define         BYMINUTE274
+        #define         BYMONTH275
+        #define         BYMONTHDAY276
+        #define         BYSECOND277
+        #define         BYSETPOS278
+        #define         BYWEEKNO279
+        #define         BYYEARDAY280
+        #define         DAILY281
+        #define         MINUTELY282
+        #define         MONTHLY283
+        #define         SECONDLY284
+        #define         WEEKLY285
+        #define         HOURLY286
+        #define         YEARLY287
+        #define         INTERVAL288
+        #define         COUNT289
+        #define         UNTIL290
+        #define         WKST291
+        #define         MO292
+        #define         SA293
+        #define         SU294
+        #define         TU295
+        #define         WE296
+        #define         TH297
+        #define         FR298
+        #define         BIT8299
+        #define         ACCEPTED300
+        #define         ADD301
+        #define         AUDIO302
+        #define         BASE64303
+        #define         BINARY304
+        #define         BOOLEAN305
+        #define         BUSY306
+        #define         BUSYTENTATIVE307
+        #define         BUSYUNAVAILABLE308
+        #define         CALADDRESS309
+        #define         CANCEL310
+        #define         CANCELLED311
+        #define         CHAIR312
+        #define         CHILD313
+        #define         COMPLETED314
+        #define         CONFIDENTIAL315
+        #define         CONFIRMED316
+        #define         COUNTER317
+        #define         DATE318
+        #define         DATETIME319
+        #define         DECLINECOUNTER320
+        #define         DECLINED321
+        #define         DELEGATED322
+        #define         DISPLAY323
+        #define         DRAFT324
+        #define         DURATION325
+        #define         EMAIL326
+        #define         END327
+        #define         FINAL328
+        #define         FLOAT329
+        #define         FREE330
+        #define         GREGORIAN331
+        #define         GROUP332
+        #define         INDIVIDUAL333
+        #define         INPROCESS334
+        #define         INTEGER335
+        #define         NEEDSACTION336
+        #define         NONPARTICIPANT337
+        #define         OPAQUE338
+        #define         OPTPARTICIPANT339
+        #define         PARENT340
+        #define         PERIOD341
+        #define         PRIVATE342
+        #define         PROCEDURE343
+        #define         PUBLIC344
+        #define         PUBLISH345
+        #define         RECUR346
+        #define         REFRESH347
+        #define         REPLY348
+        #define         REQPARTICIPANT349
+        #define         REQUEST350
+        #define         RESOURCE351
+        #define         ROOM352
+        #define         SIBLING353
+        #define         START354
+        #define         TENTATIVE355
+        #define         TEXT356
+        #define         THISANDFUTURE357
+        #define         THISANDPRIOR358
+        #define         TIME359
+        #define         TRANSPAENT360
+        #define         UNKNOWN361
+        #define         UTCOFFSET362
+        #define         XNAME363
+        #define         ALTREP364
+        #define         CN365
+        #define         CUTYPE366
+        #define         DAYLIGHT367
+        #define         DIR368
+        #define         ENCODING369
+        #define         EVENT370
+        #define         FBTYPE371
+        #define         FMTTYPE372
+        #define         LANGUAGE373
+        #define         MEMBER374
+        #define         PARTSTAT375
+        #define         RANGE376
+        #define         RELATED377
+        #define         RELTYPE378
+        #define         ROLE379
+        #define         RSVP380
+        #define         SENTBY381
+        #define         STANDARD382
+        #define         URI383
+        #define         TIME_CHAR384
+        #define         UTC_CHAR385
+
+
+extern YYSTYPE ical_yylval;
diff --git a/libical/src/libical/icalyacc.y b/libical/src/libical/icalyacc.y
new file mode 100644
index 0000000..4f53d84
--- a/dev/null
+++ b/libical/src/libical/icalyacc.y
@@ -0,0 +1,404 @@
+%{
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: icalitip.y
+  CREATOR: eric 10 June 1999
+  
+  DESCRIPTION:
+  
+  $Id$
+  $Locker$
+
+  (C) COPYRIGHT 1999 Eric Busboom 
+  http://www.softwarestudio.org
+
+  The contents of this file are subject to the Mozilla Public License
+  Version 1.0 (the "License"); you may not use this file except in
+  compliance with the License. You may obtain a copy of the License at
+  http://www.mozilla.org/MPL/
+ 
+  Software distributed under the License is distributed on an "AS IS"
+  basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+  the License for the specific language governing rights and
+  limitations under the License.
+
+  The original author is Eric Busboom
+  The original code is icalitip.y
+
+
+
+  =======================================================================*/
+
+#include <stdlib.h>
+#include <string.h> /* for strdup() */
+#include "icalparser.h"
+#include "pvl.h"
+
+icalvalue *icalparser_yy_value; /* Current Value */
+
+void ical_yyerror(char* s);
+void icalparser_clear_flex_input();  
+int ical_yy_lex(void);
+
+/* Globals for UTCOFFSET values */
+int utc; 
+int utc_b; 
+int utcsign;
+
+/* Globals for DURATION values */
+struct icaldurationtype duration;
+
+/* Globals for TRIGGER values */
+struct icaltriggertype trigger;
+
+void copy_list(short* array, size_t size);
+void add_prop(icalproperty_kind);
+void icalparser_fill_date(struct tm* t, char* dstr);
+void icalparser_fill_time(struct tm* t, char* tstr);
+void set_value_type(icalvalue_kind kind);
+void set_parser_value_state();
+struct icaltimetype fill_datetime(char* d, char* t);
+void ical_yy_error(char *s); /* Don't know why I need this.... */
+int yylex(void); /* Or this. */
+
+
+
+/* Set the state of the lexer so it will interpret values ( iCAL
+   VALUEs, that is, ) correctly. */
+
+%}
+
+%union {
+        float v_float;
+        int   v_int;
+        char* v_string;
+}
+
+
+  /* Renaming hack */
+
+/*
+#define    yymaxdepth ical_yy_maxdepth
+#define    yyparse ical_yy_parse
+#define    yyerror ical_yy_error
+#define    yylval  ical_yy_lval
+#define    yychar  ical_yy_char
+#define    yydebug ical_yy_debug
+#define    yypact  ical_yy_pact
+#define    yyr1    ical_yy_r1
+#define    yyr2    ical_yy_r2
+#define    yydef   ical_yy_def
+#define    yychk   ical_yy_chk
+#define    yypgo   ical_yy_pgo
+#define    yyact   ical_yy_act
+#define    yyexca  ical_yy_exca
+#define yyerrflag ical_yy_errflag
+#define yynerrs    ical_yy_nerrs
+#define    yyps    ical_yy_ps
+#define    yypv    ical_yy_pv
+#define    yys     ical_yy_s
+#define    yy_yys  ical_yy_yys
+#define    yystate ical_yy_state
+#define    yytmp   ical_yy_tmp
+#define    yyv     ical_yy_v
+#define    yy_yyv  ical_yy_yyv
+#define    yyval   ical_yy_val
+#define    yylloc  ical_yy_lloc
+#define yyreds     ical_yy_reds
+#define yytoks     ical_yy_toks
+#define yylhs      ical_yy_yylhs
+#define yylen      ical_yy_yylen
+#define yydefred ical_yy_yydefred
+#define yydgoto    ical_yy_yydgoto
+#define yydefred ical_yy_yydefred
+#define yydgoto    ical_yy_yydgoto
+#define yysindex ical_yy_yysindex
+#define yyrindex ical_yy_yyrindex
+#define yygindex ical_yy_yygindex
+#define yytable     ical_yy_yytable
+#define yycheck     ical_yy_yycheck
+#define yyname   ical_yy_yyname
+#define yyrule   ical_yy_yyrule
+#define yy_scan_bytes ical_yy_scan_bytes
+#define yy_scan_string ical_yy_scan_string
+#define yy_scan_buffer ical_yy_scan_buffer
+*/
+
+/* These are redefined with the -P option to flex */
+/*
+#define yy_create_buffer  ical_yy_create_buffer 
+#define yy_delete_buffer ical_yy_delete_buffer
+#define yy_flex_debug ical_yy_flex_debug
+#define yy_init_buffer ical_yy_init_buffer
+#define yy_flush_buffer ical_yy_flush_buffer
+#define yy_load_buffer_state ical_yy_load_buffer_state
+#define yy_switch_to_buffer ical_yy_switch_to_buffer
+#define yyin ical_yyin
+#define yyleng ical_yyleng
+#define yylex ical_yylex
+#define yylineno ical_yylineno
+#define yyout ical_yyout
+#define yyrestart ical_yyrestart
+#define yytext ical_yytext
+#define yywrap ical_yywrap             
+*/
+
+
+%token <v_string> DIGITS
+%token <v_int> INTNUMBER
+%token <v_float> FLOATNUMBER
+%token <v_string> STRING   
+%token EOL EQUALS CHARACTER COLON COMMA SEMICOLON MINUS TIMESEPERATOR 
+
+%token TRUE FALSE
+
+%token FREQ BYDAY BYHOUR BYMINUTE BYMONTH BYMONTHDAY BYSECOND BYSETPOS BYWEEKNO
+%token BYYEARDAY DAILY MINUTELY MONTHLY SECONDLY WEEKLY HOURLY YEARLY
+%token INTERVAL COUNT UNTIL WKST MO SA SU TU WE TH FR 
+
+%token BIT8 ACCEPTED ADD AUDIO BASE64 BINARY BOOLEAN BUSY BUSYTENTATIVE
+%token BUSYUNAVAILABLE CALADDRESS CANCEL CANCELLED CHAIR CHILD COMPLETED
+%token CONFIDENTIAL CONFIRMED COUNTER DATE DATETIME DECLINECOUNTER DECLINED
+%token DELEGATED DISPLAY DRAFT DURATION EMAIL END FINAL FLOAT FREE GREGORIAN
+%token GROUP INDIVIDUAL INPROCESS INTEGER NEEDSACTION NONPARTICIPANT
+%token OPAQUE OPTPARTICIPANT PARENT PERIOD PRIVATE PROCEDURE PUBLIC PUBLISH
+%token RECUR REFRESH REPLY REQPARTICIPANT REQUEST RESOURCE ROOM SIBLING
+%token START TENTATIVE TEXT THISANDFUTURE THISANDPRIOR TIME TRANSPAENT
+%token UNKNOWN UTCOFFSET XNAME
+
+%token ALTREP CN CUTYPE DAYLIGHT DIR ENCODING EVENT FBTYPE FMTTYPE LANGUAGE 
+%token MEMBER PARTSTAT RANGE RELATED RELTYPE ROLE RSVP SENTBY STANDARD URI
+
+%token TIME_CHAR UTC_CHAR
+
+
+%%
+
+value:
+        date_value
+        | datetime_value
+        | duration_value
+        | period_value
+        | utcoffset_value
+        | error { 
+                  icalparser_yy_value = 0;
+                  icalparser_clear_flex_input();
+                  yyclearin;
+                  }
+
+
+date_value: DIGITS
+        {
+            struct icaltimetype stm;
+
+            stm = fill_datetime($1,0);
+
+            stm.hour = -1;
+            stm.minute = -1;
+            stm.second = -1;
+            stm.is_utc = 0;
+            stm.is_date = 1;
+
+            icalparser_yy_value = icalvalue_new_date(stm);
+        }
+
+utc_char: 
+        /*empty*/  {utc = 0;}
+        | UTC_CHAR {utc = 1;}
+
+/* This is used in the period_value, where there may be two utc characters per rule. */
+utc_char_b: 
+        /*empty*/  {utc_b = 0;}
+        | UTC_CHAR {utc_b = 1;}
+
+datetime_value: 
+        DIGITS TIME_CHAR DIGITS utc_char
+        {
+            struct  icaltimetype stm;
+            stm = fill_datetime($1, $3);
+            stm.is_utc = utc;
+            stm.is_date = 0;
+
+            icalparser_yy_value = 
+                icalvalue_new_datetime(stm);
+        }
+
+
+/* Duration */
+
+
+dur_date: dur_day
+        | dur_day dur_time
+
+dur_week: DIGITS 'W'
+        {
+            duration.weeks = atoi($1);
+        }
+
+dur_time: TIME_CHAR dur_hour 
+        {
+        }
+        | TIME_CHAR dur_minute
+        {
+        }
+        | TIME_CHAR dur_second
+        {
+        }
+
+dur_hour: DIGITS 'H'
+        {
+            duration.hours = atoi($1);
+        }
+        | DIGITS 'H' dur_minute
+        {
+            duration.hours = atoi($1);
+        }
+
+dur_minute: DIGITS 'M'
+        {
+            duration.minutes = atoi($1);
+        }
+        | DIGITS 'M' dur_second
+        {
+            duration.minutes = atoi($1);
+        }
+
+dur_second: DIGITS 'S'
+        {
+            duration.seconds = atoi($1);
+        }
+
+dur_day: DIGITS 'D'
+        {
+            duration.days = atoi($1);
+        }
+
+dur_prefix: /* empty */
+        {
+            duration.is_neg = 0;
+        } 
+        | '+'
+        {
+            duration.is_neg = 0;
+        }
+        | '-'
+        { 
+            duration.is_neg = 1;
+        }
+
+duration_value: dur_prefix 'P' dur_date
+        { 
+            icalparser_yy_value = icalvalue_new_duration(duration); 
+            memset(&duration,0, sizeof(duration));
+        }
+        | dur_prefix 'P' dur_time
+        { 
+            icalparser_yy_value = icalvalue_new_duration(duration); 
+            memset(&duration,0, sizeof(duration));
+        }
+        | dur_prefix 'P' dur_week
+        { 
+            icalparser_yy_value = icalvalue_new_duration(duration); 
+            memset(&duration,0, sizeof(duration));
+        }
+
+
+/* Period */
+
+period_value:  DIGITS TIME_CHAR DIGITS utc_char '/'  DIGITS TIME_CHAR DIGITS utc_char_b
+        {
+            struct icalperiodtype p;
+        
+            p.start = fill_datetime($1,$3);
+            p.start.is_utc = utc;
+            p.start.is_date = 0;
+
+
+            p.end = fill_datetime($6,$8);
+            p.end.is_utc = utc_b;
+            p.end.is_date = 0;
+                
+            p.duration.days = -1;
+            p.duration.weeks = -1;
+            p.duration.hours = -1;
+            p.duration.minutes = -1;
+            p.duration.seconds = -1;
+
+            icalparser_yy_value = icalvalue_new_period(p);
+        }
+        | DIGITS TIME_CHAR DIGITS utc_char '/'  duration_value
+        {
+            struct icalperiodtype p;
+            
+            p.start = fill_datetime($1,$3);
+            p.start.is_utc = utc;
+            p.start.is_date = 0;
+
+            p.end.year = -1;
+            p.end.month = -1;
+            p.end.day = -1;
+            p.end.hour = -1;
+            p.end.minute = -1;
+            p.end.second = -1;
+                   
+            /* The duration_value rule setes the global 'duration'
+               variable, but it also creates a new value in
+               icalparser_yy_value. So, free that, then copy
+               'duration' into the icalperiodtype struct. */
+
+            p.duration = icalvalue_get_duration(icalparser_yy_value);
+            icalvalue_free(icalparser_yy_value);
+            icalparser_yy_value = 0;
+
+            icalparser_yy_value = icalvalue_new_period(p);
+
+        }
+
+
+trigger: 
+        
+
+
+/* UTC Offset */
+
+plusminus: '+' { utcsign = 1; }
+        | '-' { utcsign = -1; }
+
+utcoffset_value: 
+        plusminus INTNUMBER INTNUMBER
+        {
+            icalparser_yy_value = icalvalue_new_utcoffset( utcsign * ($2*3600) + ($3*60) );
+          }
+
+        | plusminus INTNUMBER INTNUMBER INTNUMBER
+        {
+            icalparser_yy_value = icalvalue_new_utcoffset(utcsign * ($2*3600) + ($3*60) +($4));
+          }
+
+%%
+
+struct icaltimetype fill_datetime(char* datestr, char* timestr)
+{
+            struct icaltimetype stm;
+
+            memset(&stm,0,sizeof(stm));
+
+            if (datestr != 0){
+                sscanf(datestr,"%4d%2d%2d",&(stm.year), &(stm.month), 
+                       &(stm.day));
+            }
+
+            if (timestr != 0){
+                sscanf(timestr,"%2d%2d%2d", &(stm.hour), &(stm.minute), 
+                       &(stm.second));
+            }
+
+            return stm;
+
+}
+
+void ical_yyerror(char* s)
+{
+    /*fprintf(stderr,"Parse error \'%s\'\n", s);*/
+}
+
diff --git a/libical/src/libical/libical.pro b/libical/src/libical/libical.pro
new file mode 100644
index 0000000..9cc3983
--- a/dev/null
+++ b/libical/src/libical/libical.pro
@@ -0,0 +1,68 @@
+include(../../../variables.pri)
+
+        TEMPLATE= lib
+
+TARGET          = ical
+DESTDIR = ../../lib
+
+win32: DEFINES += _WIN32
+
+        CONFIG  += staticlib 
+
+        HEADERS         = \
+                  icalattendee.h \
+                  icalcomponent.h \
+                  icalderivedparameter.h \
+                  icalderivedproperty.h \
+                  icalderivedvalue.h \
+                  icalduration.h \
+                  icalenums.h \
+                  icalerror.h \
+                  icallangbind.h \
+                  icalmemory.h \
+                  icalmime.h \
+                  icalparameter.h \
+                  icalparameterimpl.h \
+                  icalparser.h \
+                  icalperiod.h \
+                  icalproperty.h \
+                  icalrecur.h \
+                  icalrestriction.h \
+                  icaltime.h \
+                  icaltypes.h \
+                  icalvalue.h \
+                  icalvalueimpl.h \
+                  icalversion.h \
+                  icalyacc.h \
+                  pvl.h \
+                  sspm.h
+                  
+        SOURCES         = icalattendee.c \
+                  icalcomponent.c \
+                  icalderivedparameter.c \
+                  icalderivedproperty.c \
+                  icalderivedvalue.c \
+                  icalduration.c \
+                  icalenums.c \
+                  icalerror.c \
+                  icallangbind.c \
+                  icallexer.c \
+                  icalmemory.c \
+                  icalmime.c \
+                  icalparameter.c \
+                  icalparser.c \
+                  icalperiod.c \
+                  icalproperty.c \
+                  icalrecur.c \
+                  icalrestriction.c \
+                  icaltime.c \
+                  icaltypes.c \
+                  icalvalue.c \
+                  icalyacc.c \
+                  pvl.c \
+                  sspm.c \
+                  vsnprintf.c
+
+        INTERFACES= 
+
+INCLUDEPATH     += .
diff --git a/libical/src/libical/libicalE.pro b/libical/src/libical/libicalE.pro
new file mode 100644
index 0000000..2b9b720
--- a/dev/null
+++ b/libical/src/libical/libicalE.pro
@@ -0,0 +1,66 @@
+        TEMPLATE= lib
+        CONFIG  = warn_on staticlib
+
+INCLUDEPATH     += .
+OBJECTS_DIR = obj/$(PLATFORM)
+MOC_DIR = moc/$(PLATFORM)
+DESTDIR=../../lib/$(PLATFORM)
+TARGET          = ical
+INTERFACES = \
+
+HEADERS = \
+ ical.h \
+ icalattendee.h \
+ icalcomponent.h \
+ icalderivedparameter.h \
+ icalderivedproperty.h \
+ icalderivedvalue.h \
+ icalduration.h \
+ icalenums.h \
+ icalerror.h \
+ icallangbind.h \
+ icalmemory.h \
+ icalmime.h \
+ icalparameter.h \
+ icalparameterimpl.h \
+ icalparser.h \
+ icalperiod.h \
+ icalproperty.h \
+ icalrecur.h \
+ icalrestriction.h \
+ icaltime.h \
+ icaltypes.h \
+ icalvalue.h \
+ icalvalueimpl.h \
+ icalversion.h \
+ icalyacc.h \
+ pvl.h \
+ sspm.h \
+
+SOURCES = \
+ icalattendee.c \
+ icalcomponent.c \
+ icalderivedparameter.c \
+ icalderivedproperty.c \
+ icalderivedvalue.c \
+ icalduration.c \
+ icalenums.c \
+ icalerror.c \
+ icallangbind.c \
+ icallexer.c \
+ icalmemory.c \
+ icalmime.c \
+ icalparameter.c \
+ icalparser.c \
+ icalperiod.c \
+ icalproperty.c \
+ icalrecur.c \
+ icalrestriction.c \
+ icaltime.c \
+ icaltypes.c \
+ icalvalue.c \
+ icalyacc.c \
+ pvl.c \
+ sspm.c \
+ vsnprintf.c \
+
diff --git a/libical/src/libical/pvl.c b/libical/src/libical/pvl.c
new file mode 100644
index 0000000..2a733e8
--- a/dev/null
+++ b/libical/src/libical/pvl.c
@@ -0,0 +1,761 @@
+/*======================================================================
+ FILE: pvl.c
+ CREATOR: eric November, 1995
+
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+======================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "pvl.h"
+#include <errno.h>
+#include <assert.h>
+#include <stdlib.h>
+
+
+
+/*
+  struct pvl_list_t
+
+  The list structure. This is the hanlde for the entire list 
+
+  This type is also private. Use pvl_list instead 
+
+  */
+
+typedef struct pvl_list_t
+{
+                int MAGIC;              /* Magic Identifier */
+                struct pvl_elem_t *head;/* Head of list */
+                struct pvl_elem_t *tail;/* Tail of list */
+                int count;              /* Number of items in the list */
+                struct pvl_elem_t *p;   /* Pointer used for iterators */
+} pvl_list_t;
+
+
+
+
+/* This global is incremented for each call to pvl_new_element(); it gives each
+ * list a unique identifer */
+
+int pvl_elem_count = 0;
+int pvl_list_count = 0;
+
+
+/*----------------------------------------------------------------------
+  Function: pvl_list pvl_newlist()
+ 
+  Purpose:
+
+  Creates a new list, clears the pointers and assigns a magic number
+
+  Returns:
+
+  Pointer to the new list
+  0 if there is no available memory. 
+  *----------------------------------------------------------------------*/
+
+pvl_list 
+pvl_newlist()
+{
+    struct pvl_list_t *L;
+
+    if ( ( L = (struct pvl_list_t*)malloc(sizeof(struct pvl_list_t))) == 0)
+    {
+        errno = ENOMEM;
+        return 0;
+    }
+
+    L->MAGIC = pvl_list_count;
+    pvl_list_count++;
+    L->head = 0;
+    L->tail = 0;
+    L->count = 0;
+    L->p = 0;
+
+    return L;
+}
+
+void
+pvl_free(pvl_list l)
+{
+   struct pvl_list_t *L = (struct pvl_list_t *)l;
+
+   pvl_clear(l);
+
+   free(L);
+}
+
+/*----------------------------------------------------------------------
+  Function: pvl_new_element(void *d, struct pvl_elem_t *next,struct pvl_elem_t *prior)
+ 
+  Purpose:
+  Creates a new list element, assigns a magic number, and assigns 
+  the next and previous pointers. 
+
+  Passing in the next and previous points may seem odd, but it allos the user
+  to set them while keeping the internal data hidden. In nearly all cases, 
+  the user is the pvl library itself. 
+
+  Parameters:
+
+          dThe data item to be stored in the list
+  next  Pointer value to assign to the member "next"
+  prior Pointer value to assign to the member "prior"
+
+  Returns:
+  
+  A pointer to the new element.
+  0 if there is no memory available. 
+
+  *----------------------------------------------------------------------*/
+
+pvl_elem 
+pvl_new_element(void *d, pvl_elem next,pvl_elem prior)
+{
+    struct pvl_elem_t *E;
+
+    if ( ( E = (struct pvl_elem_t*)malloc(sizeof(struct pvl_elem_t))) == 0)
+    {
+        errno = ENOMEM;
+        return 0;
+    }
+
+    E->MAGIC = pvl_elem_count++;
+    E->d = d;
+    E->next = next;
+    E->prior = prior;
+
+    return (pvl_elem)E;
+}
+
+/*----------------------------------------------------------------------
+  Function: pvl_unshift(pvl_list l,void *d)
+ 
+  Purpose:
+
+  Add a new element to the from of the list
+
+  Parameters:
+
+          lThe list to add the item to 
+          dPointer to the item to add
+
+  Returns:
+  *----------------------------------------------------------------------*/
+
+void 
+pvl_unshift(pvl_list l,void *d)
+{
+    struct pvl_list_t *L = (struct pvl_list_t *)l;
+    struct pvl_elem_t *E = pvl_new_element(d,L->head,0);
+
+    if (E->next != 0)
+    {
+        /* Link the head node to it */
+        E->next->prior = E;
+    }
+
+    /* move the head */
+    L->head = E;
+
+    /* maybe move the tail */
+  
+    if (L->tail == 0)
+    {
+        L->tail = E;
+    }
+
+    L->count++;
+}
+
+/*----------------------------------------------------------------------
+  Function: pvl_shift(pvl_list l)
+ 
+  Purpose:
+
+  Remove an element from the front of the list 
+
+  Parameters:
+
+          lThe list to operate on
+
+  Returns:
+  *----------------------------------------------------------------------*/
+
+void* 
+pvl_shift(pvl_list l)
+{
+    struct pvl_list_t *L = (struct pvl_list_t *)l;
+
+    if (L->head == 0)
+    {
+        return 0;
+    }
+
+    return pvl_remove(l,(void*)L->head);
+
+}
+
+/*----------------------------------------------------------------------
+  Function: void  pvl_push(pvl_list l,void *d)
+
+  Purpose:
+
+  Add a new item to the tail of the list
+
+  Paramters:
+
+          lThe list to operate on
+          dPointer to the item to add
+
+  Returns:
+  *----------------------------------------------------------------------*/
+
+void 
+pvl_push(pvl_list l,void *d)
+{
+    struct pvl_list_t *L = (struct pvl_list_t *)l;
+    struct pvl_elem_t *E = pvl_new_element(d,0,L->tail);
+
+    /* These are done in pvl_new_element
+       E->next = 0;
+       E->prior = L->tail;
+    */
+
+    if (L->tail != 0) 
+    {
+        L->tail->next = E;
+    }
+
+    if (L->head == 0) 
+    {
+        L->head = E;
+    }
+  
+    L->tail = E;
+
+    L->count++;
+
+}
+
+/*----------------------------------------------------------------------
+  Function: void*  pvl_pop(pvl_list l)
+
+  Purpose:
+
+  Remove an element from the tail of the list 
+
+  Paramters:
+
+          lThe list to operate on
+
+  Returns:
+  *----------------------------------------------------------------------*/
+
+void* 
+pvl_pop(pvl_list l)
+{
+
+    struct pvl_list_t *L = (struct pvl_list_t *)l;
+
+    if ( L->tail == 0)
+    {
+        return 0;
+    }
+
+    return pvl_remove(l,(void*) L->tail);;
+
+}
+
+
+/*----------------------------------------------------------------------
+  Function: void pvl_insert_ordered(pvl_list l,pvl_comparef f,void *d)
+
+  Purpose:
+  
+  Add a new item to a list that is ordered by a comparison function. 
+  This routine assumes that the list is properly ordered. 
+
+          lThe list to operate on
+          fPointer to a comparison function
+  d     Pointer to data to pass to the comparison function
+
+  Returns:
+
+  void
+
+  *----------------------------------------------------------------------*/
+
+void 
+pvl_insert_ordered(pvl_list l,pvl_comparef f,void *d)
+{
+    struct pvl_list_t *L = (struct pvl_list_t *)l;
+
+    struct pvl_elem_t *P;
+
+    L->count++;
+
+    /* Empty list, add to head */
+
+    if(L->head == 0)
+    {
+        pvl_unshift(l,d);
+        return;
+    }
+
+    /* smaller than head, add to head */
+
+    if ( ((*f)(d,L->head->d)) <= 0)
+    { 
+        pvl_unshift(l,d);
+        return;
+    }
+
+    /* larger than tail, add to tail */
+    if ( (*f)(d,L->tail->d) >= 0)
+    { 
+        pvl_push(l,d);
+        return;
+    }
+
+
+    /* Search for the first element that is smaller, and add before it */
+    
+    for (P=L->head; P != 0; P = P->next)
+    {
+        if ( (*f)(P->d,d) >= 0)
+        {
+            pvl_insert_before(l,P,d);
+            return;
+        }
+    }
+
+    /* badness, choke */
+
+    assert(0);
+
+}
+
+/*----------------------------------------------------------------------
+  Function: void  pvl_insert_after(pvl_list l,pvl_elem p,void *d)
+
+  Purpose:
+
+  Add a new item after the referenced element. 
+
+  Parameters:
+
+          lThe list to operate on 
+          pThe list element to add the item after
+          dPointer to the item to add. 
+
+  Returns:
+
+  void
+
+  *----------------------------------------------------------------------*/
+
+void 
+pvl_insert_after(pvl_list l,pvl_elem p,void *d)
+{
+    struct pvl_list_t *L = (struct pvl_list_t *)l;
+    struct pvl_elem_t *P = (struct pvl_elem_t *)p;
+    struct pvl_elem_t *E = 0;
+
+    L->count++;
+
+    if (P == 0)
+    {
+        pvl_unshift(l,d);
+        return;
+    }
+
+    if ( P == L->tail)
+    {
+        E = pvl_new_element(d,0,P);
+        L->tail = E;
+        E->prior->next = E;
+    }
+    else
+    {
+        E = pvl_new_element(d,P->next,P);
+        E->next->prior  = E;
+        E->prior->next = E;
+    }
+}
+
+/*----------------------------------------------------------------------
+  Function: void pvl_insert_before(pvl_list l,pvl_elem p,void *d)
+
+  Purpose:
+
+  Add an item after a referenced item
+
+  Parameters:
+
+          lThe list to operate on
+          pThe list element to add the item before
+          dPointer to the data to be added. 
+
+  Returns:
+  *----------------------------------------------------------------------*/
+
+void 
+pvl_insert_before(pvl_list l,pvl_elem p,void *d)
+{
+    struct pvl_list_t *L = (struct pvl_list_t *)l;
+    struct pvl_elem_t *P = (struct pvl_elem_t *)p;
+    struct pvl_elem_t *E = 0;
+
+    L->count++;
+
+    if (P == 0)
+    {
+        pvl_unshift(l,d);
+        return;
+    }
+
+    if ( P == L->head)
+    {
+        E = pvl_new_element(d,P,0);
+        E->next->prior = E;
+        L->head = E;
+    }
+    else
+    {
+        E = pvl_new_element(d,P,P->prior);
+        E->prior->next = E;
+        E->next->prior = E;
+    }
+}
+
+/*----------------------------------------------------------------------
+  Function: void pvl_remove(pvl_list l,pvl_elem e)
+ 
+  Purpose:
+
+  Remove the referenced item from the list
+
+  This routine will free the element, but not the data item that the
+  element contains. 
+
+  Parameters:
+
+          lThe list to operate on
+          eThe element to remove. 
+
+  Returns:
+  *----------------------------------------------------------------------*/
+
+void* 
+pvl_remove(pvl_list l,pvl_elem e)
+{
+    struct pvl_list_t *L = (struct pvl_list_t *)l;
+    struct pvl_elem_t *E = (struct pvl_elem_t *)e;
+    void* data;
+
+    if (E == L->head)
+    {
+        if (E->next != 0)
+        {
+            E->next->prior = 0;
+            L->head = E->next;
+        } else {
+            /* E Also points to tail -> only one element in list */
+            L->tail = 0;
+            L->head = 0;
+        }
+    }
+    else if (E == L->tail)
+    {
+        if (E->prior != 0)
+        {
+            E->prior->next = 0;
+            L->tail = E->prior;
+        } else {
+            /* E points to the head, so it was the last element */
+            /* This case should be taken care of in the previous clause */
+            L->head = 0;
+            L->tail = 0;
+        }
+    }
+    else
+    {
+        E->prior->next = E->next;
+        E->next->prior = E->prior;
+    }
+
+
+    L->count--;
+
+    data = E->d; 
+
+    E->prior = 0;
+    E->next = 0;
+    E->d = 0;
+
+    free(E);
+
+    return data;
+
+}
+
+/*----------------------------------------------------------------------
+  Function: pvl_elem pvl_find(pvl_list l,pvl_findf f,void* v)
+
+  Purpose:
+
+  Return a pointer to data that satisfies a function
+
+  This routine will interate through the entire list and call the
+  find function for each item. It will break and return a pointer to the
+  data that causes the find function to return 1.
+
+  Parameters:
+
+          lThe list to operate on
+          fPointer to the find function
+          vPointer to constant data to pass into the function
+
+  Returns:
+
+  Pointer to the element that the find function found. 
+
+  *----------------------------------------------------------------------*/
+
+pvl_elem
+pvl_find(pvl_list l,pvl_findf f,void* v)
+{
+    pvl_elem e;
+    
+    for (e=pvl_head(l); e!= 0; e = pvl_next(e))
+    {
+        if ( (*f)(((struct pvl_elem_t *)e)->d,v) == 1)
+        {
+            /* Save this elem for a call to find_next */
+            ((struct pvl_list_t *)l)->p = e;
+            return e;
+        }
+    }
+    
+    return 0;
+
+}
+/*----------------------------------------------------------------------
+  Function: void*  pvl_find_next(pvl_list l,pvl_findf f,void* v)
+
+  Purpose:
+
+  Like pvl_find(), but continues the search where the last find() or
+  find_next() left off
+
+  Parameters:
+
+          lThe list to operate on
+          fPointer to the find function
+          vPointer to constant data to pass into the function
+
+  Returns:
+
+  Pointer to the element that the find function found. 
+
+  *----------------------------------------------------------------------*/
+
+pvl_elem
+pvl_find_next(pvl_list l,pvl_findf f,void* v)
+{
+    
+    pvl_elem e;
+    
+    for (e=pvl_head(l); e!= 0; e = pvl_next(e))
+    {
+        if ( (*f)(((struct pvl_elem_t *)e)->d,v) == 1)
+        {
+            /* Save this elem for a call to find_next */
+            ((struct pvl_list_t *)l)->p = e;
+            return e;
+        }
+    }
+
+    return 0;
+
+}
+
+/*----------------------------------------------------------------------
+  Function: void pvl_clear(pvl_list l)
+
+  Purpose:
+  
+  Remove the all the elements in the list. The does not free the data items
+  the elements hold. 
+
+
+  Returns:
+  *----------------------------------------------------------------------*/
+
+void 
+pvl_clear(pvl_list l)
+{
+    pvl_elem e = pvl_head(l);
+    pvl_elem next;
+
+    if (e == 0) {
+        return;
+    }
+
+    while(e != 0)
+    {
+        next = pvl_next(e);
+        pvl_remove(l,e);
+        e = next;
+    }
+}
+
+/*----------------------------------------------------------------------
+  Function: int pvl_count(pvl_list l)
+
+  Purpose:
+
+  Returns the number of items in the list. 
+
+  Returns:
+  *----------------------------------------------------------------------*/
+
+int 
+pvl_count(pvl_list l)
+{
+    struct pvl_list_t *L = (struct pvl_list_t *)l;
+
+    return L->count;
+}
+
+
+/*----------------------------------------------------------------------
+  Function: pvl_elem  pvl_next(pvl_elem e)
+ 
+  Purpose: 
+  Returns a pointer to the given element 
+
+  Returns:
+  *----------------------------------------------------------------------*/
+
+pvl_elem 
+pvl_next(pvl_elem e)
+{
+    struct pvl_elem_t *E = (struct pvl_elem_t *)e;
+
+    if (E == 0){
+        return 0;
+    }
+
+    return (pvl_elem)E->next;
+}
+
+/*----------------------------------------------------------------------
+  Function: pvl_elem  pvl_prior(pvl_elem e)
+
+  Purpose:
+
+  Returns a pointer to the element previous to the element given. 
+
+  Returns:
+  *----------------------------------------------------------------------*/
+
+pvl_elem 
+pvl_prior(pvl_elem e)
+{
+    struct pvl_elem_t *E = (struct pvl_elem_t *)e;
+
+    return (pvl_elem)E->prior;
+}
+
+/*----------------------------------------------------------------------
+  Function: pvl_elem  pvl_head(pvl_list l )
+ 
+  Purpose:
+  
+  Returns a pointer to the first item in the list. 
+
+  Returns:
+  *----------------------------------------------------------------------*/
+pvl_elem 
+pvl_head(pvl_list l )
+{
+    struct pvl_list_t *L = (struct pvl_list_t *)l;
+
+    return (pvl_elem)L->head;
+}
+
+/*----------------------------------------------------------------------
+  Function: pvl_elem  pvl_tail(pvl_list l)
+ 
+  Purpose:
+
+  Returns a pointer to the last item in the list. 
+
+  Returns:
+  *----------------------------------------------------------------------*/
+pvl_elem 
+pvl_tail(pvl_list l)
+{
+    struct pvl_list_t *L = (struct pvl_list_t *)l;
+    return (pvl_elem)L->tail;
+}
+
+/*----------------------------------------------------------------------
+  Function:
+ 
+
+  Purpose:
+
+
+  Returns:
+  *----------------------------------------------------------------------*/
+
+#ifndef PVL_USE_MACROS
+void* 
+pvl_data(pvl_elem e)
+{
+    struct pvl_elem_t *E = (struct pvl_elem_t *)e;
+  
+    if ( e == 0){
+        return 0;
+    }
+
+    return E->d;
+}
+#endif
+
+/*----------------------------------------------------------------------
+  Function: void  pvl_apply(pvl_list l,pvl_applyf f, void *v)
+ 
+  Purpose:
+
+  Call a function for every item in the list. 
+
+  Paramters: 
+
+          lThe list to operate on
+          fPointer to the function to call
+          vData to pass to the function on every iteration
+
+  Returns:
+
+  void
+  *----------------------------------------------------------------------*/
+
+void 
+pvl_apply(pvl_list l,pvl_applyf f, void *v)
+{
+    pvl_elem e;
+
+    for (e=pvl_head(l); e!= 0; e = pvl_next(e))
+    {
+        (*f)(((struct pvl_elem_t *)e)->d,v);
+    }
+
+}
diff --git a/libical/src/libical/pvl.h b/libical/src/libical/pvl.h
new file mode 100644
index 0000000..14a15a1
--- a/dev/null
+++ b/libical/src/libical/pvl.h
@@ -0,0 +1,94 @@
+/*======================================================================
+ FILE: pvl.h
+ CREATOR: eric November, 1995
+
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+======================================================================*/
+
+
+#ifndef __PVL_H__
+#define __PVL_H__
+
+typedef void* pvl_list;
+typedef void* pvl_elem;
+
+/*
+  struct pvl_elem_t
+
+  This type is private. Always use pvl_elem instead. The struct would
+  not even appear in this header except to make code in the USE_MACROS
+  blocks work
+
+  */
+typedef struct pvl_elem_t
+{
+                int MAGIC;              /* Magic Identifier */
+                void *d;                /* Pointer to data user is storing */
+                struct pvl_elem_t *next;/* Next element */
+                struct pvl_elem_t *prior;/* prior element */
+} pvl_elem_t;
+
+
+
+/* This global is incremented for each call to pvl_new_element(); it gives each
+ * list a unique identifer */
+
+extern int  pvl_elem_count;
+extern int  pvl_list_count;
+
+/* Create new lists or elements */
+pvl_elem pvl_new_element(void* d, pvl_elem next,pvl_elem prior);
+pvl_list pvl_newlist(void);
+void pvl_free(pvl_list);
+
+/* Add, remove, or get the head of the list */
+void pvl_unshift(pvl_list l,void *d);
+void* pvl_shift(pvl_list l);
+pvl_elem pvl_head(pvl_list);
+
+/* Add, remove or get the tail of the list */
+void pvl_push(pvl_list l,void *d);
+void* pvl_pop(pvl_list l);
+pvl_elem pvl_tail(pvl_list);
+
+/* Insert elements in random places */
+typedef int (*pvl_comparef)(void* a, void* b); /* a, b are of the data type*/
+void pvl_insert_ordered(pvl_list l,pvl_comparef f,void *d);
+void pvl_insert_after(pvl_list l,pvl_elem e,void *d);
+void pvl_insert_before(pvl_list l,pvl_elem e,void *d);
+
+/* Remove an element, or clear the entire list */
+void* pvl_remove(pvl_list,pvl_elem); /* Remove element, return data */
+void pvl_clear(pvl_list); /* Remove all elements, de-allocate all data */
+
+int pvl_count(pvl_list);
+
+/* Navagate the list */
+pvl_elem pvl_next(pvl_elem e);
+pvl_elem pvl_prior(pvl_elem e);
+
+/* get the data in the list */
+#ifndef PVL_USE_MACROS
+void* pvl_data(pvl_elem);
+#else
+#define pvl_data(x) x==0 ? 0 : ((struct pvl_elem_t *)x)->d;
+#endif
+
+
+/* Find an element for which a function returns true */
+typedef int (*pvl_findf)(void* a, void* b); /*a is list elem, b is other data*/
+pvl_elem pvl_find(pvl_list l,pvl_findf f,void* v);
+pvl_elem pvl_find_next(pvl_list l,pvl_findf f,void* v);
+
+/* Pass each element in the list to a function */
+typedef void (*pvl_applyf)(void* a, void* b); /*a is list elem, b is other data*/
+void pvl_apply(pvl_list l,pvl_applyf f, void *v);
+
+
+#endif /* __PVL_H__ */
+
+
+
+
+
diff --git a/libical/src/libical/sspm.c b/libical/src/libical/sspm.c
new file mode 100644
index 0000000..2df581b
--- a/dev/null
+++ b/libical/src/libical/sspm.c
@@ -0,0 +1,1621 @@
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: sspm.c Parse Mime
+  CREATOR: eric 25 June 2000
+  
+  $Id$
+  $Locker$
+    
+ The contents of this file are subject to the Mozilla Public License
+ Version 1.0 (the "License"); you may not use this file except in
+ compliance with the License. You may obtain a copy of the License at
+ http://www.mozilla.org/MPL/
+ 
+ Software distributed under the License is distributed on an "AS IS"
+ basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+ the License for the specific language governing rights and
+ limitations under the License.
+ 
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The Initial Developer of the Original Code is Eric Busboom
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+ ======================================================================*/
+
+#include <stdio.h>
+#include <string.h>
+#include "sspm.h"
+#include <assert.h>
+#include <ctype.h> /* for tolower */
+#include <stdlib.h>   /* for malloc, free */
+#include <string.h> /* for strcasecmp */
+
+// Eugen C. <eug@thekompany.com>
+#ifdef _WIN32
+#define strcasecmp _stricmp
+#endif
+// Eugen C. <eug@thekompany.com>
+
+int snprintf(char *str, size_t n, char const *fmt, ...);
+
+#ifdef DMALLOC
+#include "dmalloc.h"
+#endif
+
+#define TMP_BUF_SIZE 1024
+
+
+enum mime_state {
+    UNKNOWN_STATE,
+    IN_HEADER,
+    END_OF_HEADER,
+    IN_BODY,
+    OPENING_PART,
+    END_OF_PART,
+    TERMINAL_END_OF_PART,
+    END_OF_INPUT
+};
+
+struct mime_impl{
+        struct sspm_part *parts; 
+        size_t max_parts;
+        int part_no;
+        int level;
+        struct sspm_action_map *actions;
+        char* (*get_string)(char *s, size_t size, void* data);
+        void* get_string_data;
+        char temp[TMP_BUF_SIZE];
+        enum mime_state state;
+};
+
+void sspm_free_header(struct sspm_header *header);
+void* sspm_make_multipart_part(struct mime_impl *impl,struct sspm_header *header);
+void sspm_read_header(struct mime_impl *impl,struct sspm_header *header);
+
+char* sspm_strdup(char* str){
+
+    char* s;
+
+    s = strdup(str);
+
+    return s;
+}
+
+
+struct  major_content_type_map 
+{
+        enum sspm_major_type type;
+        char* str;
+        
+} major_content_type_map[]  = 
+{
+    {SSPM_MULTIPART_MAJOR_TYPE,"multipart" },
+    {SSPM_TEXT_MAJOR_TYPE,"text" },
+    {SSPM_TEXT_MAJOR_TYPE,"text" },
+    {SSPM_IMAGE_MAJOR_TYPE,"image" },
+    {SSPM_AUDIO_MAJOR_TYPE,"audio" },
+    {SSPM_VIDEO_MAJOR_TYPE,"video" },
+    {SSPM_APPLICATION_MAJOR_TYPE,"application" },
+    {SSPM_MULTIPART_MAJOR_TYPE,"multipart" },
+    {SSPM_MESSAGE_MAJOR_TYPE,"message" },
+    {SSPM_UNKNOWN_MAJOR_TYPE,"" },
+};
+
+struct  minor_content_type_map 
+{
+        enum sspm_minor_type type;
+        char* str;
+
+} minor_content_type_map[]  = 
+{
+    {SSPM_ANY_MINOR_TYPE,"*" },
+    {SSPM_PLAIN_MINOR_TYPE,"plain" },
+    {SSPM_RFC822_MINOR_TYPE,"rfc822" },
+    {SSPM_DIGEST_MINOR_TYPE,"digest" },
+    {SSPM_CALENDAR_MINOR_TYPE,"calendar" },
+    {SSPM_MIXED_MINOR_TYPE,"mixed" },
+    {SSPM_RELATED_MINOR_TYPE,"related" },
+    {SSPM_ALTERNATIVE_MINOR_TYPE,"alternative" },
+    {SSPM_PARALLEL_MINOR_TYPE,  "parallel" },  
+    {SSPM_UNKNOWN_MINOR_TYPE,"" } 
+};
+
+
+
+struct encoding_map {
+        enum sspm_encoding encoding;
+        char* str;
+} sspm_encoding_map[] = 
+{
+    {SSPM_NO_ENCODING,""},
+    {SSPM_QUOTED_PRINTABLE_ENCODING,"quoted-printable"},
+    {SSPM_8BIT_ENCODING,"8bit"},
+    {SSPM_7BIT_ENCODING,"7bit"},
+    {SSPM_BINARY_ENCODING,"binary"},
+    {SSPM_BASE64_ENCODING,"base64"},
+    {SSPM_UNKNOWN_ENCODING,""}
+
+};
+
+
+char* sspm_get_parameter(char* line, char* parameter)
+{
+    char *p,*s,*q;
+    static char name[1024];
+    
+    /* Find where the parameter name is in the line */
+    p = strstr(line,parameter);
+
+    if( p == 0){
+        return 0;
+    }
+
+    /* skip over the parameter name, the '=' and any blank spaces */
+
+    p+=strlen(parameter);
+
+    while(*p==' ' || *p == '='){
+        p++;
+    }
+
+    /*now find the next semicolon*/
+
+    s = strchr(p,';');
+
+    /* Strip of leading quote */
+    q = strchr(p,'\"');
+
+    if(q !=0){
+        p = q+1;
+    }
+
+    if(s != 0){
+        strncpy(name,p,(size_t)s-(size_t)p);
+    } else {
+        strcpy(name,p);
+    }
+
+    /* Strip off trailing quote, if it exists */
+
+    q = strrchr(name,'\"');
+
+    if (q != 0){
+        *q='\0';
+    }
+    
+    return name;
+}
+
+char* sspm_property_name(char* line)
+{
+    static char name[1024];
+    char *c = strchr(line,':');
+
+    if(c != 0){
+        strncpy(name,line,(size_t)c-(size_t)line);
+        name[(size_t)c-(size_t)line] = '\0';
+        return name;
+    } else {
+        return 0;
+    }
+}
+
+char* sspm_value(char* line)
+{
+    static char value[1024];
+
+    char *c,*s, *p;
+
+    /* Find the first colon and the next semicolon */
+
+    c = strchr(line,':');
+    s = strchr(c,';');
+
+    /* Skip the colon */
+    c++;
+
+    if (s == 0){
+        s = c+strlen(line);
+    }
+
+    for(p=value; c != s; c++){
+        if(*c!=' ' && *c!='\n'){
+            *(p++) = *c;
+        }
+    }
+
+    *p='\0';
+
+    return value;
+
+}
+
+char *mime_headers[] = {
+    "Content-Type",
+    "Content-Transfer-Encoding",
+    "Content-Disposition",
+    "Content-Id",
+    "Mime-Version",
+    0 
+};
+
+
+void* sspm_default_new_part()
+{
+    return 0;
+}
+void sspm_default_add_line(void *part, struct sspm_header *header, 
+                           char* line, size_t size)
+{
+}
+
+void* sspm_default_end_part(void* part)
+{
+    return 0;
+}
+
+void sspm_default_free_part(void *part)
+{
+}
+
+
+
+struct sspm_action_map sspm_action_map[] = 
+{
+    {SSPM_UNKNOWN_MAJOR_TYPE,SSPM_UNKNOWN_MINOR_TYPE,sspm_default_new_part,sspm_default_add_line,sspm_default_end_part,sspm_default_free_part},
+};
+
+int sspm_is_mime_header(char *line)
+{
+    char *name = sspm_property_name(line);
+    int i;
+
+    if(name == 0){ 
+        return 0;
+    }
+
+    for(i = 0; mime_headers[i] != 0; i++){
+        if(strcasecmp(name, mime_headers[i]) == 0)
+            return 1;
+    }
+    
+    return 0;
+}
+
+int sspm_is_mail_header(char* line)
+{
+    char *name = sspm_property_name(line);
+
+    if (name != 0){
+        return 1;
+    }
+
+    return 0;
+
+}
+
+int sspm_is_blank(char* line)
+{
+    char *p;
+    char c =0;
+
+    for(p=line; *p!=0; p++){
+        if( ! (*p == ' '|| *p == '\t' || *p=='\n') ){
+            c++;
+        }
+    }
+
+    if (c==0){
+        return 1;
+    }
+
+    return 0;
+    
+}
+
+int sspm_is_continuation_line(char* line)
+{
+    if (line[0] == ' '|| line[0] == '\t' ) {
+        return 1;
+    }
+
+    return 0;
+}
+
+int sspm_is_mime_boundary(char *line)
+{
+    if( line[0] == '-' && line[1] == '-') {
+        return 1;
+    } 
+
+    return 0;
+}
+
+int sspm_is_mime_terminating_boundary(char *line)
+{
+
+
+    if (sspm_is_mime_boundary(line) &&
+        strstr(line,"--\n")){
+        return 1;
+    } 
+
+    return 0;
+}
+
+enum line_type {
+    EMPTY,
+    BLANK,
+    MIME_HEADER,
+    MAIL_HEADER,
+    HEADER_CONTINUATION,
+    BOUNDARY,
+    TERMINATING_BOUNDARY,
+    UNKNOWN_TYPE
+};
+
+
+enum line_type get_line_type(char* line){
+
+    if (line == 0){
+        return EMPTY;
+    } else if(sspm_is_blank(line)){
+        return BLANK;
+    } else if (sspm_is_mime_header(line)){
+        return MIME_HEADER;
+    } else if (sspm_is_mail_header(line)){
+        return MAIL_HEADER;
+    } else if (sspm_is_continuation_line(line)){
+        return HEADER_CONTINUATION;
+    } else if (sspm_is_mime_terminating_boundary(line)){
+        return TERMINATING_BOUNDARY;
+    } else if (sspm_is_mime_boundary(line)) {
+        return BOUNDARY;
+    } else {
+        return UNKNOWN_TYPE;
+    }
+
+
+}
+
+
+struct sspm_action_map get_action(struct mime_impl *impl,
+                                  enum sspm_major_type major,
+                                  enum sspm_minor_type minor)
+{
+    int i;
+
+    /* Read caller suppled action map */
+
+    if (impl->actions != 0){
+        for(i=0; impl->actions[i].major != SSPM_UNKNOWN_MAJOR_TYPE; i++){
+            if((major == impl->actions[i].major &&
+               minor == impl->actions[i].minor) ||
+               (major == impl->actions[i].major &&
+                minor == SSPM_ANY_MINOR_TYPE)){
+                return impl->actions[i];
+            }
+        }
+    }
+
+    /* Else, read default action map */
+
+    for(i=0; sspm_action_map[i].major != SSPM_UNKNOWN_MAJOR_TYPE; i++){
+            if((major == sspm_action_map[i].major &&
+               minor == sspm_action_map[i].minor) ||
+               (major == sspm_action_map[i].major &&
+                minor == SSPM_ANY_MINOR_TYPE)){
+            break;
+        }
+    }
+    
+    return sspm_action_map[i];
+}
+
+
+char* sspm_lowercase(char* str)
+{
+    char* p = 0;
+    char* new = sspm_strdup(str);
+
+    if(str ==0){
+        return 0;
+    }
+
+    for(p = new; *p!=0; p++){
+        *p = tolower(*p);
+    }
+
+    return new;
+}
+
+enum sspm_major_type sspm_find_major_content_type(char* type)
+{
+    int i;
+
+    char* ltype = sspm_lowercase(type);
+
+    for (i=0; major_content_type_map[i].type !=  SSPM_UNKNOWN_MINOR_TYPE; i++){
+        if(strncmp(ltype, major_content_type_map[i].str,
+                   strlen(major_content_type_map[i].str))==0){
+            free(ltype);
+            return major_content_type_map[i].type;
+        }
+    }
+    free(ltype);
+    return major_content_type_map[i].type; /* Should return SSPM_UNKNOWN_MINOR_TYPE */
+}
+
+enum sspm_minor_type sspm_find_minor_content_type(char* type)
+{
+    int i;
+    char* ltype = sspm_lowercase(type);
+
+    char *p = strchr(ltype,'/');
+
+    if (p==0){
+        return SSPM_UNKNOWN_MINOR_TYPE; 
+    }
+
+    p++; /* Skip the '/' */
+
+    for (i=0; minor_content_type_map[i].type !=  SSPM_UNKNOWN_MINOR_TYPE; i++){
+        if(strncmp(p, minor_content_type_map[i].str,
+                   strlen(minor_content_type_map[i].str))==0){
+            free(ltype);
+            return minor_content_type_map[i].type;
+        }
+    }
+    
+    free(ltype);
+    return minor_content_type_map[i].type; /* Should return SSPM_UNKNOWN_MINOR_TYPE */
+}
+
+char* sspm_major_type_string(enum sspm_major_type type)
+{
+    int i;
+
+    for (i=0; major_content_type_map[i].type !=  SSPM_UNKNOWN_MINOR_TYPE; 
+         i++){
+
+        if(type == major_content_type_map[i].type){
+            return major_content_type_map[i].str;
+        }
+    }
+    
+    return major_content_type_map[i].str; /* Should return SSPM_UNKNOWN_MINOR_TYPE */
+}
+
+char* sspm_minor_type_string(enum sspm_minor_type type)
+{
+    int i;
+    for (i=0; minor_content_type_map[i].type !=  SSPM_UNKNOWN_MINOR_TYPE; 
+         i++){
+        if(type == minor_content_type_map[i].type){
+            return minor_content_type_map[i].str;
+        }
+    }
+    
+    return minor_content_type_map[i].str; /* Should return SSPM_UNKNOWN_MINOR_TYPE */
+}
+
+
+char* sspm_encoding_string(enum sspm_encoding type)
+{
+    int i;
+    for (i=0; sspm_encoding_map[i].encoding !=  SSPM_UNKNOWN_ENCODING; 
+         i++){
+        if(type == sspm_encoding_map[i].encoding){
+            return sspm_encoding_map[i].str;
+        }
+    }
+    
+    return sspm_encoding_map[i].str; /* Should return SSPM_UNKNOWN_MINOR_TYPE */
+}
+
+/* Interpret a header line and add its data to the header
+   structure. */
+void sspm_build_header(struct sspm_header *header, char* line)
+{
+    char *prop;
+    char *val;
+    
+    val = sspm_strdup(sspm_value(line));
+    prop = sspm_strdup(sspm_property_name(line));
+
+    if(strcmp(prop,"Content-Type") == 0){
+        
+        /* Create a new mime_header, fill in content-type
+           and possibly boundary */
+        
+        char* boundary= sspm_get_parameter(line,"boundary");
+        
+        header->def = 0;
+        header->major = sspm_find_major_content_type(val);
+        header->minor = sspm_find_minor_content_type(val);
+        
+        if(header->minor == SSPM_UNKNOWN_MINOR_TYPE){
+            char *p = strchr(val,'/');
+            
+            if (p != 0){
+                p++; /* Skip the '/' */
+                
+                header->minor_text = sspm_strdup(p);
+            } else {
+                /* Error, malformed content type */
+                header->minor_text = sspm_strdup("unknown");
+            }
+        }
+        if (boundary != 0){
+            header->boundary = sspm_strdup(boundary);
+        }
+        
+    } else if(strcmp(prop,"Content-Transfer-Encoding")==0){
+        char* encoding = sspm_value(line);
+        char* lencoding = sspm_lowercase(encoding);
+
+        if(strcmp(lencoding,"base64")==0){
+            header->encoding = SSPM_BASE64_ENCODING;
+                } else if(strcmp(lencoding,"quoted-printable")==0){
+            header->encoding = SSPM_QUOTED_PRINTABLE_ENCODING;
+                } else if(strcmp(lencoding,"binary")==0){
+            header->encoding = SSPM_BINARY_ENCODING;
+                } else if(strcmp(lencoding,"7bit")==0){
+            header->encoding = SSPM_7BIT_ENCODING;
+                } else if(strcmp(lencoding,"8bit")==0){
+            header->encoding = SSPM_8BIT_ENCODING;
+        } else {
+            header->encoding = SSPM_UNKNOWN_ENCODING;
+        }
+
+
+        free(lencoding);
+
+        header->def = 0;
+        
+    } else if(strcmp(prop,"Content-Id")==0){
+        char* cid = sspm_value(line);
+        header->content_id = sspm_strdup(cid);
+        header->def = 0;
+        
+    }
+    free(val);
+    free(prop);
+}
+
+char* sspm_get_next_line(struct mime_impl *impl)
+{
+    char* s;
+    s = impl->get_string(impl->temp,TMP_BUF_SIZE,impl->get_string_data);
+    
+    if(s == 0){
+        impl->state = END_OF_INPUT;
+    }
+    return s;
+}
+
+
+void sspm_store_part(struct mime_impl *impl, struct sspm_header header,
+                      int level, void *part, size_t size)
+{
+    
+    impl->parts[impl->part_no].header = header;
+    impl->parts[impl->part_no].level = level;
+    impl->parts[impl->part_no].data = part;  
+    impl->parts[impl->part_no].data_size = size;  
+    impl->part_no++;
+}
+
+void sspm_set_error(struct sspm_header* header, enum sspm_error error,
+                    char* message)
+{
+    header->error = error;
+
+    if(header->error_text!=0){
+        free(header->error_text);
+    }
+
+    header->def = 0;
+
+    if(message != 0){
+        header->error_text = sspm_strdup(message);  
+    } else {
+        header->error_text = 0;
+    }
+
+}
+
+void* sspm_make_part(struct mime_impl *impl,
+                     struct sspm_header *header, 
+                     struct sspm_header *parent_header,
+                     void **end_part,
+                     size_t *size)
+{
+
+    /* For a single part type, read to the boundary, if there is a
+   boundary. Otherwise, read until the end of input.  This routine
+   assumes that the caller has read the header and has left the input
+   at the first blank line */
+
+    char *line;
+    void *part;
+    int end = 0;
+
+    struct sspm_action_map action = get_action(
+        impl,
+        header->major,
+        header->minor);
+
+    *size = 0;
+    part =action.new_part();
+
+    impl->state = IN_BODY;
+
+    while(end == 0 && (line = sspm_get_next_line(impl)) != 0){
+        
+        if(sspm_is_mime_boundary(line)){
+            
+            /* If there is a boundary, then this must be a multipart
+               part, so there must be a parent_header. */
+            if(parent_header == 0){
+                char* boundary;
+                end = 1;
+                *end_part = 0;
+
+                sspm_set_error(header,SSPM_UNEXPECTED_BOUNDARY_ERROR,line);
+
+                /* Read until the paired terminating boundary */
+                if((boundary = (char*)malloc(strlen(line)+5)) == 0){
+                    fprintf(stderr,"Out of memory");
+                    abort();
+                }
+                strcpy(boundary,line);
+                strcat(boundary,"--");
+                while((line = sspm_get_next_line(impl)) != 0){
+                    /*printf("Error: %s\n",line);*/
+                    if(strcmp(boundary,line)==0){
+                        break;
+                    }
+                }
+                free(boundary);
+
+                break;
+            }
+            
+            if(strncmp((line+2),parent_header->boundary,
+                       sizeof(parent_header->boundary)) == 0){
+                *end_part = action.end_part(part);
+
+                if(sspm_is_mime_boundary(line)){
+                    impl->state = END_OF_PART;
+                } else if ( sspm_is_mime_terminating_boundary(line)){
+                    impl->state = TERMINAL_END_OF_PART;
+                }
+                end = 1;
+            } else {
+                /* Error, this is not the correct terminating boundary*/
+
+                /* read and discard until we get the right boundary.  */
+                    char* boundary;
+                    char msg[256];
+
+                    snprintf(msg,256,
+                             "Expected: %s--. Got: %s",
+                             parent_header->boundary,line);
+
+                    sspm_set_error(parent_header,
+                      SSPM_WRONG_BOUNDARY_ERROR,msg);
+
+                    /* Read until the paired terminating boundary */
+                    if((boundary = (char*)malloc(strlen(line)+5)) == 0){
+                        fprintf(stderr,"Out of memory");
+                        abort();
+                            }    
+                    strcpy(boundary,line);
+                    strcat(boundary,"--");
+                    while((line = sspm_get_next_line(impl)) != 0){
+                        if(strcmp(boundary,line)==0){
+                            break;
+                        }
+                    }
+                    free(boundary);
+
+                    }
+        } else {
+            char* data=0;
+            char* rtrn=0;
+            *size = strlen(line);
+
+            data = (char*)malloc(*size+2);
+            assert(data != 0);
+            if (header->encoding == SSPM_BASE64_ENCODING){
+                rtrn = decode_base64(data,line,size); 
+            } else if(header->encoding == SSPM_QUOTED_PRINTABLE_ENCODING){
+                rtrn = decode_quoted_printable(data,line,size); 
+            } 
+
+            if(rtrn == 0){
+                strcpy(data,line);
+            }
+
+            /* add a end-of-string after the data, just in case binary
+               data from decode64 gets passed to a tring handling
+               routine in add_line  */
+            data[*size+1]='\0';
+
+            action.add_line(part,header,data,*size);
+
+            free(data);
+        }
+    }
+
+    if (end == 0){
+        /* End the part if the input is exhausted */
+        *end_part = action.end_part(part);
+    }
+
+    return end_part;
+}
+
+
+void* sspm_make_multipart_subpart(struct mime_impl *impl,
+                            struct sspm_header *parent_header)
+{
+    struct sspm_header header;
+    char *line;
+    void* part;
+    size_t size;
+
+    if(parent_header->boundary == 0){
+        /* Error. Multipart headers must have a boundary*/
+        
+        sspm_set_error(parent_header,SSPM_NO_BOUNDARY_ERROR,0);
+        /* read all of the reamining lines */
+        while((line = sspm_get_next_line(impl)) != 0){
+        }  
+
+        return 0;
+    }
+
+
+    /* Step 1: Read the opening boundary */
+
+    if(get_line_type(impl->temp) != BOUNDARY){
+        while((line=sspm_get_next_line(impl)) != 0 ){
+            if(sspm_is_mime_boundary(line)){
+
+                assert(parent_header != 0);
+
+                /* Check if it is the right boundary */
+                if(!sspm_is_mime_terminating_boundary(line) &&
+                   strncmp((line+2),parent_header->boundary, 
+                           sizeof(parent_header->boundary)) 
+                   == 0){
+                    /* The +2 in strncmp skips over the leading "--" */
+                    
+                    break;
+                } else {
+                    /* Got the wrong boundary, so read and discard
+                       until we get the right boundary.  */
+                    char* boundary;
+                    char msg[256];
+                    
+                    snprintf(msg,256,
+                             "Expected: %s. Got: %s",
+                             parent_header->boundary,line);
+
+                    sspm_set_error(parent_header,
+                                   SSPM_WRONG_BOUNDARY_ERROR,msg);
+
+                    /* Read until the paired terminating boundary */
+                    if((boundary = (char*)malloc(strlen(line)+5)) == 0){
+                        fprintf(stderr,"Out of memory");
+                        abort();
+                    }
+                    strcpy(boundary,line);
+                    strcat(boundary,"--");
+                    while((line = sspm_get_next_line(impl)) != 0){
+                        if(strcmp(boundary,line)==0){
+                            break;
+                        }
+                    }
+                    free(boundary);
+                    
+                    return 0;
+                }
+            }
+        }
+    }
+
+    /* Step 2: Get the part header */
+    sspm_read_header(impl,&header);
+
+    /* If the header is still listed as default, there was probably an
+       error */
+    if(header.def == 1 && header.error != SSPM_NO_ERROR){
+        sspm_set_error(&header,SSPM_NO_HEADER_ERROR,0);
+        return 0;
+    }
+
+    if(header.error!= SSPM_NO_ERROR){
+        sspm_store_part(impl,header,impl->level,0,0);
+        return 0;
+            }
+
+    /* Step 3: read the body */
+    
+    if(header.major == SSPM_MULTIPART_MAJOR_TYPE){
+        struct sspm_header *child_header;
+        child_header = &(impl->parts[impl->part_no].header);
+
+        /* Store the multipart part */
+        sspm_store_part(impl,header,impl->level,0,0);
+
+        /* now get all of the sub-parts */
+        part = sspm_make_multipart_part(impl,child_header);
+
+        if(get_line_type(impl->temp) != TERMINATING_BOUNDARY){
+
+            sspm_set_error(child_header,SSPM_NO_BOUNDARY_ERROR,impl->temp);
+            return 0;
+        }
+        
+        sspm_get_next_line(impl); /* Step past the terminating boundary */
+
+    } else {
+        sspm_make_part(impl, &header,parent_header,&part,&size);
+
+        memset(&(impl->parts[impl->part_no]), 0, sizeof(struct sspm_part));
+
+        sspm_store_part(impl,header,impl->level,part,size);
+
+    }
+
+    return part;
+}
+
+void* sspm_make_multipart_part(struct mime_impl *impl,struct sspm_header *header)
+{
+    void *part=0;
+
+    /* Now descend a level into each of the children of this part */
+    impl->level++;
+
+    /* Now we are working on the CHILD */
+    memset(&(impl->parts[impl->part_no]), 0, sizeof(struct sspm_part));
+
+    do{
+        part = sspm_make_multipart_subpart(impl,header);
+
+        if (part==0){
+            /* Clean up the part in progress */
+            impl->parts[impl->part_no].header.major 
+                = SSPM_NO_MAJOR_TYPE;
+            impl->parts[impl->part_no].header.minor 
+                = SSPM_NO_MINOR_TYPE;
+
+        }
+        
+
+    } while (get_line_type(impl->temp) != TERMINATING_BOUNDARY &&
+        impl->state != END_OF_INPUT);
+
+    impl->level--;
+
+    return 0;
+}
+
+
+void sspm_read_header(struct mime_impl *impl,struct sspm_header *header)
+{
+#define BUF_SIZE 1024
+#define MAX_HEADER_LINES 25
+
+    char *buf;
+    char header_lines[MAX_HEADER_LINES][BUF_SIZE]; /* HACK, hard limits */
+    int current_line = -1;
+    int end = 0;
+
+    memset(header_lines,0,sizeof(header_lines));
+    memset(header,0,sizeof(struct sspm_header));
+
+    /* Set up default header */
+    header->def = 1;
+    header->major = SSPM_TEXT_MAJOR_TYPE;
+    header->minor = SSPM_PLAIN_MINOR_TYPE;
+    header->error = SSPM_NO_ERROR;
+    header->error_text = 0;
+
+    /* Read all of the lines into memory */
+    while(end==0&& (buf=sspm_get_next_line(impl)) != 0){
+
+        enum line_type line_type = get_line_type(buf);
+        
+        switch(line_type){
+            case BLANK: {
+                end = 1;
+                impl->state = END_OF_HEADER;
+                break;
+            }
+
+            case MAIL_HEADER:
+                    case MIME_HEADER: {    
+                impl->state = IN_HEADER;
+                current_line++;
+                
+                assert(strlen(buf) < BUF_SIZE);
+                
+                strcpy(header_lines[current_line],buf);
+                
+                break;
+            }
+            
+            case HEADER_CONTINUATION: {
+                char* last_line, *end;
+                char *buf_start;
+
+                if(current_line < 0){
+                    /* This is not really a continuation line, since
+                       we have not see any header line yet */
+                    sspm_set_error(header,SSPM_MALFORMED_HEADER_ERROR,buf);
+                    return;
+                }
+
+                last_line = header_lines[current_line];
+                end = (char*) ( (size_t)strlen(last_line)+
+                                      (size_t)last_line);
+                
+                impl->state = IN_HEADER;
+
+                
+                /* skip over the spaces in buf start, and remove the new
+                   line at the end of the lat line */
+                if (last_line[strlen(last_line)-1] == '\n'){
+                    last_line[strlen(last_line)-1] = '\0';
+                }
+                buf_start = buf;
+                while(*buf_start == ' ' ||*buf_start == '\t' ){
+                    buf_start++;
+                }
+                
+                assert( strlen(buf_start) + strlen(last_line) < BUF_SIZE);
+                
+                strcat(last_line,buf_start);
+                
+                break;
+            }
+            
+            default: {
+                sspm_set_error(header,SSPM_MALFORMED_HEADER_ERROR,buf);
+                return;
+            }
+        }
+    }
+        
+
+    for(current_line = 0;
+        current_line < MAX_HEADER_LINES && header_lines[current_line][0] != 0;
+        current_line++){
+        
+        sspm_build_header(header,header_lines[current_line]);
+    }
+
+
+}
+
+/* Root routine for parsing mime entries*/
+int sspm_parse_mime(struct sspm_part *parts, 
+                    size_t max_parts,
+                    struct sspm_action_map *actions,
+                    char* (*get_string)(char *s, size_t size, void* data),
+                    void *get_string_data,
+                    struct sspm_header *first_header
+    )
+{
+    struct mime_impl impl;
+    struct sspm_header header;
+    void *part;
+    int i;
+
+    /* Initialize all of the data */
+    memset(&impl,0,sizeof(struct mime_impl));
+    memset(&header,0,sizeof(struct sspm_header));
+
+    for(i = 0; i<(int)max_parts; i++){
+        parts[i].header.major = SSPM_NO_MAJOR_TYPE;
+        parts[i].header.minor = SSPM_NO_MINOR_TYPE;
+    }
+        
+    impl.parts = parts;
+    impl.max_parts = max_parts;
+    impl.part_no = 0;
+    impl.actions = actions;
+    impl.get_string = get_string;
+    impl.get_string_data = get_string_data;
+
+    /* Read the header of the message. This will be the email header,
+       unless first_header is specified. But ( HACK) that var is not
+       currently being used */
+    sspm_read_header(&impl,&header);
+
+    if(header.major == SSPM_MULTIPART_MAJOR_TYPE){
+        struct sspm_header *child_header;
+        child_header = &(impl.parts[impl.part_no].header);
+        
+        sspm_store_part(&impl,header,impl.level,0,0);
+
+        part = sspm_make_multipart_part(&impl,child_header);
+
+    } else {
+        void *part;
+        size_t size;
+        sspm_make_part(&impl, &header, 0,&part,&size);
+
+        memset(&(impl.parts[impl.part_no]), 0, sizeof(struct sspm_part));
+        
+        sspm_store_part(&impl,header,impl.level,part,size);
+    }
+
+    return 0;
+}
+
+void sspm_free_parts(struct sspm_part *parts, size_t max_parts)
+{
+     int i;
+    
+    for(i = 0; i<(int)max_parts && parts[i].header.major != SSPM_NO_MAJOR_TYPE;
+        i++){
+        sspm_free_header(&(parts[i].header));
+    }
+}
+
+void sspm_free_header(struct sspm_header *header)
+{
+    if(header->boundary!=0){
+        free(header->boundary);
+    }
+    if(header->minor_text!=0){
+        free(header->minor_text);
+    }
+    if(header->charset!=0){
+        free(header->charset);
+    }
+    if(header->filename!=0){
+        free(header->filename);
+    }
+    if(header->content_id!=0){
+        free(header->content_id);
+    }
+    if(header->error_text!=0){
+        free(header->error_text);
+    }
+}
+
+/***********************************************************************
+The remaining code is beased on code from the mimelite distribution,
+which has the following notice:
+
+| Authorship:
+|    Copyright (c) 1994 Gisle Hannemyr.
+|    Permission is granted to hack, make and distribute copies of this
+|    program as long as this copyright notice is not removed.
+|    Flames, bug reports, comments and improvements to:
+|       snail: Gisle Hannemyr, Brageveien 3A, 0452 Oslo, Norway
+|       email: Inet: gisle@oslonett.no
+
+The code is heavily modified by Eric Busboom. 
+
+***********************************************************************/
+
+char *decode_quoted_printable(char *dest, 
+                                       char *src,
+                                       size_t *size)
+{
+    int cc;
+    size_t i=0;
+
+    while (*src != 0 && i < *size) {
+        if (*src == '=') {
+
+            src++; 
+            if (!*src) {
+                break;
+            }
+
+            /* remove soft line breaks*/
+            if ((*src == '\n') || (*src == '\r')){
+                src++;
+                if ((*src == '\n') || (*src == '\r')){
+                    src++;
+                }
+                continue;
+            }
+
+            cc  = isdigit(*src) ? (*src - '0') : (*src - 55);
+            cc *= 0x10;
+            src++; 
+            if (!*src) {
+                break;
+            }
+            cc += isdigit(*src) ? (*src - '0') : (*src - 55);
+
+            *dest = cc;
+
+        } else {
+            *dest = *src;
+        }
+        
+        dest++;
+        src++;
+        i++;
+    }
+    
+    *dest = '\0';
+    
+    *size = i;
+    return(dest);
+}
+
+char *decode_base64(char *dest, 
+                             char *src,
+                             size_t *size)
+{
+    int cc;
+    char buf[4] = {0,0,0,0};  
+    int p = 0;
+    int valid_data = 0;
+    size_t size_out=0;
+    
+    while (*src && p<(int)*size && (cc!=  -1)) {
+        
+        /* convert a character into the Base64 alphabet */
+        cc = *src++;
+        
+                if((cc >= 'A') && (cc <= 'Z')) cc = cc - 'A';
+        else if ((cc >= 'a') && (cc <= 'z')) cc = cc - 'a' + 26;
+        else if ((cc >= '0') && (cc <= '9')) cc = cc - '0' + 52;
+                else if  (cc == '/')         cc = 63;
+                else if  (cc == '+')         cc = 62;
+        else                                 cc = -1;
+        
+        assert(cc<64);
+
+        /* If we've reached the end, fill the remaining slots in
+           the bucket and do a final conversion */
+        if(cc== -1){
+            if(valid_data == 0){
+                return 0;
+            }
+
+            while(p%4!=3){
+                p++;
+                buf[p%4] = 0;
+            }
+        } else {
+            buf[p%4] = cc;
+            size_out++;
+            valid_data = 1;
+        }
+
+        
+        /* When we have 4 base64 letters, convert them into three
+           bytes */
+        if (p%4 == 3) {
+            *dest++ =(buf[0]<< 2)|((buf[1] & 0x30) >> 4);
+            *dest++ =((buf[1] & 0x0F) << 4)|((buf[2] & 0x3C) >> 2);
+            *dest++ =((buf[2] & 0x03) << 6)|(buf[3] & 0x3F);
+
+            memset(buf,0,4);
+        }
+
+        p++;
+
+    }
+    /* Calculate the size of the converted data*/
+   *size = ((int)(size_out/4))*3;
+    if(size_out%4 == 2) *size+=1;
+    if(size_out%4 == 3) *size+=2;
+
+    return(dest);
+}
+
+
+/***********************************************************************
+                                                                       
+ Routines to output MIME
+
+**********************************************************************/
+
+
+struct sspm_buffer {
+        char* buffer;
+        char* pos;
+        size_t buf_size;
+        int line_pos;
+};
+
+void sspm_append_string(struct sspm_buffer* buf, char* string);
+void sspm_write_part(struct sspm_buffer *buf,struct sspm_part *part, int *part_num);
+
+void sspm_append_hex(struct sspm_buffer* buf, char ch)
+{
+    char tmp[3];
+
+    sprintf(tmp,"=%02X",ch);
+
+    sspm_append_string(buf,tmp);
+}
+
+/* a copy of icalmemory_append_char */
+void sspm_append_char(struct sspm_buffer* buf, char ch)
+{
+    char *new_buf;
+    char *new_pos;
+
+    size_t data_length, final_length;
+
+    data_length = (size_t)buf->pos - (size_t)buf->buffer;
+
+    final_length = data_length + 2; 
+
+    if ( final_length > (size_t) buf->buf_size ) {
+        
+        buf->buf_size  = (buf->buf_size) * 2  + final_length +1;
+
+        new_buf = realloc(buf->buffer,buf->buf_size);
+
+        new_pos = (void*)((size_t)new_buf + data_length);
+        
+        buf->pos = new_pos;
+        buf->buffer = new_buf;
+    }
+
+    *(buf->pos) = ch;
+    buf->pos += 1;
+    *(buf->pos) = 0;
+}
+/* A copy of icalmemory_append_string */
+void sspm_append_string(struct sspm_buffer* buf, char* string)
+{
+    char *new_buf;
+    char *new_pos;
+
+    size_t data_length, final_length, string_length;
+
+    string_length = strlen(string);
+    data_length = (size_t)buf->pos - (size_t)buf->buffer;    
+    final_length = data_length + string_length; 
+
+    if ( final_length >= (size_t) buf->buf_size) {
+
+        
+        buf->buf_size  = (buf->buf_size) * 2  + final_length;
+
+        new_buf = realloc(buf->buffer,buf->buf_size);
+
+        new_pos = (void*)((size_t)new_buf + data_length);
+        
+        buf->pos = new_pos;
+        buf->buffer = new_buf;
+    }
+    
+    strcpy(buf->pos, string);
+
+    buf->pos += string_length;
+}
+
+
+
+static int sspm_is_printable(char c)
+{
+    return (c >= 33) && (c <= 126) && (c != '=');
+
+} 
+                     
+
+void sspm_encode_quoted_printable(struct sspm_buffer *buf, char* data)
+{
+    char *p;
+    int lpos = 0;
+
+    for(p = data; *p != 0; p++){
+
+        if(sspm_is_printable(*p)){
+            /* plain characters can represent themselves */
+            /* RFC2045 Rule #2 */
+               sspm_append_char(buf,*p);
+               lpos++;
+        } else if ( *p == '\t' || *p == ' ' ) {
+
+            /* For tabs and spaces, only encode if they appear at the
+               end of the line */
+            /* RFC2045 Rule #3 */
+
+           char n = *(p+1);
+
+           if( n == '\n' || n == '\r'){
+               sspm_append_hex(buf,*p);
+               lpos += 3;
+           } else {
+               sspm_append_char(buf,*p);
+               lpos++;
+           }
+
+        } else if( *p == '\n' || *p == '\r'){
+            sspm_append_char(buf,*p);
+
+            lpos=0;
+
+        } else {
+            /* All others need to be encoded */
+            sspm_append_hex(buf,*p);
+            lpos+=3;
+        }
+
+
+        /* Add line breaks */
+        if (lpos > 72){
+            lpos = 0;
+            sspm_append_string(buf,"=\n");
+        }
+    }
+}
+
+static char BaseTable[64] = {
+    'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P',
+    'Q','R','S','T','U','V','W','X','Y','Z','a','b','c','d','e','f',
+    'g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v',
+    'w','x','y','z','0','1','2','3','4','5','6','7','8','9','+','/'
+};
+    
+void sspm_write_base64(struct sspm_buffer *buf, char* inbuf,int size )
+{
+    
+    char outbuf[4];
+    int i;
+
+    outbuf[0] = outbuf[1] = outbuf[2] = outbuf[3] = 65;
+
+    switch(size){
+        
+        case 4:
+            outbuf[3] =   inbuf[2] & 0x3F;
+
+        case 3:
+            outbuf[2] = ((inbuf[1] & 0x0F) << 2) | ((inbuf[2] & 0xC0) >> 6);
+
+                case 2:
+            outbuf[0] =  (inbuf[0] & 0xFC) >> 2;
+            outbuf[1] = ((inbuf[0] & 0x03) << 4) | ((inbuf[1] & 0xF0) >> 4);
+            break;
+
+        default:
+            assert(0);
+    }
+
+    for(i = 0; i < 4; i++){
+
+        if(outbuf[i] == 65){
+            sspm_append_char(buf,'=');
+        } else {
+            sspm_append_char(buf,BaseTable[(int)outbuf[i]]);
+        }
+    }
+}
+             
+void sspm_encode_base64(struct sspm_buffer *buf, char* data, size_t size)
+{
+
+    char *p;
+    char inbuf[3];
+    int i = 0;
+    int first = 1;
+    int lpos = 0;
+
+    inbuf[0] = inbuf[1] = inbuf[2]  = 0;
+
+    for (p = data; *p !=0; p++){
+                         
+        if (i%3 == 0 && first == 0){
+
+            sspm_write_base64(buf, inbuf, 4);
+            lpos+=4;
+
+            inbuf[0] = inbuf[1] = inbuf[2] = 0;
+        }
+
+        assert(lpos%4 == 0);
+
+        if (lpos == 72){
+            sspm_append_string(buf,"\n");
+            lpos = 0;
+        }
+
+        inbuf[i%3] = *p;
+
+        i++;
+        first = 0;
+
+    }
+
+    
+    /* If the inbuf was not exactly filled on the last byte, we need
+       to spit out the odd bytes that did get in -- either one or
+       two. This will result in an output of two bytes and '==' or
+       three bytes and '=', respectively */
+    
+    if (i%3 == 1 && first == 0){
+            sspm_write_base64(buf, inbuf, 2);
+    } else if (i%3 == 2 && first == 0){
+            sspm_write_base64(buf, inbuf, 3);
+    }
+
+}
+
+void sspm_write_header(struct sspm_buffer *buf,struct sspm_header *header)
+{
+    
+    int i;
+            char temp[TMP_BUF_SIZE];                   
+    char* major; 
+    char* minor; 
+    
+    /* Content-type */
+
+    major = sspm_major_type_string(header->major);
+    minor = sspm_minor_type_string(header->minor);
+
+    if(header->minor == SSPM_UNKNOWN_MINOR_TYPE ){
+        assert(header->minor_text !=0);
+        minor = header->minor_text;
+    }
+    
+    sprintf(temp,"Content-Type: %s/%s",major,minor);
+
+    sspm_append_string(buf,temp);
+
+    if(header->boundary != 0){
+        sprintf(temp,";boundary=\"%s\"",header->boundary);
+        sspm_append_string(buf,temp);
+    }
+    
+    /* Append any content type parameters */    
+    if(header->content_type_params != 0){
+        for(i=0; *(header->content_type_params[i])!= 0;i++){
+            sprintf(temp,header->content_type_params[i]);
+            sspm_append_char(buf,';');
+            sspm_append_string(buf,temp);
+        }
+    }
+    
+    sspm_append_char(buf,'\n');
+
+    /*Content-Transfer-Encoding */
+
+    if(header->encoding != SSPM_UNKNOWN_ENCODING &&
+        header->encoding != SSPM_NO_ENCODING){
+        sprintf(temp,"Content-Transfer-Encoding: %s\n",
+                sspm_encoding_string(header->encoding));
+    }
+
+    sspm_append_char(buf,'\n');
+
+}
+
+void sspm_write_multipart_part(struct sspm_buffer *buf,
+                               struct sspm_part *parts,
+                               int* part_num)
+{
+
+    int parent_level, level;
+    struct sspm_header *header = &(parts[*part_num].header);
+    /* Write the header for the multipart part */
+    sspm_write_header(buf,header);
+
+    parent_level = parts[*part_num].level;
+
+    (*part_num)++;
+
+    level = parts[*part_num].level;
+
+    while(parts[*part_num].header.major != SSPM_NO_MAJOR_TYPE &&
+          level == parent_level+1){
+
+        assert(header->boundary);
+        sspm_append_string(buf,header->boundary);
+        sspm_append_char(buf,'\n');
+        
+        if (parts[*part_num].header.major == SSPM_MULTIPART_MAJOR_TYPE){
+            sspm_write_multipart_part(buf,parts,part_num);
+        } else {
+            sspm_write_part(buf, &(parts[*part_num]), part_num);
+                }
+
+        (*part_num)++;
+        level =  parts[*part_num].level;
+    }
+   
+    sspm_append_string(buf,"\n\n--");
+    sspm_append_string(buf,header->boundary);
+    sspm_append_string(buf,"\n");
+
+    (*part_num)--; /* undo last, spurious, increment */
+}
+
+void sspm_write_part(struct sspm_buffer *buf,struct sspm_part *part,int *part_num)
+{
+
+    /* Write header */
+    sspm_write_header(buf,&(part->header));
+
+    /* Write part data */
+
+    if(part->data == 0){
+        return;
+    }
+
+    if(part->header.encoding == SSPM_BASE64_ENCODING) {
+        assert(part->data_size != 0);
+        sspm_encode_base64(buf,part->data,part->data_size);
+    } else if(part->header.encoding == SSPM_QUOTED_PRINTABLE_ENCODING) {
+        sspm_encode_quoted_printable(buf,part->data);
+    } else {
+        sspm_append_string(buf,part->data);
+    }
+
+    sspm_append_string(buf,"\n\n");
+}
+
+int sspm_write_mime(struct sspm_part *parts,size_t num_parts,
+                    char **output_string, char* header)
+{
+    struct sspm_buffer buf;
+    int part_num =0;
+
+    buf.buffer = malloc(4096);
+    buf.pos = buf.buffer;
+    buf.buf_size = 10;
+    buf.line_pos = 0;
+
+    /* write caller's header */
+    if(header != 0){
+        sspm_append_string(&buf,header);
+    }
+
+    if(buf.buffer[strlen(buf.buffer)-1] != '\n'){
+        sspm_append_char(&buf,'\n');
+    }
+
+    /* write mime-version header */
+    sspm_append_string(&buf,"Mime-Version: 1.0\n");
+
+    /* End of header */
+
+    /* Write body parts */
+    while(parts[part_num].header.major != SSPM_NO_MAJOR_TYPE){
+        if (parts[part_num].header.major == SSPM_MULTIPART_MAJOR_TYPE){
+            sspm_write_multipart_part(&buf,parts,&part_num);
+        } else {
+            sspm_write_part(&buf, &(parts[part_num]), &part_num);
+                }
+
+        part_num++;
+    }
+
+
+    *output_string = buf.buffer;
+
+    return 0;
+}
+
diff --git a/libical/src/libical/sspm.h b/libical/src/libical/sspm.h
new file mode 100644
index 0000000..864a23a
--- a/dev/null
+++ b/libical/src/libical/sspm.h
@@ -0,0 +1,143 @@
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: sspm.h Mime Parser
+  CREATOR: eric 25 June 2000
+  
+  $Id$
+  $Locker$
+    
+ The contents of this file are subject to the Mozilla Public License
+ Version 1.0 (the "License"); you may not use this file except in
+ compliance with the License. You may obtain a copy of the License at
+ http://www.mozilla.org/MPL/
+ 
+ Software distributed under the License is distributed on an "AS IS"
+ basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+ the License for the specific language governing rights and
+ limitations under the License.
+ 
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The Initial Developer of the Original Code is Eric Busboom
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+ ======================================================================*/
+
+#ifndef SSPM_H
+#define SSPM_H
+
+enum sspm_major_type {
+    SSPM_NO_MAJOR_TYPE,
+    SSPM_TEXT_MAJOR_TYPE,
+    SSPM_IMAGE_MAJOR_TYPE,
+    SSPM_AUDIO_MAJOR_TYPE,
+    SSPM_VIDEO_MAJOR_TYPE,
+    SSPM_APPLICATION_MAJOR_TYPE,
+    SSPM_MULTIPART_MAJOR_TYPE,
+    SSPM_MESSAGE_MAJOR_TYPE,
+    SSPM_UNKNOWN_MAJOR_TYPE
+};
+
+enum sspm_minor_type {
+    SSPM_NO_MINOR_TYPE,
+    SSPM_ANY_MINOR_TYPE,
+    SSPM_PLAIN_MINOR_TYPE,
+    SSPM_RFC822_MINOR_TYPE,
+    SSPM_DIGEST_MINOR_TYPE,
+    SSPM_CALENDAR_MINOR_TYPE,
+    SSPM_MIXED_MINOR_TYPE,
+    SSPM_RELATED_MINOR_TYPE,
+    SSPM_ALTERNATIVE_MINOR_TYPE,
+    SSPM_PARALLEL_MINOR_TYPE,
+    SSPM_UNKNOWN_MINOR_TYPE
+};
+
+enum sspm_encoding {
+    SSPM_NO_ENCODING,
+    SSPM_QUOTED_PRINTABLE_ENCODING,
+    SSPM_8BIT_ENCODING,
+    SSPM_7BIT_ENCODING,
+    SSPM_BINARY_ENCODING,
+    SSPM_BASE64_ENCODING,
+    SSPM_UNKNOWN_ENCODING
+};
+
+enum sspm_error{
+    SSPM_NO_ERROR,
+    SSPM_UNEXPECTED_BOUNDARY_ERROR,
+    SSPM_WRONG_BOUNDARY_ERROR,
+    SSPM_NO_BOUNDARY_ERROR,
+    SSPM_NO_HEADER_ERROR,
+    SSPM_MALFORMED_HEADER_ERROR
+};
+
+
+struct sspm_header
+{
+        int def;
+        char* boundary;
+        enum sspm_major_type major;
+        enum sspm_minor_type minor;
+        char *minor_text;
+        char ** content_type_params;
+        char* charset;
+        enum sspm_encoding encoding;
+        char* filename;
+        char* content_id;
+        enum sspm_error error;
+        char* error_text;
+};
+
+struct sspm_part {
+        struct sspm_header header;
+        int level;
+        size_t data_size;
+        void *data;
+};
+
+struct sspm_action_map {
+        enum sspm_major_type major;
+        enum sspm_minor_type minor;
+        void* (*new_part)();
+        void (*add_line)(void *part, struct sspm_header *header, 
+                         char* line, size_t size);
+        void* (*end_part)(void* part);
+        void (*free_part)(void *part);
+};
+
+char* sspm_major_type_string(enum sspm_major_type type);
+char* sspm_minor_type_string(enum sspm_minor_type type);
+char* sspm_encoding_string(enum sspm_encoding type);
+
+int sspm_parse_mime(struct sspm_part *parts, 
+                    size_t max_parts,
+                    struct sspm_action_map *actions,
+                    char* (*get_string)(char *s, size_t size, void* data),
+                    void *get_string_data,
+                    struct sspm_header *first_header
+    );
+
+void sspm_free_parts(struct sspm_part *parts, size_t max_parts);
+
+char *decode_quoted_printable(char *dest, 
+                                       char *src,
+                                       size_t *size);
+char *decode_base64(char *dest, 
+                             char *src,
+                             size_t *size);
+
+
+int sspm_write_mime(struct sspm_part *parts,size_t num_parts,
+                    char **output_string, char* header);
+
+#endif /*SSPM_H*/
diff --git a/libical/src/libical/vsnprintf.c b/libical/src/libical/vsnprintf.c
new file mode 100644
index 0000000..88a8c63
--- a/dev/null
+++ b/libical/src/libical/vsnprintf.c
@@ -0,0 +1,180 @@
+#ifdef __osf__
+/*
+ * Revision 12: http://theos.com/~deraadt/snprintf.c
+ *
+ * Copyright (c) 1997 Theo de Raadt
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include <sys/types.h>
+#include <stdio.h>
+
+#include <unistd.h>
+#include <sys/param.h>
+#include <sys/mman.h>
+#include <signal.h>
+
+#include <string.h>
+#if __STDC__
+#include <stdarg.h>
+#include <stdlib.h>
+#else
+#include <varargs.h>
+#endif
+#include <setjmp.h>
+
+#ifndef roundup
+#define roundup(x, y) ((((x)+((y)-1))/(y))*(y))
+#endif
+
+static int pgsize;
+static char *curobj;
+static sigjmp_buf bail;
+
+        #define EXTRABYTES      2/* XXX: why 2? you don't want to know */
+
+static char *
+msetup(str, n)
+        char *str;
+        size_t n;
+{
+        char *e;
+
+        if (n == 0)
+                return NULL;
+        if (pgsize == 0)
+                pgsize = getpagesize();
+        curobj = (char *)malloc(n + EXTRABYTES + pgsize * 2);
+        if (curobj == NULL)
+                return NULL;
+        e = curobj + n + EXTRABYTES;
+        e = (char *)roundup((unsigned long)e, pgsize);
+        if (mprotect(e, pgsize, PROT_NONE) == -1) {
+                free(curobj);
+                curobj = NULL;
+                return NULL;
+        }
+        e = e - n - EXTRABYTES;
+        *e = '\0';
+        return (e);
+}
+
+static void
+mcatch(int i)
+{
+        siglongjmp(bail, 1);
+}
+
+static void
+mcleanup(str, n, p)
+        char *str;
+        size_t n;
+        char *p;
+{
+        strncpy(str, p, n-1);
+        str[n-1] = '\0';
+        if (mprotect((caddr_t)(p + n + EXTRABYTES), pgsize,
+            PROT_READ|PROT_WRITE|PROT_EXEC) == -1)
+                mprotect((caddr_t)(p + n + EXTRABYTES), pgsize,
+                    PROT_READ|PROT_WRITE);
+        free(curobj);
+}
+
+int
+#if __STDC__
+vsnprintf(char *str, size_t n, char const *fmt, va_list ap)
+#else
+vsnprintf(str, n, fmt, ap)
+        char *str;
+        size_t n;
+        char *fmt;
+        char *ap;
+#endif
+{
+        struct sigaction osa, nsa;
+        char *p;
+                int ret = n + 1;/* if we bail, indicated we overflowed */
+
+        memset(&nsa, 0, sizeof nsa);
+        nsa.sa_handler = mcatch;
+        sigemptyset(&nsa.sa_mask);
+
+        p = msetup(str, n);
+        if (p == NULL) {
+                *str = '\0';
+                return 0;
+        }
+        if (sigsetjmp(bail, 1) == 0) {
+                if (sigaction(SIGSEGV, &nsa, &osa) == -1) {
+                        mcleanup(str, n, p);
+                        return (0);
+                }
+                ret = vsprintf(p, fmt, ap);
+        }
+        mcleanup(str, n, p);
+        (void) sigaction(SIGSEGV, &osa, NULL);
+        return (ret);
+}
+
+int
+#if __STDC__
+snprintf(char *str, size_t n, char const *fmt, ...)
+#else
+snprintf(str, n, fmt, va_alist)
+        char *str;
+        size_t n;
+        char *fmt;
+        va_dcl
+#endif
+{
+        va_list ap;
+#if __STDC__
+        va_start(ap, fmt);
+#else
+        va_start(ap);
+#endif
+
+        return (vsnprintf(str, n, fmt, ap));
+        va_end(ap);
+}
+
+#elif defined ( _WIN32 )
+
+#include <stdio.h>
+#include <stdarg.h>
+
+int snprintf(char *str, size_t n, char const *fmt, ...)
+{
+        va_list ap;
+        va_start(ap, fmt);
+        
+  return _snprintf(str, n, fmt, ap);
+}
+
+#else
+/* ANSI C forbids an empty source file... */
+
+static void vsnprintf_dummy_func() {
+   vsnprintf_dummy_func();
+}
+
+#endif
diff --git a/libical/src/libicalss/config.h b/libical/src/libicalss/config.h
new file mode 100644
index 0000000..fa66c47
--- a/dev/null
+++ b/libical/src/libicalss/config.h
@@ -0,0 +1,7 @@
+#ifndef LIBICALSS_CONFIG_H
+#define LIBICALSS_CONFIG_H
+
+#define PACKAGE "libicalss"
+#define VERSION "0.23"
+
+#endif
diff --git a/libical/src/libicalss/icalcalendar.h b/libical/src/libicalss/icalcalendar.h
new file mode 100644
index 0000000..f07457c
--- a/dev/null
+++ b/libical/src/libicalss/icalcalendar.h
@@ -0,0 +1,67 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalcalendar.h
+ CREATOR: eric 23 December 1999
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+======================================================================*/
+
+#ifndef ICALCALENDAR_H
+#define ICALCALENDAR_H
+
+#include "ical.h"
+#include "icalset.h"
+
+/* icalcalendar
+ * Routines for storing calendar data in a file system. The calendar 
+ * has two icaldirsets, one for incoming components and one for booked
+ * components. It also has interfaces to access the free/busy list
+ * and a list of calendar properties */
+
+typedef  void icalcalendar;
+
+icalcalendar* icalcalendar_new(char* dir);
+
+void icalcalendar_free(icalcalendar* calendar);
+
+int icalcalendar_lock(icalcalendar* calendar);
+
+int icalcalendar_unlock(icalcalendar* calendar);
+
+int icalcalendar_islocked(icalcalendar* calendar);
+
+int icalcalendar_ownlock(icalcalendar* calendar);
+
+icalset* icalcalendar_get_booked(icalcalendar* calendar);
+
+icalset* icalcalendar_get_incoming(icalcalendar* calendar);
+
+icalset* icalcalendar_get_properties(icalcalendar* calendar);
+
+icalset* icalcalendar_get_freebusy(icalcalendar* calendar);
+
+
+#endif /* !ICALCALENDAR_H */
+
+
+
diff --git a/libical/src/libicalss/icalclassify.c b/libical/src/libicalss/icalclassify.c
new file mode 100644
index 0000000..c029309
--- a/dev/null
+++ b/libical/src/libicalss/icalclassify.c
@@ -0,0 +1,792 @@
+/* -*- Mode: C -*-
+    ======================================================================
+    FILE: icalclassify.c
+    CREATOR: ebusboom 23 aug 2000
+  
+    $Id$
+    $Locker$
+    
+    (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+    
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of either: 
+    
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+    
+    Or:
+    
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+
+    ======================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "icalerror.h"
+#include "ical.h"
+#include "icalclassify.h"
+#include "icalmemory.h"
+#include <ctype.h>   /* For tolower() */
+#include <string.h> /* for index() */
+#include <stdlib.h> /* for malloc and free */
+
+
+
+struct icalclassify_parts {
+    icalcomponent *c;
+    icalcomponent_kind inner_kind;
+    icalproperty_method method;
+    char* organizer;
+    icalparameter_partstat reply_partstat;
+    char* reply_attendee;
+    char* uid;
+    int sequence;
+            struct icaltimetype dtstamp;
+    struct icaltimetype recurrence_id;
+}; 
+        
+
+char* icalclassify_lowercase(const char* str)
+{
+    char* p = 0;
+    char* new = icalmemory_strdup(str);
+
+    if(str ==0){
+        return 0;
+    }
+
+    for(p = new; *p!=0; p++){
+        *p = tolower(*p);
+    }
+
+    return new;
+}
+
+/* Return a set of components that intersect in time with comp. For
+component X and Y to intersect:
+    X.DTSTART < Y.DTEND && X.DTEND > Y.DTSTART
+*/
+
+
+icalcomponent* icalclassify_find_overlaps(icalset* set, icalcomponent* comp)
+{
+    icalcomponent *return_set;
+    icalcomponent *c;
+    struct icaltime_span span,compspan;
+    
+    icalerror_clear_errno();
+    compspan = icalcomponent_get_span(comp);
+
+    if(icalerrno != ICAL_NO_ERROR){
+        return 0;
+    }
+
+
+    return_set = icalcomponent_new(ICAL_XROOT_COMPONENT);
+
+    for(c = icalset_get_first_component(set);
+        c != 0;
+        c = icalset_get_next_component(set)){
+
+        icalerror_clear_errno();
+
+        span = icalcomponent_get_span(c);
+
+        if(icalerrno != ICAL_NO_ERROR){
+            continue;
+        }
+
+        if (compspan.start < span.end && 
+            compspan.end > span.start){
+
+            icalcomponent *clone = icalcomponent_new_clone(c);
+
+            icalcomponent_add_component(return_set,clone);
+                }
+    }
+
+    if(icalcomponent_count_components(return_set,ICAL_ANY_COMPONENT) !=0){
+        return return_set;
+    } else {
+        icalcomponent_free(return_set);
+        return 0;
+    }
+}
+
+
+
+icalproperty* icalclassify_find_attendee(icalcomponent *c, 
+                                                  const char* attendee)
+{
+    icalproperty *p;
+    icalcomponent* inner;
+    char* lattendee;
+    char* upn;
+
+    if(attendee == 0){
+        return 0;
+    }
+
+    lattendee = icalclassify_lowercase(attendee);
+    upn =  strchr(lattendee,':');
+
+    if (upn== 0){
+        upn = lattendee;
+    } else {
+        upn++; /* skip the ";"*/
+    }
+
+    inner = icalcomponent_get_first_real_component(c);
+
+    for(p  = icalcomponent_get_first_property(inner,ICAL_ATTENDEE_PROPERTY);
+        p != 0;
+        p  = icalcomponent_get_next_property(inner,ICAL_ATTENDEE_PROPERTY))
+    {
+        const char* this_attendee
+            = icalclassify_lowercase(icalproperty_get_attendee(p));
+        char* this_upn = strchr(this_attendee,':');
+
+        if(this_upn == 0){
+            continue;
+        } else {
+            this_upn++;
+        }
+
+        if(strcmp(this_upn,upn)==0){
+            return p;
+        }
+
+    }
+
+    return 0;
+
+}
+
+void icalssutil_free_parts(struct icalclassify_parts *parts)
+{
+    if(parts == 0){
+        return;
+    }
+
+    if(parts->organizer != 0){
+        free(parts->organizer);
+    }
+
+    if(parts->uid != 0){
+        free(parts->uid);
+    }
+
+    if(parts->reply_attendee){
+        free(parts->reply_attendee);
+    }
+}
+
+void icalssutil_get_parts(icalcomponent* c,  
+                          struct icalclassify_parts* parts)
+{
+    icalproperty *p;
+    icalcomponent *inner;
+
+    memset(parts,0,sizeof(struct icalclassify_parts));
+
+    parts->method = ICAL_METHOD_NONE;
+    parts->sequence = 0;
+    parts->reply_partstat = ICAL_PARTSTAT_NONE;
+
+    if(c == 0){
+        return;
+    }
+
+    parts->c = c;
+
+    p = icalcomponent_get_first_property(c,ICAL_METHOD_PROPERTY);
+    if(p!=0){
+        parts->method = icalproperty_get_method(p);
+    }
+
+    inner = icalcomponent_get_first_real_component(c);
+
+    parts->inner_kind = icalcomponent_isa(inner);
+
+    p = icalcomponent_get_first_property(inner,ICAL_ORGANIZER_PROPERTY);
+    if(p!=0){
+        parts->organizer = strdup(icalproperty_get_organizer(p));
+    }
+
+    p = icalcomponent_get_first_property(inner,ICAL_SEQUENCE_PROPERTY);    
+    if(p!=0){
+        parts->sequence = icalproperty_get_sequence(p);
+    }
+
+    p = icalcomponent_get_first_property(inner,ICAL_UID_PROPERTY);
+    if(p!=0){
+        parts->uid = strdup(icalproperty_get_uid(p));
+    }
+
+    p = icalcomponent_get_first_property(inner,ICAL_RECURRENCEID_PROPERTY);
+    if(p!=0){
+        parts->recurrence_id = icalproperty_get_recurrenceid(p);
+    }
+
+    p = icalcomponent_get_first_property(inner,ICAL_DTSTAMP_PROPERTY);
+    if(p!=0){
+        parts->dtstamp = icalproperty_get_dtstamp(p);
+    }
+
+    if(parts->method==ICAL_METHOD_REPLY){
+        icalparameter *param;
+        p  = icalcomponent_get_first_property(inner,ICAL_ATTENDEE_PROPERTY);
+
+        if(p!=0){
+
+            param = icalproperty_get_first_parameter(p,ICAL_PARTSTAT_PARAMETER);
+            
+            if(param != 0){
+                parts->reply_partstat = 
+                    icalparameter_get_partstat(param);
+            }
+            
+            parts->reply_attendee = strdup(icalproperty_get_attendee(p));
+        }
+
+    }    
+
+
+}
+
+
+int icalssutil_is_rescheduled(icalcomponent* a,icalcomponent* b)
+{
+    icalproperty *p1,*p2;
+    icalcomponent *i1,*i2;
+    int i;
+
+    icalproperty_kind kind_array[] = {
+        ICAL_DTSTART_PROPERTY,
+        ICAL_DTEND_PROPERTY,
+        ICAL_DURATION_PROPERTY,
+        ICAL_DUE_PROPERTY,
+        ICAL_RRULE_PROPERTY,
+        ICAL_RDATE_PROPERTY,
+        ICAL_EXRULE_PROPERTY,
+        ICAL_EXDATE_PROPERTY,
+        ICAL_NO_PROPERTY
+    };
+
+    i1 = icalcomponent_get_first_real_component(a);
+    i2 = icalcomponent_get_first_real_component(b);
+
+    for(i =0; kind_array[i] != ICAL_NO_PROPERTY; i++){
+        p1 = icalcomponent_get_first_property(i1,kind_array[i]);
+        p2 = icalcomponent_get_first_property(i2,kind_array[i]);
+        
+        if( (p1!=0)^(p1!=0) ){
+            /* Return true if the property exists in one component and not
+               the other */
+            return 1;
+        }
+        
+        if(p1 && strcmp(icalproperty_as_ical_string(p1),
+                        icalproperty_as_ical_string(p2)) != 0){
+            return 1;
+        }
+    }
+
+    return 0;
+    
+}
+
+#define icalclassify_pre \
+    int rtrn =0; 
+
+#define icalclassify_post \
+    return rtrn;
+
+
+int icalclassify_publish_new(struct icalclassify_parts *comp, 
+                                struct icalclassify_parts *match, 
+                                const char* user)
+{
+    icalclassify_pre;
+
+    if(comp->method == ICAL_METHOD_PUBLISH &&
+        match == 0 && comp->inner_kind != ICAL_VFREEBUSY_COMPONENT){
+        rtrn = 1;
+    }
+        
+    icalclassify_post;
+
+}
+
+int icalclassify_publish_update(struct icalclassify_parts *comp, 
+                                struct icalclassify_parts *match, 
+                                const char* user)
+{
+    icalclassify_pre;
+
+    if(comp->method == ICAL_METHOD_PUBLISH &&
+        match !=0 && comp->inner_kind != ICAL_VFREEBUSY_COMPONENT){
+        rtrn = 1;
+    }
+        
+    icalclassify_post;
+
+}
+
+int icalclassify_publish_freebusy(struct icalclassify_parts *comp, 
+                                struct icalclassify_parts *match, 
+                                const char* user)
+{
+    icalclassify_pre;
+
+    if(comp->method == ICAL_METHOD_PUBLISH &&
+       comp->inner_kind == ICAL_VFREEBUSY_COMPONENT){
+        rtrn = 1;
+    }
+        
+    icalclassify_post;
+
+}
+
+
+int icalclassify_request_new(struct icalclassify_parts *comp, 
+                                    struct icalclassify_parts *match, 
+                                    const char* user)
+{
+    /* Method is  REQUEST, and there is no match */
+
+    icalclassify_pre
+
+    if(match->c==0 && comp->method == ICAL_METHOD_REQUEST){
+        rtrn = 1;
+    }
+
+    icalclassify_post
+
+}
+
+int icalclassify_request_update(
+    struct icalclassify_parts *comp,
+    struct icalclassify_parts *match, 
+    const char* user)
+{
+    /* REQUEST method, Higher SEQUENCE than match, and all
+       time-related properties are unchanged */
+    
+    icalclassify_pre
+
+    if (match != 0 &&
+        comp->sequence >= match->sequence &&
+        !icalssutil_is_rescheduled(comp->c,match->c)){
+        rtrn = 1;
+    }
+
+    icalclassify_post
+
+}
+
+int icalclassify_request_reschedule(
+    struct icalclassify_parts *comp,
+    struct icalclassify_parts *match, 
+    const char* user)
+{
+    /* REQUEST method, Higher SEQUENCE than match, and one or more
+       time-related properties are changed */
+    icalclassify_pre
+
+    if (match->c != 0 &&
+        comp->sequence > match->sequence &&
+        icalssutil_is_rescheduled(comp->c,match->c)){
+        rtrn = 1;
+    }
+
+    icalclassify_post
+
+}
+
+int icalclassify_request_delegate(
+    struct icalclassify_parts *comp,
+    struct icalclassify_parts *match, 
+    const char* user)
+{
+    icalproperty* attendee;
+    icalparameter* param;
+    icalclassify_pre;
+
+    attendee = icalclassify_find_attendee(comp->c,user);
+
+    if(attendee == 0){
+        return 0;
+    }
+
+    param = icalproperty_get_first_parameter(attendee,ICAL_DELEGATEDFROM_PARAMETER);
+            
+    if (param != 0){
+        rtrn = 1;
+    }
+
+    icalclassify_post
+
+}
+
+int icalclassify_request_new_organizer(
+    struct icalclassify_parts *comp,
+    struct icalclassify_parts *match, 
+    const char* user)
+{
+    /*   Organizer has changed between match and component */
+    icalclassify_pre
+    icalerror_set_errno(ICAL_UNIMPLEMENTED_ERROR);
+    icalclassify_post
+
+}
+
+int icalclassify_request_status(
+    struct icalclassify_parts *comp,
+    struct icalclassify_parts *match, 
+    const char* user)
+{
+    icalclassify_pre
+    icalerror_set_errno(ICAL_UNIMPLEMENTED_ERROR);
+    icalclassify_post
+}
+
+int icalclassify_request_forward(
+    struct icalclassify_parts *comp,
+    struct icalclassify_parts *match, 
+    const char* user)
+{
+    icalclassify_pre
+    icalerror_set_errno(ICAL_UNIMPLEMENTED_ERROR);
+    icalclassify_post
+}
+
+int icalclassify_request_freebusy(
+    struct icalclassify_parts *comp,
+    struct icalclassify_parts *match, 
+    const char* user)
+{
+    icalclassify_pre
+    icalerror_set_errno(ICAL_UNIMPLEMENTED_ERROR);
+    icalclassify_post
+}
+
+int icalclassify_reply_accept(
+    struct icalclassify_parts *comp,
+    struct icalclassify_parts *match, 
+    const char* user)
+{
+    icalproperty* attendee;
+    icalclassify_pre;
+
+    attendee = icalclassify_find_attendee(match->c,comp->reply_attendee);
+
+    if(attendee != 0&&
+       comp->reply_partstat == ICAL_PARTSTAT_ACCEPTED){
+        rtrn = 1;
+    }
+
+    icalclassify_post
+}
+int icalclassify_reply_decline(
+    struct icalclassify_parts *comp,
+    struct icalclassify_parts *match, 
+    const char* user)
+{
+    icalproperty* attendee;
+    icalclassify_pre;
+
+    attendee = icalclassify_find_attendee(match->c,comp->reply_attendee);
+
+
+    if( attendee != 0 &&
+       comp->reply_partstat == ICAL_PARTSTAT_DECLINED){
+        rtrn = 1;
+    }
+    icalclassify_post
+}
+int icalclassify_reply_delegate(
+    struct icalclassify_parts *comp,
+    struct icalclassify_parts *match, 
+    const char* user)
+{
+    icalproperty* attendee;
+    icalclassify_pre;
+
+    attendee = icalclassify_find_attendee(match->c,comp->reply_attendee);
+
+    if( attendee != 0 &&
+       comp->reply_partstat == ICAL_PARTSTAT_DELEGATED){
+        rtrn = 1;
+    }
+    icalclassify_post
+}
+int icalclassify_reply_crasher_accept(
+    struct icalclassify_parts *comp,
+    struct icalclassify_parts *match, 
+    const char* user)
+{
+    icalproperty* attendee;
+    icalclassify_pre;
+
+    attendee= icalclassify_find_attendee(match->c,comp->reply_attendee);
+
+    if(attendee == 0 &&
+       comp->reply_partstat == ICAL_PARTSTAT_ACCEPTED){
+        rtrn = 1;
+    }
+    icalclassify_post
+}
+int icalclassify_reply_crasher_decline(
+    struct icalclassify_parts *comp,
+    struct icalclassify_parts *match, 
+    const char* user)
+{
+    icalparameter_partstat partstat;
+    icalproperty* attendee;
+    icalclassify_pre;
+
+
+    attendee = icalclassify_find_attendee(match->c,comp->reply_attendee);
+
+    if(attendee == 0 &&
+       comp->reply_partstat == ICAL_PARTSTAT_DECLINED){
+        rtrn = 1;
+    }
+    icalclassify_post
+}
+int icalclassify_add_instance(
+    struct icalclassify_parts *comp,
+    struct icalclassify_parts *match, 
+    const char* user)
+{
+    icalclassify_pre
+    if(comp->method == ICAL_METHOD_ADD){
+        rtrn = 1;
+    }
+    icalclassify_post
+}
+int icalclassify_cancel_event(
+    struct icalclassify_parts *comp,
+    struct icalclassify_parts *match, 
+    const char* user)
+{
+    icalclassify_pre
+    if(comp->method == ICAL_METHOD_CANCEL){
+        rtrn = 1;
+    }
+    icalclassify_post
+}
+int icalclassify_cancel_instance(
+    struct icalclassify_parts *comp,
+    struct icalclassify_parts *match, 
+    const char* user)
+{
+    icalclassify_pre
+    if(comp->method == ICAL_METHOD_CANCEL){
+        rtrn = 1;
+    }
+    icalclassify_post
+}
+int icalclassify_cancel_all(
+    struct icalclassify_parts *comp,
+    struct icalclassify_parts *match, 
+    const char* user)
+{
+    icalclassify_pre
+    if(comp->method == ICAL_METHOD_CANCEL){
+        rtrn = 1;
+    }
+    icalclassify_post
+}
+int icalclassify_refesh(
+    struct icalclassify_parts *comp,
+    struct icalclassify_parts *match, 
+    const char* user)
+{
+    icalclassify_pre
+    if(comp->method == ICAL_METHOD_REFRESH){
+        rtrn = 1;
+    }
+    icalclassify_post
+}
+int icalclassify_counter(
+    struct icalclassify_parts *comp,
+    struct icalclassify_parts *match, 
+    const char* user)
+{
+    icalclassify_pre
+    if(comp->method == ICAL_METHOD_COUNTER){
+        rtrn = 1;
+    }
+    icalclassify_post
+}
+int icalclassify_delinecounter(
+    struct icalclassify_parts *comp,
+    struct icalclassify_parts *match, 
+    const char* user)
+{
+    icalclassify_pre
+
+    if(comp->method == ICAL_METHOD_DECLINECOUNTER){
+        rtrn = 1;
+    }
+        
+    icalclassify_post
+}
+
+struct icalclassify_map {
+        icalproperty_method method;
+        int (*fn)(struct icalclassify_parts *comp,struct icalclassify_parts *match, const char* user);
+        ical_class class;
+} icalclassify_map[] = 
+{ {ICAL_METHOD_PUBLISH,icalclassify_publish_new,ICAL_PUBLISH_NEW_CLASS},
+ {ICAL_METHOD_PUBLISH,icalclassify_publish_update,ICAL_PUBLISH_UPDATE_CLASS},
+ {ICAL_METHOD_PUBLISH,icalclassify_publish_freebusy,ICAL_PUBLISH_FREEBUSY_CLASS},
+  {ICAL_METHOD_REQUEST,icalclassify_request_delegate,ICAL_REQUEST_DELEGATE_CLASS},
+  {ICAL_METHOD_REQUEST,icalclassify_request_new,ICAL_REQUEST_NEW_CLASS},
+  {ICAL_METHOD_REQUEST,icalclassify_request_update,ICAL_REQUEST_UPDATE_CLASS},
+  {ICAL_METHOD_REQUEST,icalclassify_request_reschedule,ICAL_REQUEST_RESCHEDULE_CLASS},
+
+  {ICAL_METHOD_REQUEST,icalclassify_request_new_organizer,ICAL_REQUEST_NEW_ORGANIZER_CLASS},
+  {ICAL_METHOD_REQUEST,icalclassify_request_forward,ICAL_REQUEST_FORWARD_CLASS},
+  {ICAL_METHOD_REQUEST,icalclassify_request_status,ICAL_REQUEST_STATUS_CLASS},
+  {ICAL_METHOD_REQUEST,icalclassify_request_freebusy,ICAL_REQUEST_FREEBUSY_CLASS},
+
+  {ICAL_METHOD_REPLY,icalclassify_reply_accept,ICAL_REPLY_ACCEPT_CLASS},
+  {ICAL_METHOD_REPLY,icalclassify_reply_decline,ICAL_REPLY_DECLINE_CLASS},
+  {ICAL_METHOD_REPLY,icalclassify_reply_delegate,ICAL_REPLY_DELEGATE_CLASS},
+  {ICAL_METHOD_REPLY,icalclassify_reply_crasher_accept,ICAL_REPLY_CRASHER_ACCEPT_CLASS},
+  {ICAL_METHOD_REPLY,icalclassify_reply_crasher_decline,ICAL_REPLY_CRASHER_DECLINE_CLASS},
+
+  {ICAL_METHOD_ADD,icalclassify_add_instance,ICAL_ADD_INSTANCE_CLASS},
+
+  {ICAL_METHOD_CANCEL,icalclassify_cancel_event,ICAL_CANCEL_EVENT_CLASS},
+  {ICAL_METHOD_CANCEL,icalclassify_cancel_instance,ICAL_CANCEL_INSTANCE_CLASS},
+  {ICAL_METHOD_CANCEL,icalclassify_cancel_all,ICAL_CANCEL_ALL_CLASS},
+
+  {ICAL_METHOD_REFRESH,icalclassify_refesh,ICAL_REFRESH_CLASS},
+  {ICAL_METHOD_COUNTER,icalclassify_counter,ICAL_COUNTER_CLASS},
+  {ICAL_METHOD_DECLINECOUNTER,icalclassify_delinecounter,ICAL_DECLINECOUNTER_CLASS},
+  {ICAL_METHOD_NONE,0,ICAL_NO_CLASS}
+};
+
+
+ical_class icalclassify(icalcomponent* c,icalcomponent* match, 
+                              const char* user)
+{
+    icalcomponent *inner;
+    icalproperty *p;
+    icalproperty_method method;
+    ical_class class = ICAL_UNKNOWN_CLASS;
+
+    int i;
+
+    struct icalclassify_parts comp_parts;
+    struct icalclassify_parts match_parts;
+
+    inner = icalcomponent_get_first_real_component(c);
+    
+    if (inner == 0) {
+        return ICAL_NO_CLASS;
+    }
+
+    icalssutil_get_parts(c,&comp_parts);
+    icalssutil_get_parts(match,&match_parts);
+
+    /* Determine if the incoming component is obsoleted by the match */
+    if(match != 0 && (
+        comp_parts.method == ICAL_METHOD_REQUEST
+        )){
+        assert ( ! ((comp_parts.dtstamp.is_utc==1)^
+                    (match_parts.dtstamp.is_utc==1)));
+
+        if( comp_parts.sequence<match_parts.sequence &&
+            icaltime_compare(comp_parts.dtstamp,match_parts.dtstamp)>0)
+        {
+            /* comp has a smaller sequence and a later DTSTAMP */
+            return ICAL_MISSEQUENCED_CLASS;
+        }
+
+        if( (comp_parts.sequence<match_parts.sequence )
+             /*&&icaltime_compare(comp_parts.dtstamp,match_parts.dtstamp)<=0*/
+             ||
+           ( comp_parts.sequence == match_parts.sequence &&
+             icaltime_compare(comp_parts.dtstamp,match_parts.dtstamp)<=0)){
+
+            return ICAL_OBSOLETE_CLASS;
+        }
+
+    }
+
+    p = icalcomponent_get_first_property(c,ICAL_METHOD_PROPERTY);
+    if (p == 0) {
+        return ICAL_UNKNOWN_CLASS;
+    }
+    method = icalproperty_get_method(p);
+
+    for (i =0; icalclassify_map[i].method != ICAL_METHOD_NONE; i++){
+        if(icalclassify_map[i].method == method){
+            if( (*(icalclassify_map[i].fn))(&comp_parts,&match_parts,user)==1){
+                class = icalclassify_map[i].class;
+                break;
+            }
+        }
+    }
+
+    icalssutil_free_parts(&comp_parts); 
+    icalssutil_free_parts(&match_parts);
+
+    return class;
+
+}
+
+struct class_map {
+        ical_class class;
+        char *str;
+} class_map[] = {
+    {ICAL_NO_CLASS,"No class"},
+    {ICAL_PUBLISH_NEW_CLASS,"New Publish"},
+    {ICAL_PUBLISH_UPDATE_CLASS,"Publish Update"},
+    {ICAL_PUBLISH_FREEBUSY_CLASS,"Publish freebusy"},
+    {ICAL_REQUEST_NEW_CLASS,"New request"},
+    {ICAL_REQUEST_UPDATE_CLASS,"Update"},
+    {ICAL_REQUEST_RESCHEDULE_CLASS,"Reschedule"},
+    {ICAL_REQUEST_DELEGATE_CLASS,"Delegate request"},
+    {ICAL_REQUEST_NEW_ORGANIZER_CLASS,"New Organizer"},
+    {ICAL_REQUEST_FORWARD_CLASS,"Forward"},
+    {ICAL_REQUEST_STATUS_CLASS,"Status request"},
+    {ICAL_REPLY_ACCEPT_CLASS,"Accept reply"},
+    {ICAL_REPLY_DECLINE_CLASS,"Decline reply"},
+    {ICAL_REPLY_DELEGATE_CLASS,"Delegation reply"},
+    {ICAL_REPLY_CRASHER_ACCEPT_CLASS,"Crasher's accept reply"},
+    {ICAL_REPLY_CRASHER_DECLINE_CLASS,"Crasher's decline reply"},
+    {ICAL_ADD_INSTANCE_CLASS,"Add instance"},
+    {ICAL_CANCEL_EVENT_CLASS,"Cancel event"},
+    {ICAL_CANCEL_INSTANCE_CLASS,"Cancel instance"},
+    {ICAL_CANCEL_ALL_CLASS,"Cancel all instances"},
+    {ICAL_REFRESH_CLASS,"Refresh"},
+    {ICAL_COUNTER_CLASS,"Counter"},
+    {ICAL_DECLINECOUNTER_CLASS,"Decline counter"},
+    {ICAL_MALFORMED_CLASS,"Malformed"}, 
+    {ICAL_OBSOLETE_CLASS,"Obsolete"},
+    {ICAL_MISSEQUENCED_CLASS,"Missequenced"},
+    {ICAL_UNKNOWN_CLASS,"Unknown"}
+};
+
+char* icalclassify_class_to_string(ical_class class)
+{
+    int i; 
+
+    for (i = 0;class_map[i].class != ICAL_UNKNOWN_CLASS;i++){
+        if (class_map[i].class == class){
+            return class_map[i].str;
+        }
+    }
+
+    return "Unknown";
+}
diff --git a/libical/src/libicalss/icalclassify.h b/libical/src/libicalss/icalclassify.h
new file mode 100644
index 0000000..81188b3
--- a/dev/null
+++ b/libical/src/libicalss/icalclassify.h
@@ -0,0 +1,77 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalclassify.h
+ CREATOR: eric 21 Aug 2000
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+
+ =========================================================================*/
+
+#ifndef ICALCLASSIFY_H
+#define ICALCLASSIFY_H
+
+#include "ical.h"
+#include "icalset.h"
+
+
+typedef enum icalclass {
+    ICAL_NO_CLASS,
+    ICAL_PUBLISH_NEW_CLASS,
+    ICAL_PUBLISH_UPDATE_CLASS,
+    ICAL_PUBLISH_FREEBUSY_CLASS,
+    ICAL_REQUEST_NEW_CLASS,
+    ICAL_REQUEST_UPDATE_CLASS,
+    ICAL_REQUEST_RESCHEDULE_CLASS,
+    ICAL_REQUEST_DELEGATE_CLASS,
+    ICAL_REQUEST_NEW_ORGANIZER_CLASS,
+    ICAL_REQUEST_FORWARD_CLASS,
+    ICAL_REQUEST_STATUS_CLASS,
+    ICAL_REQUEST_FREEBUSY_CLASS,
+    ICAL_REPLY_ACCEPT_CLASS,
+    ICAL_REPLY_DECLINE_CLASS,
+    ICAL_REPLY_DELEGATE_CLASS,
+    ICAL_REPLY_CRASHER_ACCEPT_CLASS,
+    ICAL_REPLY_CRASHER_DECLINE_CLASS,
+    ICAL_ADD_INSTANCE_CLASS,
+    ICAL_CANCEL_EVENT_CLASS,
+    ICAL_CANCEL_INSTANCE_CLASS,
+    ICAL_CANCEL_ALL_CLASS,
+    ICAL_REFRESH_CLASS,
+    ICAL_COUNTER_CLASS,
+    ICAL_DECLINECOUNTER_CLASS,
+    ICAL_MALFORMED_CLASS, 
+    ICAL_OBSOLETE_CLASS, /* 21 */
+    ICAL_MISSEQUENCED_CLASS, /* 22 */
+    ICAL_UNKNOWN_CLASS /* 23 */
+} ical_class;
+
+ical_class icalclassify(icalcomponent* c,icalcomponent* match, 
+                              const char* user);
+
+icalcomponent* icalclassify_find_overlaps(icalset* set, icalcomponent* comp);
+
+char* icalclassify_class_to_string(ical_class iclass);
+
+
+#endif /* ICALCLASSIFY_H*/
+
+
+                                    
+
+
diff --git a/libical/src/libicalss/icalcstp.c b/libical/src/libicalss/icalcstp.c
new file mode 100644
index 0000000..ed62b40
--- a/dev/null
+++ b/libical/src/libicalss/icalcstp.c
@@ -0,0 +1,122 @@
+/* -*- Mode: C -*-
+    ======================================================================
+    FILE: icalcstps.c
+    CREATOR: ebusboom 23 Jun 2000
+  
+    $Id$
+    $Locker$
+    
+    (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+    
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of either: 
+    
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+    
+    Or:
+    
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+
+    ======================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "ical.h"
+#include "icalcstp.h"
+#include "pvl.h" 
+
+// Eugen C. <eug@thekompany.com>
+#include <defines.h>
+#ifndef _QTWIN_
+#include <sys/types.h> /* For send(), others */
+#include <sys/socket.h>  /* For send(), others. */
+#include <unistd.h>
+#endif
+// Eugen C. <eug@thekompany.com>
+#include <errno.h>
+#include <stdlib.h> /* for malloc */
+#include <string.h>
+
+
+struct command_map {
+        enum icalcstp_command command;
+        char *str;
+} command_map[] = 
+{
+    {ICAL_ABORT_COMMAND,"ABORT"},
+    {ICAL_AUTHENTICATE_COMMAND,"AUTHENTICATE"},
+    {ICAL_CAPABILITY_COMMAND,"CAPABILITY"},
+    {ICAL_CONTINUE_COMMAND,"CONTINUE"},
+    {ICAL_CALIDEXPAND_COMMAND,"CALIDEXPAND"},
+    {ICAL_IDENTIFY_COMMAND,"IDENTIFY"},
+    {ICAL_DISCONNECT_COMMAND,"DISCONNECT"},
+    {ICAL_SENDDATA_COMMAND,"SENDDATA"},
+    {ICAL_STARTTLS_COMMAND,"STARTTLS"},
+    {ICAL_UPNEXPAND_COMMAND,"UPNEXPAND"},
+    {ICAL_UNKNOWN_COMMAND,"UNKNOWN"}
+};
+
+
+icalcstp_command icalcstp_line_command(char* line)
+{
+    int i;
+
+    for(i = 0; command_map[i].command != ICAL_UNKNOWN_COMMAND; i++){
+        size_t l = strlen(command_map[i].str);
+
+        if(strncmp(line, command_map[i].str, l) == 0){
+            return command_map[i].command;
+        }
+    
+    }
+
+    return ICAL_UNKNOWN_COMMAND;
+}
+
+icalrequeststatus icalcstp_line_response_code(char* line)
+{
+    struct icalreqstattype rs; 
+
+    rs = icalreqstattype_from_string(line);
+
+    return rs.code;
+}
+
+int icalcstp_line_is_endofdata(char* line)
+{
+    if(line[0] == '.' && line[1] == '\n'){
+        return 1;
+    }
+
+    return 0;
+
+}
+
+int icalcstp_line_is_mime(char* line)
+{
+  return 0;
+}
+
+
+const char* icalcstp_command_to_string(icalcstp_command command){
+
+    int i;
+
+    for(i = 0; command_map[i].command != ICAL_UNKNOWN_COMMAND; i++){
+        size_t l = strlen(command_map[i].str);
+
+        if(command_map[i].command == command){
+            return command_map[i].str;
+        }
+    
+    }
+
+    return command_map[i].str;
+
+}
+
diff --git a/libical/src/libicalss/icalcstp.h b/libical/src/libicalss/icalcstp.h
new file mode 100644
index 0000000..dfc3618
--- a/dev/null
+++ b/libical/src/libicalss/icalcstp.h
@@ -0,0 +1,79 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+  FILE: icalcstp.h
+  CREATOR: eric 20 April 1999
+  
+  $Id$
+
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalcstp.h
+
+======================================================================*/
+
+
+#ifndef ICALCSTP_H
+#define ICALCSTP_H
+
+#include "ical.h"
+
+
+/* Connection state, from the state machine in RFC2445 */
+enum cstps_state {
+    NO_STATE,
+    CONNECTED,
+    AUTHENTICATED,
+    IDENTIFIED,
+    DISCONNECTED,
+    RECEIVE
+};
+
+/* CSTP Commands that a client can issue to a server */
+typedef enum icalcstp_command {
+    ICAL_ABORT_COMMAND,
+    ICAL_AUTHENTICATE_COMMAND,
+    ICAL_CAPABILITY_COMMAND,
+    ICAL_CONTINUE_COMMAND,
+    ICAL_CALIDEXPAND_COMMAND,
+    ICAL_IDENTIFY_COMMAND,
+    ICAL_DISCONNECT_COMMAND,
+    ICAL_SENDDATA_COMMAND,
+    ICAL_STARTTLS_COMMAND,
+    ICAL_UPNEXPAND_COMMAND,
+    ICAL_COMPLETE_COMMAND,
+    ICAL_UNKNOWN_COMMAND
+} icalcstp_command;
+
+
+
+/* A statement is a combination of command or response code and a
+   component that the server and client exchage with each other. */
+struct icalcstp_statement {
+    icalcstp_command command;
+    char* str_data; /* If non-NUll use as arguments to command */
+    int int_data; /* If non-NULL use as arguments to command */
+
+    icalrequeststatus code;
+
+    icalcomponent* data;
+};
+
+const char* icalcstp_command_to_string(icalcstp_command command);
+icalcstp_command icalcstp_string_to_command(const char* str);
+
+#endif /* !ICALCSTP_H */
+
+
+
diff --git a/libical/src/libicalss/icalcstpclient.c b/libical/src/libicalss/icalcstpclient.c
new file mode 100644
index 0000000..03a70dd
--- a/dev/null
+++ b/libical/src/libicalss/icalcstpclient.c
@@ -0,0 +1,350 @@
+/* -*- Mode: C -*-
+    ======================================================================
+    FILE: icalcstps.c
+    CREATOR: ebusboom 23 Jun 2000
+  
+    $Id$
+    $Locker$
+    
+    (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+    
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of either: 
+    
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+    
+    Or:
+    
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+
+    ======================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "icalerror.h"
+#include "ical.h"
+#include "icalcstp.h"
+#include "icalcstpclient.h"
+#include "pvl.h" 
+
+// Eugen C. <eug@thekompany.com>
+#include <defines.h>
+#ifndef _QTWIN_
+#include <sys/types.h> /* For send(), others */
+#include <sys/socket.h>  /* For send(), others. */
+#include<unistd.h>
+#endif
+// Eugen C. <eug@thekompany.com>
+
+#include <errno.h>
+#include <stdlib.h> /* for malloc */
+#include <string.h>
+
+#define EOL "\n"
+
+
+/* Client state machine */
+
+typedef enum icalcstpc_line_type {
+    ICALCSTPC_RESPONSE_CODE_LINE,
+    ICALCSTPC_TERMINATOR_LINE,
+    ICALCSTPC_APPLICATION_DATA_LINE
+} icalcstpc_line_type;
+
+typedef enum icalcstpc_state {
+    ICALCSTPC_SEND_STATE,
+    ICALCSTPC_RESPONSE_CODE_STATE,
+    ICALCSTPC_RESPONSE_DATA_STATE
+} icalcstpc_state;
+
+
+
+struct icalcstpc_impl {
+    int timeout;
+    icalparser *parser;
+    icalcstp_command command;
+    icalcstpc_state state;
+    char* next_output;
+    char* next_input;
+};
+
+icalcstpc* icalcstpc_new()
+{
+    struct icalcstpc_impl *impl;
+
+    impl = malloc(sizeof(struct icalcstpc_impl));
+    
+    if(impl == 0){
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        return 0;
+    }
+
+    memset(impl,0,sizeof(struct icalcstpc_impl));
+
+    return impl;
+}
+
+void icalcstpc_free(icalcstpc* cstpc)
+{
+    struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstpc;
+
+    if(impl->next_output != 0){
+        free(impl->next_output);
+    }
+
+    if(impl->next_input != 0){
+        free(impl->next_input);
+    }
+    
+    
+    if(impl->parser != 0){
+        icalparser_free(impl->parser);
+    }
+}
+
+/* Get the next string to send to the server */
+char* icalcstpc_next_output(icalcstpc* cstp, char * line)
+{
+    char* out;
+    struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+
+    if(impl->next_output == 0){
+        return 0;
+    }
+    
+    out = impl->next_output;
+
+    impl->next_output = 0;
+
+    icalmemory_add_tmp_buffer(out);
+
+    return out;
+}
+
+/* process the next string sent by the server */ 
+int icalcstpc_next_input(icalcstpc* cstp, char* line)
+{
+    struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+    icalcstpc_line_type line_type;
+
+    if(icalcstp_line_is_endofdata(line) || line == 0){
+        return 0;
+    }
+
+    switch (impl->command){
+    case ICAL_ABORT_COMMAND:{
+        break;
+    }
+    case ICAL_AUTHENTICATE_COMMAND:{
+        break;
+    }
+    case ICAL_CAPABILITY_COMMAND:{
+        break;
+    }
+    case ICAL_CONTINUE_COMMAND:{
+        break;
+    }
+    case ICAL_CALIDEXPAND_COMMAND:{
+        break;
+    }
+    case ICAL_IDENTIFY_COMMAND:{
+        break;
+    }
+    case ICAL_DISCONNECT_COMMAND:{
+        break;
+    }
+    case ICAL_SENDDATA_COMMAND:{
+        break;
+    }
+    case ICAL_STARTTLS_COMMAND:{
+        break;
+    }
+    case ICAL_UPNEXPAND_COMMAND:{
+        break;
+    }
+    case ICAL_COMPLETE_COMMAND:{
+        break;
+    }
+    case ICAL_UNKNOWN_COMMAND:{
+        break;
+    }
+    default:
+        break;
+    }
+}
+
+/* After icalcstpc_next_input returns a 0, there are responses
+   ready. use these to get them */
+icalcstpc_response icalcstpc_first_response(icalcstpc* cstp)
+{
+    struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+
+}
+
+
+icalcstpc_response icalcstpc_next_response(icalcstpc* cstp)
+{
+    struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+}
+
+
+int icalcstpc_set_timeout(icalcstpc* cstp, int sec)
+{
+    struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+}
+
+icalerrorenum icalcstpc_abort(icalcstpc* cstp)
+{
+    struct icalcstpc_impl* impl = (struct icalcstpc_impl*)cstp;
+    
+    icalerror_check_arg_re(cstp!=0,"cstp",ICAL_BADARG_ERROR);
+
+    impl->next_output = "ABORT\n";
+
+    return ICAL_NO_ERROR;
+}
+
+icalerrorenum icalcstpclient_setup_output(icalcstpc* cstp, size_t sz)
+{
+   struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+
+   if(impl->next_output != 0){
+       icalerror_set_errno(ICAL_USAGE_ERROR);
+       return ICAL_USAGE_ERROR;
+   }
+
+   impl->next_output = malloc(sz);
+
+   if(impl->next_output == 0){
+       icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+       return ICAL_NEWFAILED_ERROR;
+   }
+   
+   return ICAL_NO_ERROR;
+
+}
+
+icalerrorenum icalcstpc_authenticate(icalcstpc* cstp, char* mechanism, 
+                                        char* data, char* f(char*))
+{
+   struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+   char* command_str;
+   icalerrorenum error;
+   size_t sz;
+
+   icalerror_check_arg_re(cstp!=0,"cstp",ICAL_BADARG_ERROR);
+   icalerror_check_arg_re(mechanism!=0,"mechanism",ICAL_BADARG_ERROR);
+   icalerror_check_arg_re(data!=0,"data",ICAL_BADARG_ERROR);
+   icalerror_check_arg_re(f!=0,"f",ICAL_BADARG_ERROR);
+
+   impl->command = ICAL_AUTHENTICATE_COMMAND;
+
+   command_str = icalcstp_command_to_string(impl->command);
+
+   sz = strlen(command_str) + strlen(mechanism) + strlen(data) + 4;
+
+   if((error=icalcstpclient_setup_output(cstp,sz)) != ICAL_NO_ERROR){
+       return error;
+   }
+
+   sprintf(impl->next_output,"%s %s %s%s",command_str,mechanism,data,EOL);
+
+   return ICAL_NO_ERROR;
+}
+
+icalerrorenum icalcstpc_capability(icalcstpc* cstp)
+{
+    struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+    char* command_str;
+    icalerrorenum error;
+    size_t sz;
+
+    icalerror_check_arg_re(cstp!=0,"cstp",ICAL_BADARG_ERROR);
+    
+    impl->command = ICAL_CAPABILITY_COMMAND;
+    
+    command_str = icalcstp_command_to_string(impl->command);
+
+    sz = strlen(command_str);
+    
+    if((error=icalcstpclient_setup_output(cstp,sz)) != ICAL_NO_ERROR){
+        return error;
+    }
+
+    return ICAL_NO_ERROR;
+}
+
+icalerrorenum icalcstpc_calidexpand(icalcstpc* cstp,char* calid)
+{
+    struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+
+    impl->command = ICAL_CALIDEXPAND_COMMAND;
+    return ICAL_NO_ERROR;
+}
+
+icalerrorenum icalcstpc_continue(icalcstpc* cstp, unsigned int time)
+{
+    struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+
+    impl->command = ICAL_CONTINUE_COMMAND;
+    return ICAL_NO_ERROR;
+}
+
+icalerrorenum icalcstpc_disconnect(icalcstpc* cstp)
+{
+    struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+
+
+    impl->command = ICAL_DISCONNECT_COMMAND;
+
+    return ICAL_NO_ERROR;
+}
+
+icalerrorenum icalcstpc_identify(icalcstpc* cstp, char* id)
+{
+    struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+
+
+    impl->command = ICAL_IDENTIFY_COMMAND;
+
+    return ICAL_NO_ERROR;
+}
+
+icalerrorenum icalcstpc_starttls(icalcstpc* cstp, char* command, 
+                                    char* data, char * f(char*))
+{
+    struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+
+    impl->command = ICAL_STARTTLS_COMMAND;
+    
+    return ICAL_NO_ERROR;
+}
+
+icalerrorenum icalcstpc_upnexpand(icalcstpc* cstp,char* calid)
+{
+    struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+
+
+    impl->command = ICAL_UPNEXPAND_COMMAND;
+
+    return ICAL_NO_ERROR;
+}
+
+icalerrorenum icalcstpc_sendata(icalcstpc* cstp, unsigned int time,
+                                   icalcomponent *comp)
+{
+    struct icalcstpc_impl *impl = (struct icalcstpc_impl *)cstp;
+
+    impl->command = ICAL_SENDDATA_COMMAND;
+    
+    return ICAL_NO_ERROR;
+}
+
+
+
+
diff --git a/libical/src/libicalss/icalcstpclient.h b/libical/src/libicalss/icalcstpclient.h
new file mode 100644
index 0000000..8d9d0c9
--- a/dev/null
+++ b/libical/src/libicalss/icalcstpclient.h
@@ -0,0 +1,100 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+  FILE: icalcstpclient.h
+  CREATOR: eric 4 Feb 01
+  
+  $Id$
+
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalcstp.h
+
+======================================================================*/
+
+
+#ifndef ICALCSTPC_H
+#define ICALCSTPC_H
+
+#include "ical.h"
+#include "icalcstp.h"
+
+/********************** Client (Sender) Interfaces **************************/
+
+/* How to use: 
+
+   1) Construct a new icalcstpc
+   2) Issue a command by calling one of the command routines. 
+   3) Repeat until both call icalcstpc_next_output and
+   icalcstpc_next_input return 0:
+     3a) Call icalcstpc_next_output. Send string to server. 
+     3b) Get string from server, & give to icalcstp_next_input()
+   4) Iterate with icalcstpc_first_response & icalcstp_next_response to 
+   get the servers responses
+   5) Repeat at #2
+*/
+
+
+typedef void icalcstpc;
+
+/* Response code sent by the server. */
+        typedef struct icalcstpc_response {
+    icalrequeststatus code;
+    char *arg; /* These strings are owned by libical */
+    char *debug_text;
+    char *more_text;
+    void* result;
+} icalcstpc_response;
+
+
+icalcstpc* icalcstpc_new();
+
+void icalcstpc_free(icalcstpc* cstpc);
+
+int icalcstpc_set_timeout(icalcstpc* cstp, int sec);
+
+
+/* Get the next string to send to the server */
+char* icalcstpc_next_output(icalcstpc* cstp, char* line);
+
+/* process the next string from the server */ 
+int icalcstpc_next_input(icalcstpc* cstp, char * line);
+
+/* After icalcstpc_next_input returns a 0, there are responses
+   ready. use these to get them */
+icalcstpc_response icalcstpc_first_response(icalcstpc* cstp);
+icalcstpc_response icalcstpc_next_response(icalcstpc* cstp);
+
+/* Issue a command */
+icalerrorenum icalcstpc_abort(icalcstpc* cstp);
+icalerrorenum icalcstpc_authenticate(icalcstpc* cstp, char* mechanism, 
+                                        char* init_data, char* f(char*) );
+icalerrorenum icalcstpc_capability(icalcstpc* cstp);
+icalerrorenum icalcstpc_calidexpand(icalcstpc* cstp,char* calid);
+icalerrorenum icalcstpc_continue(icalcstpc* cstp, unsigned int time);
+icalerrorenum icalcstpc_disconnect(icalcstpc* cstp);
+icalerrorenum icalcstpc_identify(icalcstpc* cstp, char* id);
+icalerrorenum icalcstpc_starttls(icalcstpc* cstp, char* command, 
+                                    char* init_data, char* f(char*));
+icalerrorenum icalcstpc_senddata(icalcstpc* cstp, unsigned int time,
+                                icalcomponent *comp);
+icalerrorenum icalcstpc_upnexpand(icalcstpc* cstp,char* calid);
+icalerrorenum icalcstpc_sendata(icalcstpc* cstp, unsigned int time,
+                                   icalcomponent *comp);
+
+
+#endif /* !ICALCSTPC_H */
+
+
+
diff --git a/libical/src/libicalss/icalcstpserver.c b/libical/src/libicalss/icalcstpserver.c
new file mode 100644
index 0000000..cd8b3bb
--- a/dev/null
+++ b/libical/src/libicalss/icalcstpserver.c
@@ -0,0 +1,285 @@
+/* -*- Mode: C -*-
+    ======================================================================
+    FILE: icalcstpserver.c
+    CREATOR: ebusboom 13 Feb 01
+  
+    $Id$
+    $Locker$
+    
+    (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+    
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of either: 
+    
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+    
+    Or:
+    
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+
+    ======================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "icalerror.h"
+#include "ical.h"
+#include "icalcstp.h"
+#include "icalcstpserver.h"
+#include "pvl.h" 
+
+// Eugen C. <eug@thekompany.com>
+#include <defines.h>
+#ifndef _QTWIN_
+#include <sys/types.h> /* For send(), others */
+#include <sys/socket.h>  /* For send(), others. */
+#include<unistd.h>
+#endif
+// Eugen C. <eug@thekompany.com>
+
+#include <errno.h>
+#include <stdlib.h> /* for malloc */
+#include <string.h>
+
+
+
+struct icalcstps_impl {
+        int timeout;
+        icalparser *parser;
+        enum cstps_state major_state;
+        struct icalcstps_commandfp commandfp;
+};
+
+
+
+
+/* This state machine is a Mealy-type: actions occur on the
+   transitions, not in the states.
+   
+   Here is the state machine diagram from the CAP draft:
+
+
+        STARTTLS /
+        CAPABILITY
+       +-------+
+       |       |                       +---------------+
+       |   +-----------+ AUTHENTICATE  |               |
+       +-->| Connected |-------------->| Authenticated |
+           +-----------+               |               |
+             |                         +---------------+
+             |                              |
+             |                              |
+             |                              |
+             |                              |       +-----+ STARTTLS /
+             |                              V       |     | CAPABILITY /
+             |                         +---------------+  | IDENTIFY
+             |                         |               |<-+
+             |                         |   Identified  |<----+
+             |                +--------|               |     |
+             |                |        +---------------+     | command
+             |                |             |                | completes
+             V                |DISCONNECT   |                |
+           +--------------+   |             |SENDDATA        |
+           | Disconnected |<--+             |                |
+           +--------------+                 |                | ABORT
+                     A                      |                |
+                     |                      V                |
+                     |     DISCONNECT     +---------------+  |
+                     +--------------------|    Receive    |--+
+                                          |               |<--+
+                                          +---------------+   |
+                                                         |    | CONTINUTE
+                                                         +----+
+
+   In this implmenetation, the transition from CONNECTED to IDENTIFIED
+   is non-standard. The spec specifies that on the ATHENTICATE
+   command, the machine transitions from CONNECTED to AUTHENTICATED,
+   and then immediately goes to IDENTIFIED. This makes AUTHENTICATED a
+   useless state, so I removed it */
+
+struct state_table {
+        enum cstps_state major_state;
+        enum icalcstp_command command;
+        void (*action)();
+        enum cstps_state next_state;
+
+} server_state_table[] = 
+{
+    { CONNECTED, ICAL_CAPABILITY_COMMAND , 0, CONNECTED},
+    { CONNECTED, ICAL_AUTHENTICATE_COMMAND , 0,  IDENTIFIED}, /* Non-standard */
+    { IDENTIFIED, ICAL_STARTTLS_COMMAND, 0, IDENTIFIED},
+    { IDENTIFIED, ICAL_IDENTIFY_COMMAND, 0, IDENTIFIED},
+    { IDENTIFIED, ICAL_CAPABILITY_COMMAND, 0, IDENTIFIED},
+    { IDENTIFIED, ICAL_SENDDATA_COMMAND, 0, RECEIVE},
+    { IDENTIFIED, ICAL_DISCONNECT_COMMAND, 0, DISCONNECTED},
+    { DISCONNECTED, 0, 0, 0},
+    { RECEIVE,  ICAL_DISCONNECT_COMMAND, 0, DISCONNECTED},
+    { RECEIVE,  ICAL_CONTINUE_COMMAND, 0, RECEIVE},
+    { RECEIVE,  ICAL_ABORT_COMMAND , 0, IDENTIFIED},
+    { RECEIVE,  ICAL_COMPLETE_COMMAND , 0, IDENTIFIED}
+};
+
+
+/**********************************************************************/
+
+
+
+icalcstps* icalcstps_new(struct icalcstps_commandfp cfp)
+{
+    struct icalcstps_impl* impl;
+
+    if ( ( impl = (struct icalcstps_impl*)
+           malloc(sizeof(struct icalcstps_impl))) == 0) {
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        return 0;
+    }
+
+    impl->commandfp = cfp;
+    impl->timeout = 10;
+
+    return (icalcstps*)impl;
+
+}
+
+void icalcstps_free(icalcstps* cstp);
+
+int icalcstps_set_timeout(icalcstps* cstp, int sec) 
+{
+    struct icalcstps_impl *impl = (struct icalcstps_impl *) cstp;
+
+    icalerror_check_arg_rz( (cstp!=0), "cstp");
+
+    impl->timeout = sec;
+
+    return sec;
+}
+
+        typedef struct icalcstps_response {
+        icalrequeststatus code;
+        char caluid[1024];
+        void* result;
+} icalcstps_response;
+
+
+icalerrorenum prep_abort(struct icalcstps_impl* impl, char* data)
+{
+    return ICAL_NO_ERROR;
+}
+icalerrorenum prep_authenticate(struct icalcstps_impl* impl, char* data)
+{    return ICAL_NO_ERROR;
+}
+icalerrorenum prep_capability(struct icalcstps_impl* impl, char* data)
+{    return ICAL_NO_ERROR;
+}
+icalerrorenum prep_calidexpand(struct icalcstps_impl* impl, char* data)
+{
+    return ICAL_NO_ERROR;
+}
+icalerrorenum prep_continue(struct icalcstps_impl* impl, char* data)
+{
+    return ICAL_NO_ERROR;
+}
+icalerrorenum prep_disconnect(struct icalcstps_impl* impl, char* data)
+{
+    return ICAL_NO_ERROR;
+}
+icalerrorenum prep_identify(struct icalcstps_impl* impl, char* data)
+{
+    return ICAL_NO_ERROR;
+}
+icalerrorenum prep_starttls(struct icalcstps_impl* impl, char* data)
+{
+    return ICAL_NO_ERROR;
+}
+icalerrorenum prep_upnexpand(struct icalcstps_impl* impl, char* data)
+{
+    return ICAL_NO_ERROR;
+}
+icalerrorenum prep_sendata(struct icalcstps_impl* impl, char* data)
+{    return ICAL_NO_ERROR;
+}
+
+char* icalcstps_process_incoming(icalcstps* cstp, char* input)
+{
+    struct icalcstps_impl *impl = (struct icalcstps_impl *) cstp;
+    char *i;
+    char *cmd_or_resp;
+    char *data;
+    char *input_cpy;
+    icalerrorenum error;
+
+    icalerror_check_arg_rz(cstp !=0,"cstp");
+    icalerror_check_arg_rz(input !=0,"input");
+
+    if ((input_cpy = (char*)strdup(input)) == 0){
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        return 0;
+    }
+
+    i = (char*)strstr(" ",input_cpy);
+
+    cmd_or_resp = input_cpy;
+
+    if (i != 0){
+        *i = '\0';
+        data = ++i;
+    } else {
+        data = 0;
+    }
+
+    printf("cmd: %s\n",cmd_or_resp);
+    printf("data: %s\n",data);
+        
+    /* extract the command, look up in the state table, and dispatch
+       to the proper handler */    
+
+    if(strcmp(cmd_or_resp,"ABORT") == 0){
+                error = prep_abort(impl,data);
+    } else if(strcmp(cmd_or_resp,"AUTHENTICATE") == 0){
+        error = prep_authenticate(impl,data);
+    } else if(strcmp(cmd_or_resp,"CAPABILITY") == 0){
+        error = prep_capability(impl,data);
+    } else if(strcmp(cmd_or_resp,"CALIDEXPAND") == 0){
+        error = prep_calidexpand(impl,data);
+    } else if(strcmp(cmd_or_resp,"CONTINUE") == 0){
+        error = prep_continue(impl,data);
+    } else if(strcmp(cmd_or_resp,"DISCONNECT") == 0){
+        error = prep_disconnect(impl,data);
+    } else if(strcmp(cmd_or_resp,"IDENTIFY") == 0){
+        error = prep_identify(impl,data);
+    } else if(strcmp(cmd_or_resp,"STARTTLS") == 0){
+        error = prep_starttls(impl,data);
+    } else if(strcmp(cmd_or_resp,"UPNEXPAND") == 0){
+        error = prep_upnexpand(impl,data);
+    } else if(strcmp(cmd_or_resp,"SENDDATA") == 0){
+        error = prep_sendata(impl,data);
+    }
+    
+    return 0;
+}
+
+    /* Read data until we get a end of data marker */
+
+
+
+struct icalcstps_server_stubs {
+  icalerrorenum (*abort)(icalcstps* cstp);
+  icalerrorenum (*authenticate)(icalcstps* cstp, char* mechanism, 
+                                    char* data);
+  icalerrorenum (*calidexpand)(icalcstps* cstp, char* calid);
+  icalerrorenum (*capability)(icalcstps* cstp);
+  icalerrorenum (*cont)(icalcstps* cstp, unsigned int time);
+  icalerrorenum (*identify)(icalcstps* cstp, char* id);
+  icalerrorenum (*disconnect)(icalcstps* cstp);
+  icalerrorenum (*sendata)(icalcstps* cstp, unsigned int time, 
+                               icalcomponent *comp);
+  icalerrorenum (*starttls)(icalcstps* cstp, char* command, 
+                                char* data);
+  icalerrorenum (*upnexpand)(icalcstps* cstp, char* upn);
+  icalerrorenum (*unknown)(icalcstps* cstp, char* command, char* data);
+};
+
diff --git a/libical/src/libicalss/icalcstpserver.h b/libical/src/libicalss/icalcstpserver.h
new file mode 100644
index 0000000..6fa2254
--- a/dev/null
+++ b/libical/src/libicalss/icalcstpserver.h
@@ -0,0 +1,101 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+  FILE: icalcstpserver.h
+  CREATOR: eric 13 Feb 01
+  
+  $Id$
+
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalcstp.h
+
+======================================================================*/
+
+
+#ifndef ICALCSTPS_H
+#define ICALCSTPS_H
+
+#include "ical.h"
+
+
+/********************** Server (Reciever) Interfaces *************************/
+
+/* On the server side, the caller will recieve data from the incoming
+   socket and pass it to icalcstps_next_input. The caller then takes
+   the return from icalcstps_next_outpu and sends it out through the
+   socket. This gives the caller a point of control. If the cstp code
+   connected to the socket itself, it would be hard for the caller to
+   do anything else after the cstp code was started.
+
+   All of the server and client command routines will generate
+   response codes. On the server side, these responses will be turned
+   into text and sent to the client. On the client side, the reponse
+   is the one sent from the server.
+
+   Since each command can return multiple responses, the responses are
+   stored in the icalcstps object and are accesses by
+   icalcstps_first_response() and icalcstps_next_response()
+
+   How to use: 
+
+   1) Construct a new icalcstps, bound to your code via stubs
+   2) Repeat forever:
+     2a) Get string from client & give to icalcstps_next_input()
+     2b) Repeat until icalcstp_next_output returns 0:
+       2b1) Call icalcstps_next_output. 
+       2b2) Send string to client.
+*/
+
+
+
+typedef void icalcstps;
+
+/* Pointers to the rountines that
+   icalcstps_process_incoming will call when it recognizes a CSTP
+   command in the data. BTW, the CONTINUE command is named 'cont'
+   because 'continue' is a C keyword */
+
+struct icalcstps_commandfp {
+  icalerrorenum (*abort)(icalcstps* cstp);
+  icalerrorenum (*authenticate)(icalcstps* cstp, char* mechanism,
+                                    char* data);
+  icalerrorenum (*calidexpand)(icalcstps* cstp, char* calid);
+  icalerrorenum (*capability)(icalcstps* cstp);
+  icalerrorenum (*cont)(icalcstps* cstp, unsigned int time);
+  icalerrorenum (*identify)(icalcstps* cstp, char* id);
+  icalerrorenum (*disconnect)(icalcstps* cstp);
+  icalerrorenum (*sendata)(icalcstps* cstp, unsigned int time,
+                               icalcomponent *comp);
+  icalerrorenum (*starttls)(icalcstps* cstp, char* command,
+                                char* data);
+  icalerrorenum (*upnexpand)(icalcstps* cstp, char* upn);
+  icalerrorenum (*unknown)(icalcstps* cstp, char* command, char* data);
+};                                                        
+
+
+
+icalcstps* icalcstps_new(struct icalcstps_commandfp stubs);
+
+void icalcstps_free(icalcstps* cstp);
+
+int icalcstps_set_timeout(icalcstps* cstp, int sec);
+
+/* Get the next string to send to the client */
+char* icalcstps_next_output(icalcstps* cstp);
+
+/* process the next string from the client */ 
+int icalcstps_next_input(icalcstps* cstp);
+
+#endif /* ICALCSTPS */
diff --git a/libical/src/libicalss/icaldirset.c b/libical/src/libicalss/icaldirset.c
new file mode 100644
index 0000000..b6cb673
--- a/dev/null
+++ b/libical/src/libicalss/icaldirset.c
@@ -0,0 +1,777 @@
+/* -*- Mode: C -*-
+    ======================================================================
+    FILE: icaldirset.c
+    CREATOR: eric 28 November 1999
+  
+    $Id$
+    $Locker$
+    
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+    The Original Code is eric. The Initial Developer of the Original
+    Code is Eric Busboom
+
+
+    ======================================================================*/
+
+
+/*
+ 
+  icaldirset manages a database of ical components and offers
+  interfaces for reading, writting and searching for components.
+
+  icaldirset groups components in to clusters based on their DTSTAMP
+  time -- all components that start in the same month are grouped
+  together in a single file. All files in a sotre are kept in a single
+  directory. 
+
+  The primary interfaces are icaldirset_first and icaldirset_next. These
+  routine iterate through all of the components in the store, subject
+  to the current gauge. A gauge is an icalcomponent that is tested
+  against other componets for a match. If a gauge has been set with
+  icaldirset_select, icaldirset_first and icaldirset_next will only
+  return componentes that match the gauge.
+
+  The Store generated UIDs for all objects that are stored if they do
+  not already have a UID. The UID is the name of the cluster (month &
+  year as MMYYYY) plus a unique serial number. The serial number is
+  stored as a property of the cluster.
+
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+
+#include "icalerror.h"
+#include "ical.h"
+#include "icaldirset.h"
+#include "pvl.h" 
+#include "icalparser.h"
+#include "icaldirset.h"
+#include "icalfileset.h"
+#include "icalfilesetimpl.h"
+#include "icalgauge.h"
+
+#include <limits.h> /* For PATH_MAX */
+#include <errno.h>
+#include <sys/types.h> /* for opendir() */
+#include <sys/stat.h> /* for stat */
+
+int snprintf(char *str, size_t n, char const *fmt, ...);
+
+// Eugen C. <eug@thekompany.com>
+#include <defines.h>
+#ifndef _QTWIN_
+#include <dirent.h> /* for opendir() */
+#include <unistd.h>
+#include <sys/utsname.h> /* for uname */
+#endif
+// Eugen C. <eug@thekompany.com>
+
+#include <time.h> /* for clock() */
+#include <stdlib.h> /* for rand(), srand() */
+#include <string.h> /* for strdup */
+#include "icaldirsetimpl.h"
+
+
+struct icaldirset_impl* icaldirset_new_impl()
+{
+    struct icaldirset_impl* impl;
+
+    if ( ( impl = (struct icaldirset_impl*)
+           malloc(sizeof(struct icaldirset_impl))) == 0) {
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        return 0;
+    }
+
+    strcpy(impl->id,ICALDIRSET_ID);
+
+    return impl;
+}
+
+const char* icaldirset_path(icaldirset* cluster)
+{
+    struct icaldirset_impl *impl = icaldirset_new_impl();
+
+    return impl->dir;
+
+}
+
+void icaldirset_mark(icaldirset* store)
+{
+    struct icaldirset_impl *impl = (struct icaldirset_impl*)store;
+
+    icalfileset_mark(impl->cluster);
+}
+
+
+icalerrorenum icaldirset_commit(icaldirset* store)
+{
+    struct icaldirset_impl *impl = (struct icaldirset_impl*)store;
+
+    return icalfileset_commit(impl->cluster);
+
+}
+
+void icaldirset_lock(const char* dir)
+{
+}
+
+
+void icaldirset_unlock(const char* dir)
+{
+}
+
+/* Load the contents of the store directory into the store's internal directory list*/
+icalerrorenum icaldirset_read_directory(struct icaldirset_impl* impl)
+{
+#ifndef _QTWIN_
+    struct dirent *de;
+    DIR* dp;
+    char *str;
+ 
+    dp = opendir(impl->dir);
+   
+    if ( dp == 0) {
+        icalerror_set_errno(ICAL_FILE_ERROR);
+        return ICAL_FILE_ERROR;
+    }
+
+    /* clear contents of directory list */
+    while((str = pvl_pop(impl->directory))){
+        free(str);
+    }
+    
+    /* load all of the cluster names in the directory list */
+    for(de = readdir(dp);
+        de != 0;
+        de = readdir(dp)){
+
+        /* Remove known directory names  '.' and '..'*/
+        if (strcmp(de->d_name,".") == 0 ||
+            strcmp(de->d_name,"..") == 0 ){
+            continue;
+        }
+
+                pvl_push(impl->directory, (void*)strdup(de->d_name));
+    }
+
+    closedir(dp);
+
+    return ICAL_NO_ERROR;
+#else
+        icalerror_set_errno(ICAL_FILE_ERROR);
+        return ICAL_FILE_ERROR;
+#endif
+}
+
+icaldirset* icaldirset_new(const char* dir)
+{
+    struct icaldirset_impl *impl = icaldirset_new_impl();
+    struct stat sbuf;
+
+    if (impl == 0){
+        return 0;
+    }
+
+    icalerror_check_arg_rz( (dir!=0), "dir");
+
+    if (stat(dir,&sbuf) != 0){
+        icalerror_set_errno(ICAL_FILE_ERROR);
+        return 0;
+    }
+    
+#ifndef _QTWIN_
+    /* dir is not the name of a direectory*/
+    if (!S_ISDIR(sbuf.st_mode)){ 
+        icalerror_set_errno(ICAL_USAGE_ERROR);
+        return 0;
+            }    
+#endif
+
+    icaldirset_lock(dir);
+
+    impl = icaldirset_new_impl();
+
+    if (impl ==0){
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        return 0;
+    }
+    
+    impl->directory = pvl_newlist();
+    impl->directory_iterator = 0;
+    impl->dir = (char*)strdup(dir);
+    impl->gauge = 0;
+    impl->first_component = 0;
+    impl->cluster = 0;
+
+    icaldirset_read_directory(impl);
+
+    return (icaldirset*) impl;
+}
+
+void icaldirset_free(icaldirset* s)
+{
+    struct icaldirset_impl *impl = (struct icaldirset_impl*)s;
+    char* str;
+
+    icaldirset_unlock(impl->dir);
+
+    if(impl->dir !=0){
+        free(impl->dir);
+    }
+
+    if(impl->gauge !=0){
+        icalcomponent_free(impl->gauge);
+    }
+
+    if(impl->cluster !=0){
+        icalfileset_free(impl->cluster);
+    }
+
+    while(impl->directory !=0 &&  (str=pvl_pop(impl->directory)) != 0){
+        free(str);
+    }
+
+    if(impl->directory != 0){
+        pvl_free(impl->directory);
+    }
+
+    impl->directory = 0;
+    impl->directory_iterator = 0;
+    impl->dir = 0;
+    impl->gauge = 0;
+    impl->first_component = 0;
+
+    free(impl);
+
+}
+
+/* icaldirset_next_uid_number updates a serial number in the Store
+   directory in a file called SEQUENCE */
+
+int icaldirset_next_uid_number(icaldirset* store)
+{
+    struct icaldirset_impl *impl = (struct icaldirset_impl*)store;
+    char sequence = 0;
+    char temp[128];
+    char filename[ICAL_PATH_MAX];
+    char *r;
+    FILE *f;
+    struct stat sbuf;
+
+    icalerror_check_arg_rz( (store!=0), "store");
+
+    sprintf(filename,"%s/%s",impl->dir,"SEQUENCE");
+
+    /* Create the file if it does not exist.*/
+#ifndef _QTWIN_
+    if (stat(filename,&sbuf) == -1 || !S_ISREG(sbuf.st_mode)){
+#else
+    if (stat(filename,&sbuf) == -1){
+#endif
+
+        f = fopen(filename,"w");
+        if (f != 0){
+            fprintf(f,"0");
+            fclose(f);
+        } else {
+            icalerror_warn("Can't create SEQUENCE file in icaldirset_next_uid_number");
+            return 0;
+        }
+        
+    }
+    
+    if ( (f = fopen(filename,"r+")) != 0){
+
+        rewind(f);
+        r = fgets(temp,128,f);
+
+        if (r == 0){
+            sequence = 1;
+        } else {
+            sequence = atoi(temp)+1;
+        }
+
+        rewind(f);
+
+        fprintf(f,"%d",sequence);
+
+        fclose(f);
+
+        return sequence;
+        
+    } else {
+        icalerror_warn("Can't create SEQUENCE file in icaldirset_next_uid_number");
+        return 0;
+    }
+
+}
+
+icalerrorenum icaldirset_next_cluster(icaldirset* store)
+{
+    struct icaldirset_impl *impl = (struct icaldirset_impl*)store;
+    char path[ICAL_PATH_MAX];
+
+    if (impl->directory_iterator == 0){
+        icalerror_set_errno(ICAL_INTERNAL_ERROR);
+        return ICAL_INTERNAL_ERROR;
+            }    
+    impl->directory_iterator = pvl_next(impl->directory_iterator);
+
+    if (impl->directory_iterator == 0){
+        /* There are no more clusters */
+        if(impl->cluster != 0){
+            icalfileset_free(impl->cluster);
+            impl->cluster = 0;
+        }
+        return ICAL_NO_ERROR;
+    }
+            
+    sprintf(path,"%s/%s",impl->dir,(char*)pvl_data(impl->directory_iterator));
+
+    icalfileset_free(impl->cluster);
+
+    impl->cluster = icalfileset_new(path);
+
+    return icalerrno;
+}
+
+void icaldirset_add_uid(icaldirset* store, icaldirset* comp)
+{
+#ifndef _QTWIN_
+
+    char uidstring[ICAL_PATH_MAX];
+    icalproperty *uid;
+    struct utsname unamebuf;
+
+    icalerror_check_arg_rv( (store!=0), "store");
+    icalerror_check_arg_rv( (comp!=0), "comp");
+
+    uid = icalcomponent_get_first_property(comp,ICAL_UID_PROPERTY);
+    
+    if (uid == 0) {
+        
+        uname(&unamebuf);
+        
+        sprintf(uidstring,"%d-%s",(int)getpid(),unamebuf.nodename);
+        
+        uid = icalproperty_new_uid(uidstring);
+        icalcomponent_add_property(comp,uid);
+    } else {
+        
+        strcpy(uidstring,icalproperty_get_uid(uid));
+    }
+
+#endif
+}
+
+
+/* This assumes that the top level component is a VCALENDAR, and there
+   is an inner component of type VEVENT, VTODO or VJOURNAL. The inner
+   component must have a DTAMP property */
+
+icalerrorenum icaldirset_add_component(icaldirset* store, icaldirset* comp)
+{
+    struct icaldirset_impl *impl;
+    char clustername[ICAL_PATH_MAX];
+    icalproperty *dt;
+    icalvalue *v;
+    struct icaltimetype tm;
+    icalerrorenum error = ICAL_NO_ERROR;
+    icalcomponent *inner;
+
+    impl = (struct icaldirset_impl*)store;
+    icalerror_check_arg_rz( (store!=0), "store");
+    icalerror_check_arg_rz( (comp!=0), "comp");
+
+    errno = 0;
+    
+    icaldirset_add_uid(store,comp);
+
+    /* Determine which cluster this object belongs in. This is a HACK */
+
+    for(inner = icalcomponent_get_first_component(comp,ICAL_ANY_COMPONENT);
+        inner != 0;
+        inner = icalcomponent_get_next_component(comp,ICAL_ANY_COMPONENT)){
+  
+        dt = icalcomponent_get_first_property(inner,ICAL_DTSTAMP_PROPERTY);
+         
+        if (dt != 0){
+            break; 
+                }
+    }
+
+    if (dt == 0){
+
+        for(inner = icalcomponent_get_first_component(comp,ICAL_ANY_COMPONENT);
+            inner != 0;
+            inner = icalcomponent_get_next_component(comp,ICAL_ANY_COMPONENT)){
+            
+            dt = icalcomponent_get_first_property(inner,ICAL_DTSTART_PROPERTY);
+            
+            if (dt != 0){
+                break; 
+                    }
+        }
+
+    }
+
+    if (dt == 0){
+
+
+        icalerror_warn("The component does not have a DTSTAMP or DTSTART property, so it cannot be added to the store");
+        icalerror_set_errno(ICAL_BADARG_ERROR);
+        return ICAL_BADARG_ERROR;
+    }
+
+    v = icalproperty_get_value(dt);
+
+    tm = icalvalue_get_datetime(v);
+
+    snprintf(clustername,ICAL_PATH_MAX,"%s/%04d%02d",impl->dir,tm.year,tm.month);
+
+    /* Load the cluster and insert the object */
+
+    if(impl->cluster != 0 && 
+       strcmp(clustername,icalfileset_path(impl->cluster)) != 0 ){
+        icalfileset_free(impl->cluster);
+        impl->cluster = 0;
+    }
+
+    if (impl->cluster == 0){
+        impl->cluster = icalfileset_new(clustername);
+
+        if (impl->cluster == 0){
+            error = icalerrno;
+        }
+    }
+    
+    if (error != ICAL_NO_ERROR){
+        icalerror_set_errno(error);
+        return error;
+    }
+
+    /* Add the component to the cluster */
+
+    icalfileset_add_component(impl->cluster,comp);
+    
+    icalfileset_mark(impl->cluster);
+
+    return ICAL_NO_ERROR;    
+}
+
+/* Remove a component in the current cluster. HACK. This routine is a
+   "friend" of icalfileset, and breaks its encapsulation. It was
+   either do it this way, or add several layers of interfaces that had
+   no other use.  */
+icalerrorenum icaldirset_remove_component(icaldirset* store, icaldirset* comp)
+{
+    struct icaldirset_impl *impl = (struct icaldirset_impl*)store;
+
+    struct icalfileset_impl *filesetimpl = 
+        (struct icalfileset_impl*)impl->cluster;
+
+    icalcomponent *filecomp = filesetimpl->cluster;
+
+    icalcompiter i;
+    int found = 0;
+
+    icalerror_check_arg_re((store!=0),"store",ICAL_BADARG_ERROR);
+    icalerror_check_arg_re((comp!=0),"comp",ICAL_BADARG_ERROR);
+    icalerror_check_arg_re((impl->cluster!=0),"Cluster pointer",ICAL_USAGE_ERROR);
+
+    for(i = icalcomponent_begin_component(filecomp,ICAL_ANY_COMPONENT);
+        icalcompiter_deref(&i)!= 0; icalcompiter_next(&i)){
+        
+        icalcomponent *this = icalcompiter_deref(&i);
+
+        if (this == comp){
+            found = 1;
+            break;
+        }
+    }
+
+    if (found != 1){
+        icalerror_warn("icaldirset_remove_component: component is not part of current cluster");
+        icalerror_set_errno(ICAL_USAGE_ERROR);
+        return ICAL_USAGE_ERROR;
+    }
+
+    icalfileset_remove_component(impl->cluster,comp);
+
+    icalfileset_mark(impl->cluster);
+
+    /* If the removal emptied the fileset, get the next fileset */
+    if( icalfileset_count_components(impl->cluster,ICAL_ANY_COMPONENT)==0){
+        
+        icalerrorenum error = icaldirset_next_cluster(store);
+
+        if(impl->cluster != 0 && error == ICAL_NO_ERROR){
+            icalfileset_get_first_component(impl->cluster);
+        } else {
+            /* HACK. Not strictly correct for impl->cluster==0 */
+            return error;
+        }
+    } else {
+        /* Do nothing */
+    }
+
+    return ICAL_NO_ERROR;
+}
+
+
+
+int icaldirset_count_components(icaldirset* store,
+                               icalcomponent_kind kind)
+{
+    /* HACK, not implemented */
+    
+    assert(0);
+
+    return 0;
+}
+
+
+icalcomponent* icaldirset_fetch_match(icaldirset* set, icalcomponent *c)
+{
+    fprintf(stderr," icaldirset_fetch_match is not implemented\n");
+    assert(0);
+}
+
+
+icalcomponent* icaldirset_fetch(icaldirset* store, const char* uid)
+{
+    icalcomponent *gauge;
+    icalcomponent *old_gauge;
+    icalcomponent *c;
+    struct icaldirset_impl *impl = (struct icaldirset_impl*)store;
+
+    icalerror_check_arg_rz( (store!=0), "store");
+    icalerror_check_arg_rz( (uid!=0), "uid");
+
+    gauge = 
+        icalcomponent_vanew(
+            ICAL_VCALENDAR_COMPONENT,
+            icalcomponent_vanew(
+                ICAL_VEVENT_COMPONENT,  
+                icalproperty_vanew_uid(
+                    uid,
+                    icalparameter_new_xliccomparetype(
+                        ICAL_XLICCOMPARETYPE_EQUAL),
+                    0),
+                0),
+            0);
+
+    old_gauge = impl->gauge;
+    impl->gauge = gauge;
+
+    c= icaldirset_get_first_component(store);
+
+    impl->gauge = old_gauge;
+
+    icalcomponent_free(gauge);
+
+    return c;
+}
+
+
+int icaldirset_has_uid(icaldirset* store, const char* uid)
+{
+    icalcomponent *c;
+
+    icalerror_check_arg_rz( (store!=0), "store");
+    icalerror_check_arg_rz( (uid!=0), "uid");
+    
+    /* HACK. This is a temporary implementation. _has_uid should use a
+       database, and _fetch should use _has_uid, not the other way
+       around */
+    c = icaldirset_fetch(store,uid);
+
+    return c!=0;
+
+}
+
+
+icalerrorenum icaldirset_select(icaldirset* store, icalcomponent* gauge)
+ {
+    struct icaldirset_impl *impl = (struct icaldirset_impl*)store;
+
+    icalerror_check_arg_re( (store!=0), "store",ICAL_BADARG_ERROR);
+    icalerror_check_arg_re( (gauge!=0), "gauge",ICAL_BADARG_ERROR);
+
+    if (!icalcomponent_is_valid(gauge)){
+        return ICAL_BADARG_ERROR;
+    }
+
+    impl->gauge = gauge;
+
+    return ICAL_NO_ERROR;
+}
+
+
+icalerrorenum icaldirset_modify(icaldirset* store, icalcomponent *old,
+                               icalcomponent *new)
+{
+    assert(0);
+    return ICAL_NO_ERROR; /* HACK, not implemented */
+
+}
+
+
+void icaldirset_clear(icaldirset* store)
+{
+
+    assert(0);
+    return;
+    /* HACK, not implemented */
+}
+
+icalcomponent* icaldirset_get_current_component(icaldirset* store)
+{
+    struct icaldirset_impl *impl = (struct icaldirset_impl*)store;
+
+    if(impl->cluster == 0){
+        icaldirset_get_first_component(store);
+    }
+
+    return icalfileset_get_current_component(impl->cluster);
+
+}
+
+
+icalcomponent* icaldirset_get_first_component(icaldirset* store)
+{
+    struct icaldirset_impl *impl = (struct icaldirset_impl*)store;
+    icalerrorenum error;
+    char path[ICAL_PATH_MAX];
+
+    error = icaldirset_read_directory(impl);
+
+    if (error != ICAL_NO_ERROR){
+        icalerror_set_errno(error);
+        return 0;
+    }
+
+    impl->directory_iterator = pvl_head(impl->directory);
+    
+    if (impl->directory_iterator == 0){
+        icalerror_set_errno(error);
+        return 0;
+    }
+    
+    snprintf(path,ICAL_PATH_MAX,"%s/%s",impl->dir,(char*)pvl_data(impl->directory_iterator));
+
+    /* If the next cluster we need is different than the current cluster, 
+       delete the current one and get a new one */
+
+    if(impl->cluster != 0 && strcmp(path,icalfileset_path(impl->cluster)) != 0 ){
+        icalfileset_free(impl->cluster);
+        impl->cluster = 0;
+    }
+    
+    if (impl->cluster == 0){
+        impl->cluster = icalfileset_new(path);
+
+        if (impl->cluster == 0){
+            error = icalerrno;
+        }
+    } 
+
+    if (error != ICAL_NO_ERROR){
+        icalerror_set_errno(error);
+        return 0;
+    }
+
+    impl->first_component = 1;
+
+    return icaldirset_get_next_component(store);
+}
+
+icalcomponent* icaldirset_get_next_component(icaldirset* store)
+{
+    struct icaldirset_impl *impl;
+    icalcomponent *c;
+    icalerrorenum error;
+
+    icalerror_check_arg_rz( (store!=0), "store");
+
+    impl = (struct icaldirset_impl*)store;
+
+    if(impl->cluster == 0){
+
+        icalerror_warn("icaldirset_get_next_component called with a NULL cluster (Caller must call icaldirset_get_first_component first");
+        icalerror_set_errno(ICAL_USAGE_ERROR);
+        return 0;
+
+    }
+
+    /* Set the component iterator for the following for loop */
+    if (impl->first_component == 1){
+        icalfileset_get_first_component(impl->cluster);
+        impl->first_component = 0;
+    } else {
+        icalfileset_get_next_component(impl->cluster);
+    }
+
+
+    while(1){
+        /* Iterate through all of the objects in the cluster*/
+        for( c = icalfileset_get_current_component(impl->cluster);
+             c != 0;
+             c = icalfileset_get_next_component(impl->cluster)){
+            
+            /* If there is a gauge defined and the component does not
+               pass the gauge, skip the rest of the loop */
+
+#if 0 /* HACK */
+            if (impl->gauge != 0 && icalgauge_test(c,impl->gauge) == 0){
+                continue;
+            }
+#else
+            assert(0); /* icalgauge_test needs to be fixed */
+#endif
+            /* Either there is no gauge, or the component passed the
+               gauge, so return it*/
+
+            return c;
+        }
+
+        /* Fell through the loop, so the component we want is not
+           in this cluster. Load a new cluster and try again.*/
+
+        error = icaldirset_next_cluster(store);
+
+        if(impl->cluster == 0 || error != ICAL_NO_ERROR){
+            /* No more clusters */
+            return 0;
+        } else {
+            c = icalfileset_get_first_component(impl->cluster);
+
+            return c;
+        }
+        
+    }
+
+    return 0; /* Should never get here */
+}
+
+   
+
+
+
+
+        
diff --git a/libical/src/libicalss/icaldirset.h b/libical/src/libicalss/icaldirset.h
new file mode 100644
index 0000000..7d205ec
--- a/dev/null
+++ b/libical/src/libicalss/icaldirset.h
@@ -0,0 +1,82 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icaldirset.h
+ CREATOR: eric 28 November 1999
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+======================================================================*/
+
+#ifndef ICALDIRSET_H
+#define ICALDIRSET_H
+
+#include "ical.h"
+
+/* icaldirset Routines for storing, fetching, and searching for ical
+ * objects in a database */
+
+typedef void icaldirset;
+
+
+icaldirset* icaldirset_new(const char* path);
+
+void icaldirset_free(icaldirset* store);
+
+const char* icaldirset_path(icaldirset* store);
+
+/* Mark the cluster as changed, so it will be written to disk when it
+   is freed. Commit writes to disk immediately*/
+void icaldirset_mark(icaldirset* store);
+icalerrorenum icaldirset_commit(icaldirset* store); 
+
+icalerrorenum icaldirset_add_component(icaldirset* store, icalcomponent* comp);
+icalerrorenum icaldirset_remove_component(icaldirset* store, icalcomponent* comp);
+
+int icaldirset_count_components(icaldirset* store,
+                               icalcomponent_kind kind);
+
+/* Restrict the component returned by icaldirset_first, _next to those
+   that pass the gauge. _clear removes the gauge. */
+icalerrorenum icaldirset_select(icaldirset* store, icalcomponent* gauge);
+void icaldirset_clear(icaldirset* store);
+
+/* Get a component by uid */
+icalcomponent* icaldirset_fetch(icaldirset* store, const char* uid);
+int icaldirset_has_uid(icaldirset* store, const char* uid);
+icalcomponent* icaldirset_fetch_match(icaldirset* set, icalcomponent *c);
+
+/* Modify components according to the MODIFY method of CAP. Works on
+   the currently selected components. */
+icalerrorenum icaldirset_modify(icaldirset* store, icalcomponent *oldc,
+                               icalcomponent *newc);
+
+/* Iterate through the components. If a guage has been defined, these
+   will skip over components that do not pass the gauge */
+
+icalcomponent* icaldirset_get_current_component(icaldirset* store);
+icalcomponent* icaldirset_get_first_component(icaldirset* store);
+icalcomponent* icaldirset_get_next_component(icaldirset* store);
+
+#endif /* !ICALDIRSET_H */
+
+
+
diff --git a/libical/src/libicalss/icaldirsetimpl.h b/libical/src/libicalss/icaldirsetimpl.h
new file mode 100644
index 0000000..0e69ba2
--- a/dev/null
+++ b/libical/src/libicalss/icaldirsetimpl.h
@@ -0,0 +1,47 @@
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: icaldirsetimpl.h
+  CREATOR: eric 21 Aug 2000
+  
+  $Id$
+  $Locker$
+    
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+ ======================================================================*/
+
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+/* This definition is in its own file so it can be kept out of the
+   main header file, but used by "friend classes" like icalset*/
+
+#define ICALDIRSET_ID "dset"
+
+struct icaldirset_impl 
+{
+        char id[5]; /* "dset" */
+        char* dir;
+        icalcomponent* gauge;
+        icaldirset* cluster;
+        int first_component;
+        pvl_list directory;
+        pvl_elem directory_iterator;
+};
diff --git a/libical/src/libicalss/icalfileset.c b/libical/src/libicalss/icalfileset.c
new file mode 100644
index 0000000..943071d
--- a/dev/null
+++ b/libical/src/libicalss/icalfileset.c
@@ -0,0 +1,659 @@
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: icalfileset.c
+  CREATOR: eric 23 December 1999
+  
+  $Id$
+  $Locker$
+    
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+ ======================================================================*/
+
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <errno.h>
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#include <fcntl.h> /* For open() flags and mode */
+#include <sys/types.h> /* For open() flags and mode */
+#include <sys/stat.h> /* For open() flags and mode */
+
+#include "icalfileset.h"
+#include "icalfilesetimpl.h"
+
+// Eugen C. <eug@thekompany.com>
+#include <defines.h>
+//
+
+int snprintf(char *str, size_t n, char const *fmt, ...);
+
+//extern int errno;
+
+int icalfileset_lock(icalfileset *cluster);
+int icalfileset_unlock(icalfileset *cluster);
+icalerrorenum icalfileset_read_file(icalfileset* cluster, mode_t mode);
+int icalfileset_filesize(icalfileset* cluster);
+
+icalerrorenum icalfileset_create_cluster(const char *path);
+
+icalfileset* icalfileset_new_impl()
+{
+    struct icalfileset_impl* impl;
+  
+    if ( ( impl = (struct icalfileset_impl*)
+           malloc(sizeof(struct icalfileset_impl))) == 0) {
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        errno = ENOMEM;
+        return 0;
+    }
+  
+    memset(impl,0,sizeof(struct icalfileset_impl));
+  
+    strcpy(impl->id,ICALFILESET_ID);
+  
+    return impl;
+}
+
+
+icalfileset* icalfileset_new(const char* path)
+{
+    return icalfileset_new_open(path, O_RDWR|O_CREAT, 0664);
+}
+
+icalfileset* icalfileset_new_open(const char* path, int flags, mode_t mode)
+{
+    struct icalfileset_impl *impl = icalfileset_new_impl(); 
+    struct icaltimetype tt;
+    off_t cluster_file_size;
+
+    memset(&tt,0,sizeof(struct icaltimetype));
+
+    icalerror_clear_errno();
+    icalerror_check_arg_rz( (path!=0), "path");
+
+    if (impl == 0){
+        return 0;
+    }
+
+    impl->path = strdup(path); 
+
+    cluster_file_size = icalfileset_filesize(impl);
+        
+    if(cluster_file_size < 0){
+        icalfileset_free(impl);
+        return 0;
+    } 
+
+    impl->fd = open(impl->path,flags, mode);
+    
+    if (impl->fd < 0){
+        icalerror_set_errno(ICAL_FILE_ERROR);
+        icalfileset_free(impl);
+        return 0;
+    }
+
+    icalfileset_lock(impl);
+    
+    if(cluster_file_size > 0 ){
+        icalerrorenum error;
+        if((error = icalfileset_read_file(impl,mode))!= ICAL_NO_ERROR){
+            icalfileset_free(impl);
+            return 0;
+        }
+    }
+ 
+    if(impl->cluster == 0){
+        impl->cluster = icalcomponent_new(ICAL_XROOT_COMPONENT);
+    }      
+    
+    return impl;
+}
+
+char* icalfileset_read_from_file(char *s, size_t size, void *d)
+{
+    
+    char* p = s;
+    int fd = (int)d;
+
+    /* Simulate fgets -- read single characters and stop at '\n' */
+
+    for(p=s; p<s+size-1;p++){
+        
+        if(read(fd,p,1) != 1 || *p=='\n'){
+            p++;
+            break;
+        } 
+    }
+
+    *p = '\0';
+    
+    if(*s == 0){
+        return 0;
+    } else {
+        return s;
+    }
+
+}
+
+
+icalerrorenum icalfileset_read_file(icalfileset* cluster,mode_t mode)
+{
+
+    icalparser *parser;
+  
+    struct icalfileset_impl *impl = (struct icalfileset_impl*)cluster;
+    
+    parser = icalparser_new();
+    icalparser_set_gen_data(parser,(void*)impl->fd);
+    impl->cluster = icalparser_parse(parser,icalfileset_read_from_file);
+    icalparser_free(parser);
+
+    if (impl->cluster == 0 || icalerrno != ICAL_NO_ERROR){
+        icalerror_set_errno(ICAL_PARSE_ERROR);
+        return ICAL_PARSE_ERROR;
+    }
+  
+    if (icalcomponent_isa(impl->cluster) != ICAL_XROOT_COMPONENT){
+        /* The parser got a single component, so it did not put it in
+           an XROOT. */
+        icalcomponent *cl = impl->cluster;
+        impl->cluster = icalcomponent_new(ICAL_XROOT_COMPONENT);
+        icalcomponent_add_component(impl->cluster,cl);
+    }
+
+    return ICAL_NO_ERROR;
+
+}
+
+int icalfileset_filesize(icalfileset* cluster)
+{
+    struct icalfileset_impl *impl = (struct icalfileset_impl*)cluster;
+    int cluster_file_size;
+    struct stat sbuf;
+
+    if (stat(impl->path,&sbuf) != 0){
+        
+        /* A file by the given name does not exist, or there was
+           another error */
+        cluster_file_size = 0;
+        if (errno == ENOENT) {
+            /* It was because the file does not exist */
+            return 0;
+        } else {
+            /* It was because of another error */
+            icalerror_set_errno(ICAL_FILE_ERROR);
+            return -1;
+        }
+    } else {
+        /* A file by the given name exists, but is it a regular file? */
+        
+#ifndef _QTWIN_
+        if (!S_ISREG(sbuf.st_mode)){ 
+            /* Nope, not a regular file */
+            icalerror_set_errno(ICAL_FILE_ERROR);
+            return -1;
+        } else {
+            /* Lets assume that it is a file of the right type */
+            return sbuf.st_size;
+        }
+#else
+            return sbuf.st_size;
+#endif
+        
+    }
+
+    /*return -1; not reached*/
+}
+
+void icalfileset_free(icalfileset* cluster)
+{
+    struct icalfileset_impl *impl = (struct icalfileset_impl*)cluster;
+
+    icalerror_check_arg_rv((cluster!=0),"cluster");
+
+    if (impl->cluster != 0){
+        icalfileset_commit(cluster);
+        icalcomponent_free(impl->cluster);
+        impl->cluster=0;
+    }
+
+    if(impl->fd > 0){
+        icalfileset_unlock(impl);
+        close(impl->fd);
+        impl->fd = -1;
+    }
+
+    if(impl->path != 0){
+        free(impl->path);
+        impl->path = 0;
+    }
+
+    free(impl);
+}
+
+const char* icalfileset_path(icalfileset* cluster)
+{
+    struct icalfileset_impl *impl = (struct icalfileset_impl*)cluster;
+    icalerror_check_arg_rz((cluster!=0),"cluster");
+
+    return impl->path;
+}
+
+
+int icalfileset_lock(icalfileset *cluster)
+{
+#ifndef _WIN32
+    struct icalfileset_impl *impl = (struct icalfileset_impl*)cluster;
+    struct flock lock;
+    int rtrn;
+
+    icalerror_check_arg_rz((impl->fd>0),"impl->fd");
+    errno = 0;
+    lock.l_type = F_WRLCK;     /* F_RDLCK, F_WRLCK, F_UNLCK */
+    lock.l_start = 0;  /* byte offset relative to l_whence */
+    lock.l_whence = SEEK_SET; /* SEEK_SET, SEEK_CUR, SEEK_END */
+    lock.l_len = 0;       /* #bytes (0 means to EOF) */
+
+    rtrn = fcntl(impl->fd, F_SETLKW, &lock);
+
+    return rtrn;
+#else
+    return -1;
+#endif
+}
+
+int icalfileset_unlock(icalfileset *cluster)
+{
+#ifndef _WIN32
+    struct icalfileset_impl *impl = (struct icalfileset_impl*)cluster;
+    struct flock lock;
+    icalerror_check_arg_rz((impl->fd>0),"impl->fd");
+
+    lock.l_type = F_WRLCK;     /* F_RDLCK, F_WRLCK, F_UNLCK */
+    lock.l_start = 0;  /* byte offset relative to l_whence */
+    lock.l_whence = SEEK_SET; /* SEEK_SET, SEEK_CUR, SEEK_END */
+    lock.l_len = 0;       /* #bytes (0 means to EOF) */
+
+    return (fcntl(impl->fd, F_UNLCK, &lock)); 
+#else
+  return -1;
+#endif
+}
+
+#ifdef ICAL_SAFESAVES
+int icalfileset_safe_saves=1;
+#else
+int icalfileset_safe_saves=0;
+#endif
+
+icalerrorenum icalfileset_commit(icalfileset* cluster)
+{
+    char tmp[ICAL_PATH_MAX]; 
+    char *str;
+    icalcomponent *c;
+    off_t write_size=0;
+    
+    struct icalfileset_impl *impl = (struct icalfileset_impl*)cluster;
+    
+    icalerror_check_arg_re((impl!=0),"cluster",ICAL_BADARG_ERROR);  
+    
+    icalerror_check_arg_re((impl->fd>0),"impl->fd is invalid",
+                           ICAL_INTERNAL_ERROR) ;
+
+    if (impl->changed == 0 ){
+        return ICAL_NO_ERROR;
+    }
+    
+    if(icalfileset_safe_saves == 1){
+        snprintf(tmp,ICAL_PATH_MAX,"cp %s %s.bak",impl->path,impl->path);
+        
+        if(system(tmp) < 0){
+            icalerror_set_errno(ICAL_FILE_ERROR);
+            return ICAL_FILE_ERROR;
+        }
+    }
+
+    if(lseek(impl->fd,SEEK_SET,0) < 0){
+        icalerror_set_errno(ICAL_FILE_ERROR);
+        return ICAL_FILE_ERROR;
+    }
+    
+    for(c = icalcomponent_get_first_component(impl->cluster,ICAL_ANY_COMPONENT);
+        c != 0;
+        c = icalcomponent_get_next_component(impl->cluster,ICAL_ANY_COMPONENT)){
+        int sz;
+
+        str = icalcomponent_as_ical_string(c);
+    
+        sz=write(impl->fd,str,strlen(str));
+
+        if ( sz != strlen(str)){
+            perror("write");
+            icalerror_set_errno(ICAL_FILE_ERROR);
+            return ICAL_FILE_ERROR;
+        }
+
+        write_size += sz;
+    }
+    
+    impl->changed = 0;    
+
+#ifndef _QTWIN_
+    if(ftruncate(impl->fd,write_size) < 0){
+        return ICAL_FILE_ERROR;
+    }
+#endif
+    
+    return ICAL_NO_ERROR;
+    
+} 
+
+void icalfileset_mark(icalfileset* cluster){
+
+    struct icalfileset_impl *impl = (struct icalfileset_impl*)cluster;
+
+    icalerror_check_arg_rv((impl!=0),"cluster");
+
+    impl->changed = 1;
+
+}
+
+icalcomponent* icalfileset_get_component(icalfileset* cluster){
+    struct icalfileset_impl *impl = (struct icalfileset_impl*)cluster;
+
+    icalerror_check_arg_re((impl!=0),"cluster",ICAL_BADARG_ERROR);
+
+    return impl->cluster;
+}
+
+
+/* manipulate the components in the cluster */
+
+icalerrorenum icalfileset_add_component(icalfileset *cluster,
+                                        icalcomponent* child)
+{
+    struct icalfileset_impl* impl = (struct icalfileset_impl*)cluster;
+
+    icalerror_check_arg_re((cluster!=0),"cluster", ICAL_BADARG_ERROR);
+    icalerror_check_arg_re((child!=0),"child",ICAL_BADARG_ERROR);
+
+    icalcomponent_add_component(impl->cluster,child);
+
+    icalfileset_mark(cluster);
+
+    return ICAL_NO_ERROR;
+
+}
+
+icalerrorenum icalfileset_remove_component(icalfileset *cluster,
+                                           icalcomponent* child)
+{
+    struct icalfileset_impl* impl = (struct icalfileset_impl*)cluster;
+
+    icalerror_check_arg_re((cluster!=0),"cluster",ICAL_BADARG_ERROR);
+    icalerror_check_arg_re((child!=0),"child",ICAL_BADARG_ERROR);
+
+    icalcomponent_remove_component(impl->cluster,child);
+
+    icalfileset_mark(cluster);
+
+    return ICAL_NO_ERROR;
+}
+
+int icalfileset_count_components(icalfileset *cluster,
+                                 icalcomponent_kind kind)
+{
+    struct icalfileset_impl* impl = (struct icalfileset_impl*)cluster;
+
+    if(cluster == 0){
+        icalerror_set_errno(ICAL_BADARG_ERROR);
+        return -1;
+    }
+
+    return icalcomponent_count_components(impl->cluster,kind);
+}
+
+icalerrorenum icalfileset_select(icalfileset* set, icalgauge* gauge)
+{
+    struct icalfileset_impl* impl = (struct icalfileset_impl*)set;
+
+    icalerror_check_arg_re(gauge!=0,"guage",ICAL_BADARG_ERROR);
+
+    impl->gauge = gauge;
+
+    return ICAL_NO_ERROR;
+}
+
+void icalfileset_clear(icalfileset* gauge)
+{
+    struct icalfileset_impl* impl = (struct icalfileset_impl*)gauge;
+    
+    impl->gauge = 0;
+
+}
+
+icalcomponent* icalfileset_fetch(icalfileset* store,const char* uid)
+{
+    icalcompiter i;    
+    struct icalfileset_impl* impl = (struct icalfileset_impl*)store;
+    
+    for(i = icalcomponent_begin_component(impl->cluster,ICAL_ANY_COMPONENT);
+        icalcompiter_deref(&i)!= 0; icalcompiter_next(&i)){
+        
+        icalcomponent *this = icalcompiter_deref(&i);
+        icalcomponent *inner = icalcomponent_get_first_real_component(this);
+        icalcomponent *p;
+        const char *this_uid;
+
+        if(inner != 0){
+            p = icalcomponent_get_first_property(inner,ICAL_UID_PROPERTY);
+            this_uid = icalproperty_get_uid(p);
+
+            if(this_uid==0){
+                icalerror_warn("icalfileset_fetch found a component with no UID");
+                continue;
+            }
+
+            if (strcmp(uid,this_uid)==0){
+                return this;
+            }
+        }
+    }
+
+    return 0;
+}
+
+int icalfileset_has_uid(icalfileset* store,const char* uid)
+{
+    assert(0); /* HACK, not implemented */
+    return 0;
+}
+
+/******* support routines for icalfileset_fetch_match *********/
+
+struct icalfileset_id{
+    char* uid;
+    char* recurrence_id;
+    int sequence;
+};
+
+void icalfileset_id_free(struct icalfileset_id *id)
+{
+    if(id->recurrence_id != 0){
+        free(id->recurrence_id);
+    }
+
+    if(id->uid != 0){
+        free(id->uid);
+    }
+
+}
+
+struct icalfileset_id icalfileset_get_id(icalcomponent* comp)
+{
+
+    icalcomponent *inner;
+    struct icalfileset_id id;
+    icalproperty *p;
+
+    inner = icalcomponent_get_first_real_component(comp);
+    
+    p = icalcomponent_get_first_property(inner, ICAL_UID_PROPERTY);
+
+    assert(p!= 0);
+
+    id.uid = strdup(icalproperty_get_uid(p));
+
+    p = icalcomponent_get_first_property(inner, ICAL_SEQUENCE_PROPERTY);
+
+    if(p == 0) {
+        id.sequence = 0;
+    } else { 
+        id.sequence = icalproperty_get_sequence(p);
+    }
+
+    p = icalcomponent_get_first_property(inner, ICAL_RECURRENCEID_PROPERTY);
+
+    if (p == 0){
+        id.recurrence_id = 0;
+    } else {
+        icalvalue *v;
+        v = icalproperty_get_value(p);
+        id.recurrence_id = strdup(icalvalue_as_ical_string(v));
+
+        assert(id.recurrence_id != 0);
+    }
+
+    return id;
+}
+
+/* Find the component that is related to the given
+   component. Currently, it just matches based on UID and
+   RECURRENCE-ID */
+icalcomponent* icalfileset_fetch_match(icalfileset* set, icalcomponent *comp)
+{
+    struct icalfileset_impl* impl = (struct icalfileset_impl*)set;
+    icalcompiter i;    
+
+    struct icalfileset_id comp_id, match_id;
+    
+    comp_id = icalfileset_get_id(comp);
+
+    for(i = icalcomponent_begin_component(impl->cluster,ICAL_ANY_COMPONENT);
+        icalcompiter_deref(&i)!= 0; icalcompiter_next(&i)){
+        
+        icalcomponent *match = icalcompiter_deref(&i);
+
+        match_id = icalfileset_get_id(match);
+
+        if(strcmp(comp_id.uid, match_id.uid) == 0 &&
+           ( comp_id.recurrence_id ==0 || 
+             strcmp(comp_id.recurrence_id, match_id.recurrence_id) ==0 )){
+
+            /* HACK. What to do with SEQUENCE? */
+
+            icalfileset_id_free(&match_id);
+            icalfileset_id_free(&comp_id);
+            return match;
+            
+        }
+        
+        icalfileset_id_free(&match_id);
+    }
+
+    icalfileset_id_free(&comp_id);
+    return 0;
+
+}
+
+
+icalerrorenum icalfileset_modify(icalfileset* store, icalcomponent *old,
+                                 icalcomponent *new)
+{
+    assert(0); /* HACK, not implemented */
+    return ICAL_NO_ERROR;
+}
+
+
+/* Iterate through components */
+icalcomponent* icalfileset_get_current_component (icalfileset* cluster)
+{
+    struct icalfileset_impl* impl = (struct icalfileset_impl*)cluster;
+
+    icalerror_check_arg_rz((cluster!=0),"cluster");
+
+    return icalcomponent_get_current_component(impl->cluster);
+}
+
+
+icalcomponent* icalfileset_get_first_component(icalfileset* cluster)
+{
+    struct icalfileset_impl* impl = (struct icalfileset_impl*)cluster;
+    icalcomponent *c=0;
+
+    icalerror_check_arg_rz((cluster!=0),"cluster");
+
+    do {
+        if (c == 0){
+            c = icalcomponent_get_first_component(impl->cluster,
+                                                  ICAL_ANY_COMPONENT);
+        } else {
+            c = icalcomponent_get_next_component(impl->cluster,
+                                                 ICAL_ANY_COMPONENT);
+        }
+
+        if(c != 0 && (impl->gauge == 0 ||
+                      icalgauge_compare(impl->gauge,c) == 1)){
+            return c;
+        }
+
+    } while(c != 0);
+
+
+    return 0;
+}
+
+icalcomponent* icalfileset_get_next_component(icalfileset* cluster)
+{
+    struct icalfileset_impl* impl = (struct icalfileset_impl*)cluster;
+    icalcomponent *c;
+
+    icalerror_check_arg_rz((cluster!=0),"cluster");
+    
+    do {
+        c = icalcomponent_get_next_component(impl->cluster,
+                                             ICAL_ANY_COMPONENT);
+
+        if(c != 0 && (impl->gauge == 0 ||
+                      icalgauge_compare(impl->gauge,c) == 1)){
+            return c;
+        }
+        
+    } while(c != 0);
+    
+    
+    return 0;
+}
+
diff --git a/libical/src/libicalss/icalfileset.h b/libical/src/libicalss/icalfileset.h
new file mode 100644
index 0000000..51254d2
--- a/dev/null
+++ b/libical/src/libicalss/icalfileset.h
@@ -0,0 +1,107 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalfileset.h
+ CREATOR: eric 23 December 1999
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+======================================================================*/
+
+#ifndef ICALFILESET_H
+#define ICALFILESET_H
+
+#include "icalerror.h"
+#include "ical.h"
+#include "icalset.h"
+#include "icalgauge.h"
+
+extern int icalfileset_safe_saves;
+
+typedef void icalfileset;
+
+
+/* icalfileset
+   icalfilesetfile
+   icalfilesetdir
+*/
+
+
+icalfileset* icalfileset_new(const char* path);
+
+#ifdef _WIN32
+#define mode_t int
+#endif
+
+/* Like _new, but takes open() flags for opening the file */
+icalfileset* icalfileset_new_open(const char* path, 
+                                  int flags, mode_t mode);
+
+void icalfileset_free(icalfileset* cluster);
+
+const char* icalfileset_path(icalfileset* cluster);
+
+/* Mark the cluster as changed, so it will be written to disk when it
+   is freed. Commit writes to disk immediately. */
+void icalfileset_mark(icalfileset* cluster);
+icalerrorenum icalfileset_commit(icalfileset* cluster); 
+
+icalerrorenum icalfileset_add_component(icalfileset* cluster,
+                                        icalcomponent* child);
+
+icalerrorenum icalfileset_remove_component(icalfileset* cluster,
+                                           icalcomponent* child);
+
+int icalfileset_count_components(icalfileset* cluster,
+                                 icalcomponent_kind kind);
+
+/* Restrict the component returned by icalfileset_first, _next to those
+   that pass the gauge. _clear removes the gauge */
+icalerrorenum icalfileset_select(icalfileset* store, icalgauge* gauge);
+void icalfileset_clear(icalfileset* store);
+
+/* Get and search for a component by uid */
+icalcomponent* icalfileset_fetch(icalfileset* cluster, const char* uid);
+int icalfileset_has_uid(icalfileset* cluster, const char* uid);
+icalcomponent* icalfileset_fetch_match(icalfileset* set, icalcomponent *c);
+
+
+/* Modify components according to the MODIFY method of CAP. Works on
+   the currently selected components. */
+icalerrorenum icalfileset_modify(icalfileset* store, icalcomponent *oldcomp,
+                               icalcomponent *newcomp);
+
+/* Iterate through components. If a guage has been defined, these
+   will skip over components that do not pass the gauge */
+
+icalcomponent* icalfileset_get_current_component (icalfileset* cluster);
+icalcomponent* icalfileset_get_first_component(icalfileset* cluster);
+icalcomponent* icalfileset_get_next_component(icalfileset* cluster);
+/* Return a reference to the internal component. You probably should
+   not be using this. */
+
+icalcomponent* icalfileset_get_component(icalfileset* cluster);
+
+
+#endif /* !ICALFILESET_H */
+
+
+
diff --git a/libical/src/libicalss/icalfilesetimpl.h b/libical/src/libicalss/icalfilesetimpl.h
new file mode 100644
index 0000000..fcd3415
--- a/dev/null
+++ b/libical/src/libicalss/icalfilesetimpl.h
@@ -0,0 +1,49 @@
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: icalfilesetimpl.h
+  CREATOR: eric 23 December 1999
+  
+  $Id$
+  $Locker$
+    
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+ ======================================================================*/
+
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "icalgauge.h"
+
+/* This definition is in its own file so it can be kept out of the
+   main header file, but used by "friend classes" like icaldirset*/
+
+#define ICALFILESET_ID "fset"
+
+struct icalfileset_impl {
+
+  char id[5]; /*fset*/
+  char *path;
+  icalcomponent* cluster;
+  icalgauge* gauge;
+  int changed;
+  int fd; /* file descriptor */
+};
+
diff --git a/libical/src/libicalss/icalgauge.c b/libical/src/libicalss/icalgauge.c
new file mode 100644
index 0000000..b958ecf
--- a/dev/null
+++ b/libical/src/libicalss/icalgauge.c
@@ -0,0 +1,447 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalgauge.c
+ CREATOR: eric 23 December 1999
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+======================================================================*/
+
+#include "ical.h"
+#include "icalgauge.h"
+#include "icalgaugeimpl.h"
+#include <stdlib.h>
+
+extern char* input_buffer;
+extern char* input_buffer_p;
+int ssparse(void);
+
+struct icalgauge_impl *icalss_yy_gauge;
+
+icalgauge* icalgauge_new_from_sql(char* sql)
+{
+    struct icalgauge_impl *impl;
+
+    int r;
+    
+    if ( ( impl = (struct icalgauge_impl*)
+           malloc(sizeof(struct icalgauge_impl))) == 0) {
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        return 0;
+    }
+
+    impl->select = pvl_newlist();
+    impl->from = pvl_newlist();
+    impl->where = pvl_newlist();
+
+    icalss_yy_gauge = impl;
+
+    input_buffer_p = input_buffer = sql;
+    r = ssparse();
+
+    return impl;
+}
+
+
+void icalgauge_free(icalgauge* gauge)
+{
+      struct icalgauge_impl *impl =  (struct icalgauge_impl*)gauge;
+      struct icalgauge_where *w;
+
+      assert(impl->select != 0);
+      assert(impl->where != 0);
+      assert(impl->from != 0);
+
+      if(impl->select){
+          while( (w=pvl_pop(impl->select)) != 0){
+              if(w->value != 0){
+                  free(w->value);
+              }
+              free(w);
+          }
+          pvl_free(impl->select);
+      }
+
+      if(impl->where){
+          while( (w=pvl_pop(impl->where)) != 0){
+              
+              if(w->value != 0){
+                  free(w->value);
+              }
+              free(w);
+          }
+          pvl_free(impl->where);
+      }
+
+      if(impl->from){
+          pvl_free(impl->from);
+      }
+      
+}
+
+/* Convert a VQUERY component into a gauge */
+icalcomponent* icalgauge_make_gauge(icalcomponent* query);
+
+/* icaldirset_test compares a component against a gauge, and returns
+   true if the component passes the test 
+
+   The gauge is a VCALENDAR component that specifies how to test the
+   target components. The guage holds a collection of VEVENT, VTODO or
+   VJOURNAL sub-components. Each of the sub-components has a
+   collection of properties that are compared to corresponding
+   properties in the target component, according to the
+   X-LIC-COMPARETYPE parameters to the gauge's properties.
+
+   When a gauge has several sub-components, the results of testing the
+   target against each of them is ORed together - the target
+   component will pass if it matches any of the sub-components in the
+   gauge. However, the results of matching the properties in a
+   sub-component are ANDed -- the target must match every property in
+   a gauge sub-component to match the sub-component.
+
+   Here is an example:
+
+   BEGIN:XROOT
+   DTSTART;X-LIC-COMPARETYPE=LESS:19981025T020000
+   ORGANIZER;X-LIC-COMPARETYPE=EQUAL:mrbig@host.com 
+   END:XROOT
+   BEGIN:XROOT
+   LOCATION;X-LIC-COMPARETYPE=EQUAL:McNary's Pub
+   END:XROOT
+
+   This gauge has two sub-components; one which will match a VEVENT
+   based on start time, and organizer, and another that matches based
+   on LOCATION. A target component will pass the test if it matched
+   either of the sub-components.
+   
+  */
+
+
+int icalgauge_compare_recurse(icalcomponent* comp, icalcomponent* gauge)
+{
+    int pass = 1,localpass = 0;
+    icalproperty *p;
+    icalcomponent *child,*subgauge; 
+    icalcomponent_kind gaugekind, compkind;
+
+    icalerror_check_arg_rz( (comp!=0), "comp");
+    icalerror_check_arg_rz( (gauge!=0), "gauge");
+
+    gaugekind = icalcomponent_isa(gauge);
+    compkind = icalcomponent_isa(comp);
+
+    if( ! (gaugekind == compkind || gaugekind == ICAL_ANY_COMPONENT) ){
+        return 0;
+    }   
+
+    /* Test properties. For each property in the gauge, search through
+       the component for a similar property. If one is found, compare
+       the two properties value with the comparison specified in the
+       gauge with the X-LIC-COMPARETYPE parameter */
+    
+    for(p = icalcomponent_get_first_property(gauge,ICAL_ANY_PROPERTY);
+        p != 0;
+        p = icalcomponent_get_next_property(gauge,ICAL_ANY_PROPERTY)){
+        
+        icalproperty* targetprop; 
+        icalparameter* compareparam;
+        icalparameter_xliccomparetype compare;
+        int rel; /* The relationship between the gauge and target values.*/
+        
+        /* Extract the comparison type from the gauge. If there is no
+           comparison type, assume that it is "EQUAL" */
+        
+        compareparam = icalproperty_get_first_parameter(
+            p,
+            ICAL_XLICCOMPARETYPE_PARAMETER);
+        
+        if (compareparam!=0){
+            compare = icalparameter_get_xliccomparetype(compareparam);
+        } else {
+            compare = ICAL_XLICCOMPARETYPE_EQUAL;
+        }
+        
+        /* Find a property in the component that has the same type
+           as the gauge property. HACK -- multiples of a single
+           property type in the gauge will match only the first
+           instance in the component */
+        
+        targetprop = icalcomponent_get_first_property(comp,
+                                                      icalproperty_isa(p));
+        
+        if(targetprop != 0){
+        
+            /* Compare the values of the gauge property and the target
+               property */
+            
+            rel = icalvalue_compare(icalproperty_get_value(p),
+                                    icalproperty_get_value(targetprop));
+            
+            /* Now see if the comparison is equavalent to the comparison
+               specified in the gauge */
+            
+            if (rel == compare){ 
+                localpass++; 
+            } else if (compare == ICAL_XLICCOMPARETYPE_LESSEQUAL && 
+                       ( rel == ICAL_XLICCOMPARETYPE_LESS ||
+                         rel == ICAL_XLICCOMPARETYPE_EQUAL)) {
+                localpass++;
+            } else if (compare == ICAL_XLICCOMPARETYPE_GREATEREQUAL && 
+                       ( rel == ICAL_XLICCOMPARETYPE_GREATER ||
+                         rel == ICAL_XLICCOMPARETYPE_EQUAL)) {
+                localpass++;
+            } else if (compare == ICAL_XLICCOMPARETYPE_NOTEQUAL && 
+                       ( rel == ICAL_XLICCOMPARETYPE_GREATER ||
+                         rel == ICAL_XLICCOMPARETYPE_LESS)) {
+                localpass++;
+            } else {
+                localpass = 0;
+            }
+            
+            pass = pass && (localpass>0);
+        }
+    }
+    
+    /* Test subcomponents. Look for a child component that has a
+       counterpart in the gauge. If one is found, recursively call
+       icaldirset_test */
+    
+    for(subgauge = icalcomponent_get_first_component(gauge,ICAL_ANY_COMPONENT);
+        subgauge != 0;
+        subgauge = icalcomponent_get_next_component(gauge,ICAL_ANY_COMPONENT)){
+        
+        gaugekind = icalcomponent_isa(subgauge);
+
+        if (gaugekind == ICAL_ANY_COMPONENT){
+            child = icalcomponent_get_first_component(comp,ICAL_ANY_COMPONENT);
+        } else {
+            child = icalcomponent_get_first_component(comp,gaugekind);
+        }
+        
+        if(child !=0){
+            localpass = icalgauge_compare_recurse(child,subgauge);
+            pass = pass && localpass;
+        } else {
+            pass = 0;
+        }
+    }
+    
+    return pass;   
+}
+
+
+int icalgauge_compare(icalgauge* gauge,icalcomponent* comp)
+{
+
+    struct icalgauge_impl *impl = (struct icalgauge_impl*)gauge;
+    icalcomponent *inner; 
+    int local_pass = 0;
+    int last_clause = 1, this_clause = 1;
+    pvl_elem e;
+
+    icalerror_check_arg_rz( (comp!=0), "comp");
+    icalerror_check_arg_rz( (gauge!=0), "gauge");
+    
+    inner = icalcomponent_get_first_real_component(comp);
+
+    if(inner == 0){
+        icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+        return 0;
+    }
+
+
+    /* Check that this component is one of the FROM types */
+    local_pass = 0;
+    for(e = pvl_head(impl->from);e!=0;e=pvl_next(e)){
+        icalcomponent_kind k = (icalcomponent_kind)pvl_data(e);
+
+        if(k == icalcomponent_isa(inner)){
+            local_pass=1;
+        }
+    }
+    
+    if(local_pass == 0){
+        return 0;
+    }
+
+    
+    /* Check each where clause against the component */
+    for(e = pvl_head(impl->where);e!=0;e=pvl_next(e)){
+        struct icalgauge_where *w = pvl_data(e);
+        icalcomponent *sub_comp;
+        icalvalue *v;
+        icalproperty *prop;
+        icalvalue_kind vk;
+
+        if(w->prop == ICAL_NO_PROPERTY || w->value == 0){
+            icalerror_set_errno(ICAL_INTERNAL_ERROR);
+            return 0;
+        }
+
+        /* First, create a value from the gauge */
+        vk = icalenum_property_kind_to_value_kind(w->prop);
+
+        if(vk == ICAL_NO_VALUE){
+            icalerror_set_errno(ICAL_INTERNAL_ERROR);
+            return 0;
+        }
+
+        v = icalvalue_new_from_string(vk,w->value);
+
+        if (v == 0){
+            /* Keep error set by icalvalue_from-string*/
+            return 0;
+        }
+            
+        /* Now find the corresponding property in the component,
+           descending into a sub-component if necessary */
+
+        if(w->comp == ICAL_NO_COMPONENT){
+            sub_comp = inner;
+        } else {
+            sub_comp = icalcomponent_get_first_component(inner,w->comp);
+            if(sub_comp == 0){
+                return 0;
+            }
+                }   
+
+        this_clause = 0;
+        local_pass = 0;
+        for(prop = icalcomponent_get_first_property(sub_comp,w->prop);
+            prop != 0;
+            prop = icalcomponent_get_next_property(sub_comp,w->prop)){
+            icalvalue* prop_value;
+            icalgaugecompare relation;
+
+            prop_value = icalproperty_get_value(prop);
+
+            relation = (icalgaugecompare)icalvalue_compare(prop_value,v);
+            
+            if (relation  == w->compare){ 
+                local_pass++; 
+            } else if (w->compare == ICALGAUGECOMPARE_LESSEQUAL && 
+                       ( relation  == ICALGAUGECOMPARE_LESS ||
+                         relation  == ICALGAUGECOMPARE_EQUAL)) {
+                local_pass++;
+            } else if (w->compare == ICALGAUGECOMPARE_GREATEREQUAL && 
+                       ( relation  == ICALGAUGECOMPARE_GREATER ||
+                         relation  == ICALGAUGECOMPARE_EQUAL)) {
+                local_pass++;
+            } else if (w->compare == ICALGAUGECOMPARE_NOTEQUAL && 
+                       ( relation  == ICALGAUGECOMPARE_GREATER ||
+                         relation  == ICALGAUGECOMPARE_LESS)) {
+                local_pass++;
+            } else {
+                local_pass = 0;
+            }
+        }
+    
+        this_clause = local_pass > 0 ? 1 : 0;
+
+        /* Now look at the logic operator for this clause to see how
+           the value should be merge with the previous clause */
+
+        if(w->logic == ICALGAUGELOGIC_AND){
+            last_clause = this_clause && last_clause;
+        } else if(w->logic == ICALGAUGELOGIC_AND) {
+            last_clause = this_clause || last_clause;
+        } else {
+            last_clause = this_clause;
+        }
+    }
+
+    return last_clause;
+
+}
+    
+
+void icalgauge_dump(icalcomponent* gauge)
+{
+
+    pvl_elem *p;
+    struct icalgauge_impl *impl = (struct icalgauge_impl*)gauge;
+  
+  
+    printf("--- Select ---\n");
+    for(p = pvl_head(impl->select);p!=0;p=pvl_next(p)){
+        struct icalgauge_where *w = pvl_data(p);
+
+        if(w->comp != ICAL_NO_COMPONENT){
+            printf("%s ",icalenum_component_kind_to_string(w->comp));
+        }
+
+        if(w->prop != ICAL_NO_PROPERTY){
+            printf("%s ",icalenum_property_kind_to_string(w->prop));
+        }
+        
+        if (w->compare != ICALGAUGECOMPARE_NONE){
+            printf("%d ",w->compare);
+        }
+
+
+        if (w->value!=0){
+            printf("%s",w->value);
+        }
+
+
+        printf("\n");
+    }
+
+    printf("--- From ---\n");
+    for(p = pvl_head(impl->from);p!=0;p=pvl_next(p)){
+        icalcomponent_kind k = (icalcomponent_kind)pvl_data(p);
+
+        printf("%s\n",icalenum_component_kind_to_string(k));
+    }
+
+    printf("--- Where ---\n");
+    for(p = pvl_head(impl->where);p!=0;p=pvl_next(p)){
+        struct icalgauge_where *w = pvl_data(p);
+
+        if(w->logic != ICALGAUGELOGIC_NONE){
+            printf("%d ",w->logic);
+        }
+        
+        if(w->comp != ICAL_NO_COMPONENT){
+            printf("%s ",icalenum_component_kind_to_string(w->comp));
+        }
+
+        if(w->prop != ICAL_NO_PROPERTY){
+            printf("%s ",icalenum_property_kind_to_string(w->prop));
+        }
+        
+        if (w->compare != ICALGAUGECOMPARE_NONE){
+            printf("%d ",w->compare);
+        }
+
+
+        if (w->value!=0){
+            printf("%s",w->value);
+        }
+
+
+        printf("\n");
+    }
+
+    
+}
+
diff --git a/libical/src/libicalss/icalgauge.h b/libical/src/libicalss/icalgauge.h
new file mode 100644
index 0000000..1caf0ac
--- a/dev/null
+++ b/libical/src/libicalss/icalgauge.h
@@ -0,0 +1,51 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalgauge.h
+ CREATOR: eric 23 December 1999
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+======================================================================*/
+
+#ifndef ICALGAUGE_H
+#define ICALGAUGE_H
+
+typedef void icalgauge;
+
+icalgauge* icalgauge_new_from_sql(char* sql);
+
+void icalgauge_free(icalgauge* gauge);
+
+char* icalgauge_as_sql(icalcomponent* gauge);
+
+void icalgauge_dump(icalcomponent* gauge);
+
+/* Return true is comp matches the gauge. The component must be in
+   cannonical form -- a VCALENDAR with one VEVENT, VTODO or VJOURNAL
+   sub component */
+int icalgauge_compare(icalgauge* g, icalcomponent* comp);
+
+/* Clone the component, but only return the properties specified in
+   the gauge */
+icalcomponent* icalgauge_new_clone(icalgauge* g, icalcomponent* comp);
+
+#endif /* ICALGAUGE_H*/
diff --git a/libical/src/libicalss/icalgaugeimpl.h b/libical/src/libicalss/icalgaugeimpl.h
new file mode 100644
index 0000000..73a2813
--- a/dev/null
+++ b/libical/src/libicalss/icalgaugeimpl.h
@@ -0,0 +1,63 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalgaugeimpl.h
+ CREATOR: eric 09 Aug 2000
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+======================================================================*/
+
+#include "ical.h"
+
+#include "pvl.h" 
+
+typedef enum icalgaugecompare {
+    ICALGAUGECOMPARE_EQUAL=ICAL_XLICCOMPARETYPE_EQUAL,
+    ICALGAUGECOMPARE_LESS=ICAL_XLICCOMPARETYPE_LESS,
+    ICALGAUGECOMPARE_LESSEQUAL=ICAL_XLICCOMPARETYPE_LESSEQUAL,
+    ICALGAUGECOMPARE_GREATER=ICAL_XLICCOMPARETYPE_GREATER,
+    ICALGAUGECOMPARE_GREATEREQUAL=ICAL_XLICCOMPARETYPE_GREATEREQUAL,
+    ICALGAUGECOMPARE_NOTEQUAL=ICAL_XLICCOMPARETYPE_NOTEQUAL,
+    ICALGAUGECOMPARE_REGEX=ICAL_XLICCOMPARETYPE_REGEX,
+    ICALGAUGECOMPARE_NONE=0
+} icalgaugecompare;
+
+typedef enum icalgaugelogic {
+    ICALGAUGELOGIC_NONE,
+    ICALGAUGELOGIC_AND,
+    ICALGAUGELOGIC_OR
+} icalgaugelogic;
+    
+
+struct icalgauge_where {
+        icalgaugelogic logic;
+        icalcomponent_kind comp;
+        icalproperty_kind prop;
+        icalgaugecompare compare;
+        char* value;
+};
+
+struct icalgauge_impl
+{
+
+        pvl_list select; /*Of icalgaugecompare, using only prop and comp fields*/
+        pvl_list from; /* List of component_kinds, as integers */
+        pvl_list where; /* List of icalgaugecompare */
+};
+
+
diff --git a/libical/src/libicalss/icalmessage.c b/libical/src/libicalss/icalmessage.c
new file mode 100644
index 0000000..d5c57c1
--- a/dev/null
+++ b/libical/src/libicalss/icalmessage.c
@@ -0,0 +1,373 @@
+/* -*- Mode: C -*-
+    ======================================================================
+    FILE: icalmessage.c
+    CREATOR: ebusboom 07 Nov 2000
+  
+    $Id$
+    $Locker$
+    
+    (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+    
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of either: 
+    
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+    
+    Or:
+    
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+
+    ======================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "icalmessage.h"
+#include "icalenums.h"
+#include <ctype.h>  /* for tolower()*/
+#include <string.h> /* for strstr */
+#include <stdlib.h> /* for free(), malloc() */
+icalcomponent* icalmessage_get_inner(icalcomponent* comp)
+{
+    if (icalcomponent_isa(comp) == ICAL_VCALENDAR_COMPONENT){
+        return icalcomponent_get_first_real_component(comp);
+    } else {
+        return comp;
+    }
+}
+
+char* lowercase(const char* str)
+{
+    char* p = 0;
+    char* n = icalmemory_strdup(str);
+
+    if(str ==0){
+        return 0;
+    }
+
+    for(p = n; *p!=0; p++){
+        *p = tolower(*p);
+    }
+
+    return n;
+}
+
+icalproperty* icalmessage_find_attendee(icalcomponent* comp, const char* user)
+{
+    icalcomponent *inner = icalmessage_get_inner(comp);
+    icalproperty *p,*attendee = 0;
+    char* luser = lowercase(user);
+
+    for(p = icalcomponent_get_first_property(inner, ICAL_ATTENDEE_PROPERTY);
+        p != 0;
+        p = icalcomponent_get_next_property(inner, ICAL_ATTENDEE_PROPERTY)
+        ){
+
+        char* lattendee;
+
+        lattendee = lowercase(icalproperty_get_attendee(p));
+
+        if (strstr(lattendee,user) != 0){
+            attendee = p;
+            break;
+        }
+
+        free(lattendee);
+
+    }
+    
+    free(luser);
+
+    return attendee;
+
+}
+
+void icalmessage_copy_properties(icalcomponent* to, icalcomponent* from, 
+                icalproperty_kind kind)
+{
+    icalcomponent *to_inner = icalmessage_get_inner(to);
+    icalcomponent *from_inner = icalmessage_get_inner(from);
+
+    if (to_inner == 0 && from_inner == 0){
+        icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+        return;
+    }
+
+    if(!icalcomponent_get_first_property(from_inner,kind)){
+        return;
+    }
+
+    icalcomponent_add_property(to_inner,
+               icalproperty_new_clone(
+                   icalcomponent_get_first_property(
+                       from_inner,
+                       kind)
+                   )
+        );
+}
+
+icalcomponent *icalmessage_new_reply_base(icalcomponent* c,
+                                            const char* user,
+                                            const char* msg)
+{
+    icalproperty *attendee;
+    char tmp[45];
+
+    icalcomponent *reply = icalcomponent_vanew(
+        ICAL_VCALENDAR_COMPONENT,
+        icalproperty_new_method(ICAL_METHOD_REPLY),
+        icalcomponent_vanew(
+            ICAL_VEVENT_COMPONENT,
+            icalproperty_new_dtstamp(icaltime_from_timet(time(0),0)),
+            0),
+        0);
+
+    icalcomponent *inner = icalmessage_get_inner(reply);
+
+    icalerror_check_arg_rz(c,"c");
+
+    icalmessage_copy_properties(reply,c,ICAL_UID_PROPERTY);
+    icalmessage_copy_properties(reply,c,ICAL_ORGANIZER_PROPERTY);
+    icalmessage_copy_properties(reply,c,ICAL_RECURRENCEID_PROPERTY);
+    icalmessage_copy_properties(reply,c,ICAL_SUMMARY_PROPERTY);
+    icalmessage_copy_properties(reply,c,ICAL_SEQUENCE_PROPERTY);
+
+    icalcomponent_set_dtstamp(reply,icaltime_from_timet(time(0),0));
+
+    if(msg != 0){
+        icalcomponent_add_property(inner,icalproperty_new_comment(msg));
+    }
+
+    /* Copy this user's attendee property */
+
+    attendee = icalmessage_find_attendee(c,user);
+
+    if (attendee == 0){
+        icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+        icalcomponent_free(reply);
+        return 0;
+    }
+
+    icalcomponent_add_property(inner,icalproperty_new_clone(attendee));
+
+    /* Add PRODID and VERSION */
+
+    icalcomponent_add_property(reply,icalproperty_new_version("2.0"));
+    
+    sprintf(tmp,
+           "-//SoftwareStudio//NONSGML %s %s //EN",PACKAGE,VERSION);
+    icalcomponent_add_property(reply,icalproperty_new_prodid(tmp));
+
+    return reply;
+
+}
+
+icalcomponent* icalmessage_new_accept_reply(icalcomponent* c,
+                                            const char* user,
+                                            const char* msg)
+{
+
+    icalcomponent *reply;
+    icalproperty *attendee;
+    icalcomponent *inner;
+
+    icalerror_check_arg_rz(c,"c");
+    
+    reply = icalmessage_new_reply_base(c,user,msg);
+
+    if(reply == 0){
+        return 0;
+    }
+
+    inner  = icalmessage_get_inner(reply);
+
+    attendee = icalcomponent_get_first_property(inner,
+                                                ICAL_ATTENDEE_PROPERTY);
+
+    icalproperty_set_parameter(attendee,
+               icalparameter_new_partstat(ICAL_PARTSTAT_ACCEPTED));
+
+    return reply;
+}
+
+icalcomponent* icalmessage_new_decline_reply(icalcomponent* c,
+                                            const char* user,
+                                            const char* msg)
+{
+    icalcomponent *reply;
+    icalproperty *attendee;
+    icalcomponent *inner;
+
+    icalerror_check_arg_rz(c,"c");
+    
+    reply = icalmessage_new_reply_base(c,user,msg);
+    inner = icalmessage_get_inner(reply);
+    if(reply == 0){
+        return 0;
+    }
+
+    attendee = icalcomponent_get_first_property(inner,
+                                                ICAL_ATTENDEE_PROPERTY);
+
+    icalproperty_set_parameter(attendee,
+               icalparameter_new_partstat(ICAL_PARTSTAT_DECLINED));
+
+    return reply;
+}
+
+/* New is modified version of old */
+icalcomponent* icalmessage_new_counterpropose_reply(icalcomponent* oldc,
+                                                    icalcomponent* newc,
+                                                    const char* user,
+                                                    const char* msg)
+{
+    icalcomponent *reply;
+
+    icalerror_check_arg_rz(oldc,"oldc");
+    icalerror_check_arg_rz(newc,"newc");
+    
+    reply = icalcomponent_new_clone(newc);
+
+    icalcomponent_set_method(reply,ICAL_METHOD_COUNTER);
+
+    return newc;
+
+}
+
+
+icalcomponent* icalmessage_new_delegate_reply(icalcomponent* c,
+                                              const char* user,
+                                              const char* delegatee,
+                                              const char* msg)
+{
+
+    icalcomponent *reply;
+    icalproperty *attendee;
+    icalcomponent *inner;
+
+    icalerror_check_arg_rz(c,"c");
+
+    reply =  icalmessage_new_reply_base(c,user,msg);
+    inner = icalmessage_get_inner(reply);
+    if(reply == 0){
+        return 0;
+    }
+
+    attendee = icalcomponent_get_first_property(inner,
+                                                ICAL_ATTENDEE_PROPERTY);
+
+    icalproperty_set_parameter(attendee,
+               icalparameter_new_partstat(ICAL_PARTSTAT_DELEGATED));
+
+    icalproperty_set_parameter(attendee,
+               icalparameter_new_delegatedto(delegatee));
+
+    return reply;
+
+}
+
+icalcomponent* icalmessage_new_delegate_request(icalcomponent* c,
+                                              const char* user,
+                                              const char* delegatee,
+                                              const char* msg)
+{
+
+    icalcomponent *reply;
+    icalproperty *attendee;
+    icalcomponent *inner;
+
+    icalerror_check_arg_rz(c,"c");
+
+    reply =  icalmessage_new_reply_base(c,user,msg);
+    inner = icalmessage_get_inner(reply);
+
+    if(reply == 0){
+        return 0;
+    }
+
+    icalcomponent_set_method(reply,ICAL_METHOD_REQUEST);
+
+    attendee = icalcomponent_get_first_property(inner,
+                                                ICAL_ATTENDEE_PROPERTY);
+
+    icalproperty_set_parameter(attendee,
+               icalparameter_new_partstat(ICAL_PARTSTAT_DELEGATED));
+
+    icalproperty_set_parameter(attendee,
+               icalparameter_new_delegatedto(delegatee));
+
+    icalcomponent_add_property(
+        inner,
+        icalproperty_vanew_attendee(
+            delegatee,
+            icalparameter_new_delegatedfrom(
+                icalproperty_get_attendee(attendee)
+                ),
+            0
+            )
+        );
+             
+
+    return reply;
+
+}
+
+
+icalcomponent* icalmessage_new_cancel_event(icalcomponent* c,
+                                            const char* user,
+                                            const char* msg);
+icalcomponent* icalmessage_new_cancel_instance(icalcomponent* c,
+                                            const char* user,
+                                            const char* msg);
+icalcomponent* icalmessage_new_cancel_all(icalcomponent* c,
+                                            const char* user,
+                                            const char* msg);
+
+
+
+icalcomponent* icalmessage_new_error_reply(icalcomponent* c,
+                                           const char* user,
+                                           const char* msg,
+                                           const char* debug,
+                                           icalrequeststatus code)
+{
+    icalcomponent *reply;
+    icalcomponent *inner, *cinner;
+    struct icalreqstattype rs;
+
+    icalerror_check_arg_rz(c,"c");
+    
+    reply = icalmessage_new_reply_base(c,user,msg);
+    inner = icalmessage_get_inner(reply);
+    cinner = icalmessage_get_inner(c);
+    if(reply == 0){
+        return 0;
+    }
+
+    if( code != ICAL_UNKNOWN_STATUS){
+        rs.code = code;
+        rs.debug = debug;
+        
+        icalcomponent_add_property(inner, 
+                                   icalproperty_new_requeststatus(rs));
+    } else { /*  code == ICAL_UNKNOWN_STATUS */ 
+
+        /* Copy all of the request status properties */
+        icalproperty *p;
+        for(p = icalcomponent_get_first_property(cinner,
+                                                 ICAL_REQUESTSTATUS_PROPERTY);
+            p != 0;
+            p = icalcomponent_get_next_property(cinner,
+                                                ICAL_REQUESTSTATUS_PROPERTY)){
+
+            
+            icalcomponent_add_property(inner,icalproperty_new_clone(p));
+        }
+    }
+
+    return reply;
+}
diff --git a/libical/src/libicalss/icalmessage.h b/libical/src/libicalss/icalmessage.h
new file mode 100644
index 0000000..24f1c9f
--- a/dev/null
+++ b/libical/src/libicalss/icalmessage.h
@@ -0,0 +1,71 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalmessage.h
+ CREATOR: eric 07 Nov 2000
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+
+ =========================================================================*/
+
+#include "ical.h"
+
+#ifndef ICALMESSAGE_H
+#define ICALMESSAGE_H
+
+
+icalcomponent* icalmessage_new_accept_reply(icalcomponent* c, 
+                                            const char* user,
+                                            const char* msg);
+
+icalcomponent* icalmessage_new_decline_reply(icalcomponent* c,
+                                            const char* user,
+                                            const char* msg);
+
+/* New is modified version of old */
+icalcomponent* icalmessage_new_counterpropose_reply(icalcomponent* oldc,
+                                                    icalcomponent* newc,
+                                                    const char* user,
+                                                    const char* msg);
+
+
+icalcomponent* icalmessage_new_delegate_reply(icalcomponent* c,
+                                              const char* user,
+                                              const char* delegatee,
+                                              const char* msg);
+
+
+icalcomponent* icalmessage_new_cancel_event(icalcomponent* c,
+                                            const char* user,
+                                            const char* msg);
+icalcomponent* icalmessage_new_cancel_instance(icalcomponent* c,
+                                            const char* user,
+                                            const char* msg);
+icalcomponent* icalmessage_new_cancel_all(icalcomponent* c,
+                                            const char* user,
+                                            const char* msg);
+
+
+icalcomponent* icalmessage_new_error_reply(icalcomponent* c,
+                                           const char* user,
+                                           const char* msg,
+                                           const char* debug,
+                                           icalrequeststatus rs);
+
+
+#endif /* ICALMESSAGE_H*/
diff --git a/libical/src/libicalss/icalset.c b/libical/src/libicalss/icalset.c
new file mode 100644
index 0000000..2120609
--- a/dev/null
+++ b/libical/src/libicalss/icalset.c
@@ -0,0 +1,367 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalset.c
+ CREATOR: eric 17 Jul 2000
+
+
+ Icalset is the "base class" for representations of a collection of
+ iCal components. Derived classes (actually delegates) include:
+ 
+    icalfileset   Store components in a single file
+    icaldirset    Store components in multiple files in a directory
+    icalheapset   Store components on the heap
+    icalmysqlset  Store components in a mysql database. 
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+======================================================================*/
+
+#include "ical.h"
+#include "icalset.h"
+#include "icalfileset.h"
+#include "icalfilesetimpl.h"
+#include "icaldirset.h"
+#include "icaldirsetimpl.h"
+#include <stdlib.h>
+/*#include "icalheapset.h"*/
+/*#include "icalmysqlset.h"*/
+
+#define ICALSET_ID "set "
+
+struct icalset_fp {
+        void (*free)(icalset* set);
+        const char* (*path)(icalset* set);
+        void (*mark)(icalset* set);
+        icalerrorenum (*commit)(icalset* set); 
+        icalerrorenum (*add_component)(icalset* set, icalcomponent* comp);
+        icalerrorenum (*remove_component)(icalset* set, icalcomponent* comp);
+        int (*count_components)(icalset* set,
+                             icalcomponent_kind kind);
+        icalerrorenum (*select)(icalset* set, icalcomponent* gauge);
+        void (*clear)(icalset* set);
+        icalcomponent* (*fetch)(icalset* set, const char* uid);
+        icalcomponent* (*fetch_match)(icalset* set, icalcomponent *comp);
+        int (*has_uid)(icalset* set, const char* uid);
+        icalerrorenum (*modify)(icalset* set, icalcomponent *old,
+                                     icalcomponent *new);
+                icalcomponent* (*get_current_component)(icalset* set);
+        icalcomponent* (*get_first_component)(icalset* set);
+        icalcomponent* (*get_next_component)(icalset* set);
+};
+
+struct icalset_fp icalset_dirset_fp = {
+    icaldirset_free,
+    icaldirset_path,
+    icaldirset_mark,
+    icaldirset_commit,
+    icaldirset_add_component,
+    icaldirset_remove_component,
+    icaldirset_count_components,
+    icaldirset_select,
+    icaldirset_clear,
+    icaldirset_fetch,
+    icaldirset_fetch_match,
+    icaldirset_has_uid,
+    icaldirset_modify,
+    icaldirset_get_current_component,
+    icaldirset_get_first_component,
+    icaldirset_get_next_component
+};
+
+
+struct icalset_fp icalset_fileset_fp = {
+    icalfileset_free,
+    icalfileset_path,
+    icalfileset_mark,
+    icalfileset_commit,
+    icalfileset_add_component,
+    icalfileset_remove_component,
+    icalfileset_count_components,
+    icalfileset_select,
+    icalfileset_clear,
+    icalfileset_fetch,
+    icalfileset_fetch_match,
+    icalfileset_has_uid,
+    icalfileset_modify,
+    icalfileset_get_current_component,
+    icalfileset_get_first_component,
+    icalfileset_get_next_component
+};
+
+struct icalset_impl {
+
+        char id[5]; /* "set " */
+
+        void *derived_impl;
+        struct icalset_fp *fp;
+};
+
+/* Figure out what was actually passed in as the set. This could be a
+   set or and of the derived types such as dirset or fileset. Note
+   this routine returns a value, not a reference, to avoid memory
+   leaks in the methods */
+struct icalset_impl icalset_get_impl(icalset* set)
+{
+    struct icalset_impl  impl;
+
+    memset(&impl,0,sizeof(impl));
+    icalerror_check_arg_re( (set!=0),"set",impl);
+
+    if(strcmp((char*)set,ICALSET_ID)==0) {
+        /* It is actually a set, so just sent the reference back out. */
+        return *(struct icalset_impl*)set;
+    } else if(strcmp((char*)set,ICALFILESET_ID)==0) {
+        /* Make a new set from the fileset */
+        impl.fp = &icalset_fileset_fp;
+        impl.derived_impl = set;
+        strcpy(impl.id,ICALFILESET_ID);/* HACK. Is this necessary? */
+        return impl;
+    } else if(strcmp((char*)set,ICALDIRSET_ID)==0) {
+        /* Make a new set from the dirset */
+        impl.fp = &icalset_dirset_fp;
+        impl.derived_impl = set;
+        strcpy(impl.id,ICALDIRSET_ID);/* HACK. Is this necessary? */
+        return impl;
+    } else {
+        /* The type of set is unknown, so throw an error */
+        icalerror_assert((0),"Unknown set type");
+        return impl;
+    }
+}
+
+
+struct icalset_impl* icalset_new_impl()
+{
+    
+    struct icalset_impl* impl;
+
+    if ( ( impl = (struct icalset_impl*)
+           malloc(sizeof(struct icalset_impl))) == 0) {
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        return 0;
+    }
+
+    strcpy(impl->id,ICALSET_ID);
+
+    impl->derived_impl = 0;
+    impl->fp = 0;
+
+    return impl;
+}
+
+struct icalset_impl* icalset_new_file_from_ref(icalfileset *fset)
+{
+    struct icalset_impl *impl = icalset_new_impl();
+
+    icalerror_check_arg_rz( (fset!=0),"fset");
+
+    if(impl == 0){
+        free(impl);
+        return 0;
+    }
+
+    impl->derived_impl = fset;
+
+    if (impl->derived_impl == 0){
+        free(impl);
+        return 0;
+    }
+
+    impl->fp = &icalset_fileset_fp;
+
+    return (struct icalset_impl*)impl;
+}
+
+icalset* icalset_new_file(const char* path)
+{
+    icalfileset *fset = icalfileset_new(path);
+
+    if(fset == 0){
+        return 0;
+    }
+
+    return (icalset*)icalset_new_file_from_ref(fset);
+}
+
+icalset* icalset_new_dir_from_ref(icaldirset *dset)
+{
+
+    struct icalset_impl *impl = icalset_new_impl();
+
+    icalerror_check_arg_rz( (dset!=0),"dset");
+
+    if(impl == 0){
+        return 0;
+    }
+
+    impl->derived_impl = dset;
+
+    if (impl->derived_impl == 0){
+        free(impl);
+        return 0;
+    }
+
+    impl->fp = &icalset_dirset_fp;
+
+    return impl;
+}
+
+icalset* icalset_new_dir(const char* path)
+{
+    icaldirset *dset = icaldirset_new(path);
+
+    if(dset == 0){
+        return 0;
+    }
+
+    return icalset_new_dir_from_ref(dset);
+}
+
+icalset* icalset_new_heap(void)
+{
+    struct icalset_impl *impl = icalset_new_impl();
+
+
+    if(impl == 0){
+        free(impl);
+        return 0;
+    }
+
+    return 0;
+}
+
+icalset* icalset_new_mysql(const char* path)
+{
+    struct icalset_impl *impl = icalset_new_impl();
+
+    if(impl == 0){
+        free(impl);
+        return 0;
+    }
+
+    return 0;
+}
+
+void icalset_free(icalset* set)
+{
+    struct icalset_impl impl = icalset_get_impl(set);
+    (*(impl.fp->free))(impl.derived_impl);
+
+   if(strcmp((char*)set,ICALSET_ID)) {    
+       free(set);
+   }
+}
+
+const char* icalset_path(icalset* set)
+{
+    struct icalset_impl impl = icalset_get_impl(set);
+    return (*(impl.fp->path))(impl.derived_impl);
+}
+
+void icalset_mark(icalset* set)
+{
+    struct icalset_impl impl = icalset_get_impl(set);
+    (*(impl.fp->mark))(impl.derived_impl);
+}
+
+icalerrorenum icalset_commit(icalset* set)
+{
+    struct icalset_impl impl = icalset_get_impl(set);
+    return (*(impl.fp->commit))(impl.derived_impl);
+}
+
+icalerrorenum icalset_add_component(icalset* set, icalcomponent* comp)
+{
+    struct icalset_impl impl = icalset_get_impl(set);
+    return (*(impl.fp->add_component))(impl.derived_impl,comp);
+}
+
+icalerrorenum icalset_remove_component(icalset* set, icalcomponent* comp)
+{
+    struct icalset_impl impl = icalset_get_impl(set);
+    return (*(impl.fp->remove_component))(impl.derived_impl,comp);
+}
+
+int icalset_count_components(icalset* set,icalcomponent_kind kind)
+{
+    struct icalset_impl impl = icalset_get_impl(set);
+    return (*(impl.fp->count_components))(impl.derived_impl,kind);
+}
+
+icalerrorenum icalset_select(icalset* set, icalcomponent* gauge)
+{
+    struct icalset_impl impl = icalset_get_impl(set);
+    return (*(impl.fp->select))(impl.derived_impl,gauge);
+}
+
+void icalset_clear(icalset* set)
+{
+    struct icalset_impl impl = icalset_get_impl(set);
+    (*(impl.fp->clear))(impl.derived_impl);
+}
+
+icalcomponent* icalset_fetch(icalset* set, const char* uid)
+{
+    struct icalset_impl impl = icalset_get_impl(set);
+    return (*(impl.fp->fetch))(impl.derived_impl,uid);
+}
+
+icalcomponent* icalset_fetch_match(icalset* set, icalcomponent *comp)
+{
+    struct icalset_impl impl = icalset_get_impl(set);
+    return (*(impl.fp->fetch_match))(impl.derived_impl,comp);
+}
+
+
+int icalset_has_uid(icalset* set, const char* uid)
+{
+    struct icalset_impl impl = icalset_get_impl(set);
+    return (*(impl.fp->has_uid))(impl.derived_impl,uid);
+}
+
+icalerrorenum icalset_modify(icalset* set, icalcomponent *old,
+                               icalcomponent *new)
+{
+    struct icalset_impl impl = icalset_get_impl(set);
+    return (*(impl.fp->modify))(impl.derived_impl,old,new);
+}
+
+icalcomponent* icalset_get_current_component(icalset* set)
+{
+    struct icalset_impl impl = icalset_get_impl(set);
+    return (*(impl.fp->get_current_component))(impl.derived_impl);
+}
+
+icalcomponent* icalset_get_first_component(icalset* set)
+{
+    struct icalset_impl impl = icalset_get_impl(set);
+    return (*(impl.fp->get_first_component))(impl.derived_impl);
+}
+
+icalcomponent* icalset_get_next_component(icalset* set)
+{
+    struct icalset_impl impl = icalset_get_impl(set);
+    return (*(impl.fp->get_next_component))(impl.derived_impl);
+}
+
+
+
+
diff --git a/libical/src/libicalss/icalset.h b/libical/src/libicalss/icalset.h
new file mode 100644
index 0000000..7b083da
--- a/dev/null
+++ b/libical/src/libicalss/icalset.h
@@ -0,0 +1,111 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalset.h
+ CREATOR: eric 28 November 1999
+
+
+ Icalset is the "base class" for representations of a collection of
+ iCal components. Derived classes (actually delegatees) include:
+ 
+    icalfileset   Store componetns in a single file
+    icaldirset    Store components in multiple files in a directory
+    icalheapset   Store components on the heap
+    icalmysqlset  Store components in a mysql database. 
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+======================================================================*/
+
+#ifndef ICALSET_H
+#define ICALSET_H
+
+#include <limits.h> /* For PATH_MAX */
+#include "ical.h"
+#include "icalerror.h"
+
+#ifdef PATH_MAX
+#define ICAL_PATH_MAX PATH_MAX
+#else
+#define ICAL_PATH_MAX 1024
+#endif
+
+
+
+
+typedef void icalset;
+
+typedef enum icalset_kind {
+    ICAL_FILE_SET,
+    ICAL_DIR_SET,
+    ICAL_HEAP_SET,
+    ICAL_MYSQL_SET,
+    ICAL_CAP_SET
+} icalset_kind;
+
+
+/* Create a specific derived type of set */
+icalset* icalset_new_file(const char* path);
+icalset* icalset_new_dir(const char* path);
+icalset* icalset_new_heap(void);
+icalset* icalset_new_mysql(const char* path);
+/*icalset* icalset_new_cap(icalcstp* cstp);*/
+
+void icalset_free(icalset* set);
+
+const char* icalset_path(icalset* set);
+
+/* Mark the cluster as changed, so it will be written to disk when it
+   is freed. Commit writes to disk immediately*/
+void icalset_mark(icalset* set);
+icalerrorenum icalset_commit(icalset* set); 
+
+icalerrorenum icalset_add_component(icalset* set, icalcomponent* comp);
+icalerrorenum icalset_remove_component(icalset* set, icalcomponent* comp);
+
+int icalset_count_components(icalset* set,
+                             icalcomponent_kind kind);
+
+/* Restrict the component returned by icalset_first, _next to those
+   that pass the gauge. _clear removes the gauge. */
+icalerrorenum icalset_select(icalset* set, icalcomponent* gauge);
+void icalset_clear_select(icalset* set);
+
+/* Get a component by uid */
+icalcomponent* icalset_fetch(icalset* set, const char* uid);
+int icalset_has_uid(icalset* set, const char* uid);
+icalcomponent* icalset_fetch_match(icalset* set, icalcomponent *c);
+
+/* Modify components according to the MODIFY method of CAP. Works on
+   the currently selected components. */
+icalerrorenum icalset_modify(icalset* set, icalcomponent *oldc,
+                               icalcomponent *newc);
+
+/* Iterate through the components. If a guage has been defined, these
+   will skip over components that do not pass the gauge */
+
+icalcomponent* icalset_get_current_component(icalset* set);
+icalcomponent* icalset_get_first_component(icalset* set);
+icalcomponent* icalset_get_next_component(icalset* set);
+
+#endif /* !ICALSET_H */
+
+
+
diff --git a/libical/src/libicalss/icalspanlist.c b/libical/src/libicalss/icalspanlist.c
new file mode 100644
index 0000000..cab6a81
--- a/dev/null
+++ b/libical/src/libicalss/icalspanlist.c
@@ -0,0 +1,309 @@
+/* -*- Mode: C -*-
+    ======================================================================
+    FILE: icalspanlist.c
+    CREATOR: ebusboom 23 aug 2000
+  
+    $Id$
+    $Locker$
+    
+    (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+    
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of either: 
+    
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+    
+    Or:
+    
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+
+    ======================================================================*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "ical.h"
+#include "icalspanlist.h"
+#include "pvl.h" 
+#include <stdlib.h> /* for free and malloc */
+
+struct icalspanlist_impl {
+        pvl_list spans;
+};
+
+int compare_span(void* a, void* b)
+{
+    struct icaltime_span *span_a = (struct icaltime_span *)a ;
+    struct icaltime_span *span_b = (struct icaltime_span *)b ;
+    
+    if(span_a->start == span_b->start){
+        return 0;
+    } else if(span_a->start < span_b->start){
+        return -1;
+    }  else { /*if(span_a->start > span->b.start)*/
+        return 1;
+    }
+}
+
+icalcomponent* icalspanlist_get_inner(icalcomponent* comp)
+{
+    if (icalcomponent_isa(comp) == ICAL_VCALENDAR_COMPONENT){
+        return icalcomponent_get_first_real_component(comp);
+    } else {
+        return comp;
+    }
+}
+
+
+void print_span(int c, struct icaltime_span span );
+
+    
+/* Make a free list from a set of component */
+icalspanlist* icalspanlist_new(icalset *set, 
+                               struct icaltimetype start,
+                               struct icaltimetype end)
+{
+    struct icaltime_span range;
+    pvl_elem itr;
+    icalcomponent *c,*inner;
+    icalcomponent_kind kind, inner_kind;
+    struct icalspanlist_impl *sl; 
+    struct icaltime_span *freetime;
+
+    if ( ( sl = (struct icalspanlist_impl*)
+           malloc(sizeof(struct icalspanlist_impl))) == 0) {
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        return 0;
+    }
+
+    sl->spans =  pvl_newlist();
+
+    range.start = icaltime_as_timet(start);
+    range.end = icaltime_as_timet(end);
+
+    printf("Range start: %s",ctime(&range.start));
+    printf("Range end  : %s",ctime(&range.end));
+
+
+    /* Get a list of spans of busy time from the events in the set
+       and order the spans based on the start time */
+
+   for(c = icalset_get_first_component(set);
+        c != 0;
+        c = icalset_get_next_component(set)){
+
+       struct icaltime_span span;
+
+       kind  = icalcomponent_isa(c);
+       inner = icalcomponent_get_inner(c);
+
+       if(!inner){
+           continue;
+       }
+
+       inner_kind = icalcomponent_isa(inner);
+
+       if( kind != ICAL_VEVENT_COMPONENT &&
+           inner_kind != ICAL_VEVENT_COMPONENT){
+           continue;
+       }
+       
+       icalerror_clear_errno();
+
+        span = icalcomponent_get_span(c);
+        span.is_busy = 1;
+
+        if(icalerrno != ICAL_NO_ERROR){
+            continue;
+        }
+
+        if ((range.start < span.end && icaltime_is_null_time(end)) ||
+            (range.start < span.end && range.end > span.start )){
+            
+            struct icaltime_span *s;
+
+            if ((s=(struct icaltime_span *)
+                 malloc(sizeof(struct icaltime_span))) == 0){
+                icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+                return 0;
+            }
+
+            memcpy(s,&span,sizeof(span));
+                
+            pvl_insert_ordered(sl->spans,compare_span,(void*)s);
+
+        }
+    }
+    
+    /* Now Fill in the free time spans. loop through the spans. if the
+       start of the range is not within the span, create a free entry
+       that runs from the start of the range to the start of the
+       span. */
+
+     for( itr = pvl_head(sl->spans);
+         itr != 0;
+         itr = pvl_next(itr))
+    {
+        struct icaltime_span *s = (icalproperty*)pvl_data(itr);
+
+        if ((freetime=(struct icaltime_span *)
+             malloc(sizeof(struct icaltime_span))) == 0){
+            icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+            return 0;
+            }
+
+        if(range.start < s->start){
+            freetime->start = range.start; 
+            freetime->end = s->start;
+            
+            freetime->is_busy = 0;
+
+
+            pvl_insert_ordered(sl->spans,compare_span,(void*)freetime);
+        } else {
+            free(freetime);
+        }
+        
+        range.start = s->end;
+    }
+     
+     /* If the end of the range is null, then assume that everything
+        after the last item in the calendar is open and add a span
+        that indicates this */
+
+     if( icaltime_is_null_time(end)){
+         struct icaltime_span* last_span;
+
+         last_span = pvl_data(pvl_tail(sl->spans));
+
+         if (last_span != 0){
+
+             if ((freetime=(struct icaltime_span *)
+                  malloc(sizeof(struct icaltime_span))) == 0){
+                 icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+                 return 0;
+                     }
+        
+             freetime->is_busy = 0;
+             freetime->start = last_span->end;
+             freetime->end = freetime->start;
+             pvl_insert_ordered(sl->spans,compare_span,(void*)freetime);
+         }
+     }
+
+
+     return sl;
+
+}
+
+void icalspanlist_free(icalspanlist* s)
+{
+    struct icaltime_span *span;
+    struct icalspanlist_impl* impl = (struct icalspanlist_impl*)s;
+    
+    while( (span=pvl_pop(impl->spans)) != 0){
+        free(span);
+    }
+    
+    pvl_free(impl->spans);
+    
+    impl->spans = 0;
+}
+
+
+void icalspanlist_dump(icalspanlist* s){
+
+     int i = 0;
+     struct icalspanlist_impl* sl = (struct icalspanlist_impl*)s;
+     pvl_elem itr;
+
+     for( itr = pvl_head(sl->spans);
+         itr != 0;
+         itr = pvl_next(itr))
+    {
+        struct icaltime_span *s = (icalproperty*)pvl_data(itr);
+        
+        printf("#%02d %d start: %s",++i,s->is_busy,ctime(&s->start));
+        printf("      end  : %s",ctime(&s->end));
+
+    }
+}
+
+icalcomponent* icalspanlist_make_free_list(icalspanlist* sl);
+icalcomponent* icalspanlist_make_busy_list(icalspanlist* sl);
+
+struct icalperiodtype icalspanlist_next_free_time(icalspanlist* sl,
+                                                struct icaltimetype t)
+{
+     struct icalspanlist_impl* impl = (struct icalspanlist_impl*)sl;
+     pvl_elem itr;
+     struct icalperiodtype period;
+     struct icaltime_span *s;
+
+     time_t rangett= icaltime_as_timet(t);
+
+     period.start = icaltime_null_time();
+     period.end = icaltime_null_time();
+
+     /* Is the reference time before the first span? If so, assume
+        that the reference time is free */
+     itr = pvl_head(impl->spans);
+     s = (icalproperty*)pvl_data(itr);
+
+     if (s == 0){
+         /* No elements in span */
+         return period;
+     }
+
+     if(rangett <s->start ){
+         /* End of period is start of first span if span is busy, end
+            of the span if it is free */
+         period.start =  t;
+
+         if (s->is_busy == 0){
+             period.end =  icaltime_from_timet(s->start,0);
+         } else {
+             period.end =  icaltime_from_timet(s->end,0);
+         }
+
+         return period;
+     }
+
+     /* Otherwise, find the first free span that contains the
+        reference time. */
+
+     for( itr = pvl_head(impl->spans);
+         itr != 0;
+         itr = pvl_next(itr))
+    {
+        s = (icalproperty*)pvl_data(itr);
+
+        if(s->is_busy == 0 && s->start >= rangett && 
+            ( rangett < s->end || s->end == s->start)){
+
+            if (rangett < s->start){
+                period.start = icaltime_from_timet(s->start,0);
+            } else {
+                period.start = icaltime_from_timet(rangett,0);
+            }
+            
+            period.end = icaltime_from_timet(s->end,0);
+
+            return period;
+        }
+                        
+    }
+
+     period.start = icaltime_null_time();
+     period.end = icaltime_null_time();
+
+     return period;
+}
+
+struct icalperiodtype icalspanlist_next_busy_time(icalspanlist* sl,
+                                                struct icaltimetype t);
+
diff --git a/libical/src/libicalss/icalspanlist.h b/libical/src/libicalss/icalspanlist.h
new file mode 100644
index 0000000..83cb1c8
--- a/dev/null
+++ b/libical/src/libicalss/icalspanlist.h
@@ -0,0 +1,54 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalspanlist.h
+ CREATOR: eric 21 Aug 2000
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+
+ =========================================================================*/
+#ifndef ICALSPANLIST_H
+#define ICALSPANLIST_H
+
+#include "ical.h"
+#include "icalset.h"
+
+typedef void icalspanlist;
+
+/* Make a free list from a set of component. Start and end should be in UTC */
+icalspanlist* icalspanlist_new(icalset *set, 
+                                struct icaltimetype start,
+                                struct icaltimetype end);
+
+void icalspanlist_free(icalspanlist* spl);
+
+icalcomponent* icalspanlist_make_free_list(icalspanlist* sl);
+icalcomponent* icalspanlist_make_busy_list(icalspanlist* sl);
+
+/* Get first free or busy time after time t. all times are in UTC */
+struct icalperiodtype icalspanlist_next_free_time(icalspanlist* sl,
+                                                struct icaltimetype t);
+struct icalperiodtype icalspanlist_next_busy_time(icalspanlist* sl,
+                                                struct icaltimetype t);
+
+void icalspanlist_dump(icalspanlist* s);
+
+#endif
+                                    
+
+
diff --git a/libical/src/libicalss/icalss.h b/libical/src/libicalss/icalss.h
new file mode 100644
index 0000000..cd07919
--- a/dev/null
+++ b/libical/src/libicalss/icalss.h
@@ -0,0 +1,885 @@
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalgauge.h
+ CREATOR: eric 23 December 1999
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+======================================================================*/
+
+#ifndef ICALGAUGE_H
+#define ICALGAUGE_H
+
+typedef void icalgauge;
+
+icalgauge* icalgauge_new_from_sql(char* sql);
+
+void icalgauge_free(icalgauge* gauge);
+
+char* icalgauge_as_sql(icalcomponent* gauge);
+
+void icalgauge_dump(icalcomponent* gauge);
+
+/* Return true is comp matches the gauge. The component must be in
+   cannonical form -- a VCALENDAR with one VEVENT, VTODO or VJOURNAL
+   sub component */
+int icalgauge_compare(icalgauge* g, icalcomponent* comp);
+
+/* Clone the component, but only return the properties specified in
+   the gauge */
+icalcomponent* icalgauge_new_clone(icalgauge* g, icalcomponent* comp);
+
+#endif /* ICALGAUGE_H*/
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalset.h
+ CREATOR: eric 28 November 1999
+
+
+ Icalset is the "base class" for representations of a collection of
+ iCal components. Derived classes (actually delegatees) include:
+ 
+    icalfileset   Store componetns in a single file
+    icaldirset    Store components in multiple files in a directory
+    icalheapset   Store components on the heap
+    icalmysqlset  Store components in a mysql database. 
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+======================================================================*/
+
+#ifndef ICALSET_H
+#define ICALSET_H
+
+#include <limits.h> /* For PATH_MAX */
+
+#ifdef PATH_MAX
+#define ICAL_PATH_MAX PATH_MAX
+#else
+#define ICAL_PATH_MAX 1024
+#endif
+
+
+#ifdef _WIN32
+#define mode_t int
+#endif
+
+
+
+typedef void icalset;
+
+typedef enum icalset_kind {
+    ICAL_FILE_SET,
+    ICAL_DIR_SET,
+    ICAL_HEAP_SET,
+    ICAL_MYSQL_SET,
+    ICAL_CAP_SET
+} icalset_kind;
+
+
+/* Create a specific derived type of set */
+icalset* icalset_new_file(const char* path);
+icalset* icalset_new_dir(const char* path);
+icalset* icalset_new_heap(void);
+icalset* icalset_new_mysql(const char* path);
+/*icalset* icalset_new_cap(icalcstp* cstp);*/
+
+void icalset_free(icalset* set);
+
+const char* icalset_path(icalset* set);
+
+/* Mark the cluster as changed, so it will be written to disk when it
+   is freed. Commit writes to disk immediately*/
+void icalset_mark(icalset* set);
+icalerrorenum icalset_commit(icalset* set); 
+
+icalerrorenum icalset_add_component(icalset* set, icalcomponent* comp);
+icalerrorenum icalset_remove_component(icalset* set, icalcomponent* comp);
+
+int icalset_count_components(icalset* set,
+                             icalcomponent_kind kind);
+
+/* Restrict the component returned by icalset_first, _next to those
+   that pass the gauge. _clear removes the gauge. */
+icalerrorenum icalset_select(icalset* set, icalcomponent* gauge);
+void icalset_clear_select(icalset* set);
+
+/* Get a component by uid */
+icalcomponent* icalset_fetch(icalset* set, const char* uid);
+int icalset_has_uid(icalset* set, const char* uid);
+icalcomponent* icalset_fetch_match(icalset* set, icalcomponent *c);
+
+/* Modify components according to the MODIFY method of CAP. Works on
+   the currently selected components. */
+icalerrorenum icalset_modify(icalset* set, icalcomponent *oldc,
+                               icalcomponent *newc);
+
+/* Iterate through the components. If a guage has been defined, these
+   will skip over components that do not pass the gauge */
+
+icalcomponent* icalset_get_current_component(icalset* set);
+icalcomponent* icalset_get_first_component(icalset* set);
+icalcomponent* icalset_get_next_component(icalset* set);
+
+#endif /* !ICALSET_H */
+
+
+
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalfileset.h
+ CREATOR: eric 23 December 1999
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+======================================================================*/
+
+#ifndef ICALFILESET_H
+#define ICALFILESET_H
+
+#include <sys/types.h> /* For open() flags and mode */
+#include <sys/stat.h> /* For open() flags and mode */
+#include <fcntl.h> /* For open() flags and mode */
+
+extern int icalfileset_safe_saves;
+
+typedef void icalfileset;
+
+
+/* icalfileset
+   icalfilesetfile
+   icalfilesetdir
+*/
+
+
+icalfileset* icalfileset_new(const char* path);
+
+/* Like _new, but takes open() flags for opening the file */
+icalfileset* icalfileset_new_open(const char* path, 
+                                  int flags, mode_t mode);
+
+void icalfileset_free(icalfileset* cluster);
+
+const char* icalfileset_path(icalfileset* cluster);
+
+/* Mark the cluster as changed, so it will be written to disk when it
+   is freed. Commit writes to disk immediately. */
+void icalfileset_mark(icalfileset* cluster);
+icalerrorenum icalfileset_commit(icalfileset* cluster); 
+
+icalerrorenum icalfileset_add_component(icalfileset* cluster,
+                                        icalcomponent* child);
+
+icalerrorenum icalfileset_remove_component(icalfileset* cluster,
+                                           icalcomponent* child);
+
+int icalfileset_count_components(icalfileset* cluster,
+                                 icalcomponent_kind kind);
+
+/* Restrict the component returned by icalfileset_first, _next to those
+   that pass the gauge. _clear removes the gauge */
+icalerrorenum icalfileset_select(icalfileset* store, icalgauge* gauge);
+void icalfileset_clear(icalfileset* store);
+
+/* Get and search for a component by uid */
+icalcomponent* icalfileset_fetch(icalfileset* cluster, const char* uid);
+int icalfileset_has_uid(icalfileset* cluster, const char* uid);
+icalcomponent* icalfileset_fetch_match(icalfileset* set, icalcomponent *c);
+
+
+/* Modify components according to the MODIFY method of CAP. Works on
+   the currently selected components. */
+icalerrorenum icalfileset_modify(icalfileset* store, icalcomponent *oldcomp,
+                               icalcomponent *newcomp);
+
+/* Iterate through components. If a guage has been defined, these
+   will skip over components that do not pass the gauge */
+
+icalcomponent* icalfileset_get_current_component (icalfileset* cluster);
+icalcomponent* icalfileset_get_first_component(icalfileset* cluster);
+icalcomponent* icalfileset_get_next_component(icalfileset* cluster);
+/* Return a reference to the internal component. You probably should
+   not be using this. */
+
+icalcomponent* icalfileset_get_component(icalfileset* cluster);
+
+
+#endif /* !ICALFILESET_H */
+
+
+
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icaldirset.h
+ CREATOR: eric 28 November 1999
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+======================================================================*/
+
+#ifndef ICALDIRSET_H
+#define ICALDIRSET_H
+
+
+/* icaldirset Routines for storing, fetching, and searching for ical
+ * objects in a database */
+
+typedef void icaldirset;
+
+
+icaldirset* icaldirset_new(const char* path);
+
+void icaldirset_free(icaldirset* store);
+
+const char* icaldirset_path(icaldirset* store);
+
+/* Mark the cluster as changed, so it will be written to disk when it
+   is freed. Commit writes to disk immediately*/
+void icaldirset_mark(icaldirset* store);
+icalerrorenum icaldirset_commit(icaldirset* store); 
+
+icalerrorenum icaldirset_add_component(icaldirset* store, icalcomponent* comp);
+icalerrorenum icaldirset_remove_component(icaldirset* store, icalcomponent* comp);
+
+int icaldirset_count_components(icaldirset* store,
+                               icalcomponent_kind kind);
+
+/* Restrict the component returned by icaldirset_first, _next to those
+   that pass the gauge. _clear removes the gauge. */
+icalerrorenum icaldirset_select(icaldirset* store, icalcomponent* gauge);
+void icaldirset_clear(icaldirset* store);
+
+/* Get a component by uid */
+icalcomponent* icaldirset_fetch(icaldirset* store, const char* uid);
+int icaldirset_has_uid(icaldirset* store, const char* uid);
+icalcomponent* icaldirset_fetch_match(icaldirset* set, icalcomponent *c);
+
+/* Modify components according to the MODIFY method of CAP. Works on
+   the currently selected components. */
+icalerrorenum icaldirset_modify(icaldirset* store, icalcomponent *oldc,
+                               icalcomponent *newc);
+
+/* Iterate through the components. If a guage has been defined, these
+   will skip over components that do not pass the gauge */
+
+icalcomponent* icaldirset_get_current_component(icaldirset* store);
+icalcomponent* icaldirset_get_first_component(icaldirset* store);
+icalcomponent* icaldirset_get_next_component(icaldirset* store);
+
+#endif /* !ICALDIRSET_H */
+
+
+
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalcalendar.h
+ CREATOR: eric 23 December 1999
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+
+======================================================================*/
+
+#ifndef ICALCALENDAR_H
+#define ICALCALENDAR_H
+
+
+/* icalcalendar
+ * Routines for storing calendar data in a file system. The calendar 
+ * has two icaldirsets, one for incoming components and one for booked
+ * components. It also has interfaces to access the free/busy list
+ * and a list of calendar properties */
+
+typedef  void icalcalendar;
+
+icalcalendar* icalcalendar_new(char* dir);
+
+void icalcalendar_free(icalcalendar* calendar);
+
+int icalcalendar_lock(icalcalendar* calendar);
+
+int icalcalendar_unlock(icalcalendar* calendar);
+
+int icalcalendar_islocked(icalcalendar* calendar);
+
+int icalcalendar_ownlock(icalcalendar* calendar);
+
+icalset* icalcalendar_get_booked(icalcalendar* calendar);
+
+icalset* icalcalendar_get_incoming(icalcalendar* calendar);
+
+icalset* icalcalendar_get_properties(icalcalendar* calendar);
+
+icalset* icalcalendar_get_freebusy(icalcalendar* calendar);
+
+
+#endif /* !ICALCALENDAR_H */
+
+
+
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalclassify.h
+ CREATOR: eric 21 Aug 2000
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+
+ =========================================================================*/
+
+#ifndef ICALCLASSIFY_H
+#define ICALCLASSIFY_H
+
+
+
+typedef enum icalclass {
+    ICAL_NO_CLASS,
+    ICAL_PUBLISH_NEW_CLASS,
+    ICAL_PUBLISH_UPDATE_CLASS,
+    ICAL_PUBLISH_FREEBUSY_CLASS,
+    ICAL_REQUEST_NEW_CLASS,
+    ICAL_REQUEST_UPDATE_CLASS,
+    ICAL_REQUEST_RESCHEDULE_CLASS,
+    ICAL_REQUEST_DELEGATE_CLASS,
+    ICAL_REQUEST_NEW_ORGANIZER_CLASS,
+    ICAL_REQUEST_FORWARD_CLASS,
+    ICAL_REQUEST_STATUS_CLASS,
+    ICAL_REQUEST_FREEBUSY_CLASS,
+    ICAL_REPLY_ACCEPT_CLASS,
+    ICAL_REPLY_DECLINE_CLASS,
+    ICAL_REPLY_DELEGATE_CLASS,
+    ICAL_REPLY_CRASHER_ACCEPT_CLASS,
+    ICAL_REPLY_CRASHER_DECLINE_CLASS,
+    ICAL_ADD_INSTANCE_CLASS,
+    ICAL_CANCEL_EVENT_CLASS,
+    ICAL_CANCEL_INSTANCE_CLASS,
+    ICAL_CANCEL_ALL_CLASS,
+    ICAL_REFRESH_CLASS,
+    ICAL_COUNTER_CLASS,
+    ICAL_DECLINECOUNTER_CLASS,
+    ICAL_MALFORMED_CLASS, 
+    ICAL_OBSOLETE_CLASS, /* 21 */
+    ICAL_MISSEQUENCED_CLASS, /* 22 */
+    ICAL_UNKNOWN_CLASS /* 23 */
+} ical_class;
+
+ical_class icalclassify(icalcomponent* c,icalcomponent* match, 
+                              const char* user);
+
+icalcomponent* icalclassify_find_overlaps(icalset* set, icalcomponent* comp);
+
+char* icalclassify_class_to_string(ical_class iclass);
+
+
+#endif /* ICALCLASSIFY_H*/
+
+
+                                    
+
+
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalspanlist.h
+ CREATOR: eric 21 Aug 2000
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+
+ =========================================================================*/
+#ifndef ICALSPANLIST_H
+#define ICALSPANLIST_H
+
+
+typedef void icalspanlist;
+
+/* Make a free list from a set of component. Start and end should be in UTC */
+icalspanlist* icalspanlist_new(icalset *set, 
+                                struct icaltimetype start,
+                                struct icaltimetype end);
+
+void icalspanlist_free(icalspanlist* spl);
+
+icalcomponent* icalspanlist_make_free_list(icalspanlist* sl);
+icalcomponent* icalspanlist_make_busy_list(icalspanlist* sl);
+
+/* Get first free or busy time after time t. all times are in UTC */
+struct icalperiodtype icalspanlist_next_free_time(icalspanlist* sl,
+                                                struct icaltimetype t);
+struct icalperiodtype icalspanlist_next_busy_time(icalspanlist* sl,
+                                                struct icaltimetype t);
+
+void icalspanlist_dump(icalspanlist* s);
+
+#endif
+                                    
+
+
+/* -*- Mode: C -*- */
+/*======================================================================
+ FILE: icalmessage.h
+ CREATOR: eric 07 Nov 2000
+
+
+ $Id$
+ $Locker$
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+
+ =========================================================================*/
+
+
+#ifndef ICALMESSAGE_H
+#define ICALMESSAGE_H
+
+
+icalcomponent* icalmessage_new_accept_reply(icalcomponent* c, 
+                                            const char* user,
+                                            const char* msg);
+
+icalcomponent* icalmessage_new_decline_reply(icalcomponent* c,
+                                            const char* user,
+                                            const char* msg);
+
+/* New is modified version of old */
+icalcomponent* icalmessage_new_counterpropose_reply(icalcomponent* oldc,
+                                                    icalcomponent* newc,
+                                                    const char* user,
+                                                    const char* msg);
+
+
+icalcomponent* icalmessage_new_delegate_reply(icalcomponent* c,
+                                              const char* user,
+                                              const char* delegatee,
+                                              const char* msg);
+
+
+icalcomponent* icalmessage_new_cancel_event(icalcomponent* c,
+                                            const char* user,
+                                            const char* msg);
+icalcomponent* icalmessage_new_cancel_instance(icalcomponent* c,
+                                            const char* user,
+                                            const char* msg);
+icalcomponent* icalmessage_new_cancel_all(icalcomponent* c,
+                                            const char* user,
+                                            const char* msg);
+
+
+icalcomponent* icalmessage_new_error_reply(icalcomponent* c,
+                                           const char* user,
+                                           const char* msg,
+                                           const char* debug,
+                                           icalrequeststatus rs);
+
+
+#endif /* ICALMESSAGE_H*/
+/* -*- Mode: C -*- */
+/*======================================================================
+  FILE: icalcstp.h
+  CREATOR: eric 20 April 1999
+  
+  $Id$
+
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalcstp.h
+
+======================================================================*/
+
+
+#ifndef ICALCSTP_H
+#define ICALCSTP_H
+
+
+
+/* Connection state, from the state machine in RFC2445 */
+enum cstps_state {
+    NO_STATE,
+    CONNECTED,
+    AUTHENTICATED,
+    IDENTIFIED,
+    DISCONNECTED,
+    RECEIVE
+};
+
+/* CSTP Commands that a client can issue to a server */
+typedef enum icalcstp_command {
+    ICAL_ABORT_COMMAND,
+    ICAL_AUTHENTICATE_COMMAND,
+    ICAL_CAPABILITY_COMMAND,
+    ICAL_CONTINUE_COMMAND,
+    ICAL_CALIDEXPAND_COMMAND,
+    ICAL_IDENTIFY_COMMAND,
+    ICAL_DISCONNECT_COMMAND,
+    ICAL_SENDDATA_COMMAND,
+    ICAL_STARTTLS_COMMAND,
+    ICAL_UPNEXPAND_COMMAND,
+    ICAL_COMPLETE_COMMAND,
+    ICAL_UNKNOWN_COMMAND
+} icalcstp_command;
+
+
+
+/* A statement is a combination of command or response code and a
+   component that the server and client exchage with each other. */
+struct icalcstp_statement {
+    icalcstp_command command;
+    char* str_data; /* If non-NUll use as arguments to command */
+    int int_data; /* If non-NULL use as arguments to command */
+
+    icalrequeststatus code;
+
+    icalcomponent* data;
+};
+
+const char* icalcstp_command_to_string(icalcstp_command command);
+icalcstp_command icalcstp_string_to_command(const char* str);
+
+#endif /* !ICALCSTP_H */
+
+
+
+/* -*- Mode: C -*- */
+/*======================================================================
+  FILE: icalcstpclient.h
+  CREATOR: eric 4 Feb 01
+  
+  $Id$
+
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalcstp.h
+
+======================================================================*/
+
+
+#ifndef ICALCSTPC_H
+#define ICALCSTPC_H
+
+
+/********************** Client (Sender) Interfaces **************************/
+
+/* How to use: 
+
+   1) Construct a new icalcstpc
+   2) Issue a command by calling one of the command routines. 
+   3) Repeat until both call icalcstpc_next_output and
+   icalcstpc_next_input return 0:
+     3a) Call icalcstpc_next_output. Send string to server. 
+     3b) Get string from server, & give to icalcstp_next_input()
+   4) Iterate with icalcstpc_first_response & icalcstp_next_response to 
+   get the servers responses
+   5) Repeat at #2
+*/
+
+
+typedef void icalcstpc;
+
+/* Response code sent by the server. */
+        typedef struct icalcstpc_response {
+    icalrequeststatus code;
+    char *arg; /* These strings are owned by libical */
+    char *debug_text;
+    char *more_text;
+    void* result;
+} icalcstpc_response;
+
+
+icalcstpc* icalcstpc_new();
+
+void icalcstpc_free(icalcstpc* cstpc);
+
+int icalcstpc_set_timeout(icalcstpc* cstp, int sec);
+
+
+/* Get the next string to send to the server */
+char* icalcstpc_next_output(icalcstpc* cstp, char* line);
+
+/* process the next string from the server */ 
+int icalcstpc_next_input(icalcstpc* cstp, char * line);
+
+/* After icalcstpc_next_input returns a 0, there are responses
+   ready. use these to get them */
+icalcstpc_response icalcstpc_first_response(icalcstpc* cstp);
+icalcstpc_response icalcstpc_next_response(icalcstpc* cstp);
+
+/* Issue a command */
+icalerrorenum icalcstpc_abort(icalcstpc* cstp);
+icalerrorenum icalcstpc_authenticate(icalcstpc* cstp, char* mechanism, 
+                                        char* init_data, char* f(char*) );
+icalerrorenum icalcstpc_capability(icalcstpc* cstp);
+icalerrorenum icalcstpc_calidexpand(icalcstpc* cstp,char* calid);
+icalerrorenum icalcstpc_continue(icalcstpc* cstp, unsigned int time);
+icalerrorenum icalcstpc_disconnect(icalcstpc* cstp);
+icalerrorenum icalcstpc_identify(icalcstpc* cstp, char* id);
+icalerrorenum icalcstpc_starttls(icalcstpc* cstp, char* command, 
+                                    char* init_data, char* f(char*));
+icalerrorenum icalcstpc_senddata(icalcstpc* cstp, unsigned int time,
+                                icalcomponent *comp);
+icalerrorenum icalcstpc_upnexpand(icalcstpc* cstp,char* calid);
+icalerrorenum icalcstpc_sendata(icalcstpc* cstp, unsigned int time,
+                                   icalcomponent *comp);
+
+
+#endif /* !ICALCSTPC_H */
+
+
+
+/* -*- Mode: C -*- */
+/*======================================================================
+  FILE: icalcstpserver.h
+  CREATOR: eric 13 Feb 01
+  
+  $Id$
+
+
+ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+  The original code is icalcstp.h
+
+======================================================================*/
+
+
+#ifndef ICALCSTPS_H
+#define ICALCSTPS_H
+
+
+
+/********************** Server (Reciever) Interfaces *************************/
+
+/* On the server side, the caller will recieve data from the incoming
+   socket and pass it to icalcstps_next_input. The caller then takes
+   the return from icalcstps_next_outpu and sends it out through the
+   socket. This gives the caller a point of control. If the cstp code
+   connected to the socket itself, it would be hard for the caller to
+   do anything else after the cstp code was started.
+
+   All of the server and client command routines will generate
+   response codes. On the server side, these responses will be turned
+   into text and sent to the client. On the client side, the reponse
+   is the one sent from the server.
+
+   Since each command can return multiple responses, the responses are
+   stored in the icalcstps object and are accesses by
+   icalcstps_first_response() and icalcstps_next_response()
+
+   How to use: 
+
+   1) Construct a new icalcstps, bound to your code via stubs
+   2) Repeat forever:
+     2a) Get string from client & give to icalcstps_next_input()
+     2b) Repeat until icalcstp_next_output returns 0:
+       2b1) Call icalcstps_next_output. 
+       2b2) Send string to client.
+*/
+
+
+
+typedef void icalcstps;
+
+/* Pointers to the rountines that
+   icalcstps_process_incoming will call when it recognizes a CSTP
+   command in the data. BTW, the CONTINUE command is named 'cont'
+   because 'continue' is a C keyword */
+
+struct icalcstps_commandfp {
+  icalerrorenum (*abort)(icalcstps* cstp);
+  icalerrorenum (*authenticate)(icalcstps* cstp, char* mechanism,
+                                    char* data);
+  icalerrorenum (*calidexpand)(icalcstps* cstp, char* calid);
+  icalerrorenum (*capability)(icalcstps* cstp);
+  icalerrorenum (*cont)(icalcstps* cstp, unsigned int time);
+  icalerrorenum (*identify)(icalcstps* cstp, char* id);
+  icalerrorenum (*disconnect)(icalcstps* cstp);
+  icalerrorenum (*sendata)(icalcstps* cstp, unsigned int time,
+                               icalcomponent *comp);
+  icalerrorenum (*starttls)(icalcstps* cstp, char* command,
+                                char* data);
+  icalerrorenum (*upnexpand)(icalcstps* cstp, char* upn);
+  icalerrorenum (*unknown)(icalcstps* cstp, char* command, char* data);
+};                                                        
+
+
+
+icalcstps* icalcstps_new(struct icalcstps_commandfp stubs);
+
+void icalcstps_free(icalcstps* cstp);
+
+int icalcstps_set_timeout(icalcstps* cstp, int sec);
+
+/* Get the next string to send to the client */
+char* icalcstps_next_output(icalcstps* cstp);
+
+/* process the next string from the client */ 
+int icalcstps_next_input(icalcstps* cstp);
+
+#endif /* ICALCSTPS */
diff --git a/libical/src/libicalss/icalsslexer.c b/libical/src/libicalss/icalsslexer.c
new file mode 100644
index 0000000..e10bcd3
--- a/dev/null
+++ b/libical/src/libicalss/icalsslexer.c
@@ -0,0 +1,1713 @@
+#define yy_create_buffer ss_create_buffer
+#define yy_delete_buffer ss_delete_buffer
+#define yy_scan_buffer ss_scan_buffer
+#define yy_scan_string ss_scan_string
+#define yy_scan_bytes ss_scan_bytes
+#define yy_flex_debug ss_flex_debug
+#define yy_init_buffer ss_init_buffer
+#define yy_flush_buffer ss_flush_buffer
+#define yy_load_buffer_state ss_load_buffer_state
+#define yy_switch_to_buffer ss_switch_to_buffer
+#define yyin ssin
+#define yyleng ssleng
+#define yylex sslex
+#define yyout ssout
+#define yyrestart ssrestart
+#define yytext sstext
+#define yywrap sswrap
+
+/* A lexical scanner generated by flex */
+
+/* Scanner skeleton version:
+ * $Header$
+ */
+
+#define FLEX_SCANNER
+#define YY_FLEX_MAJOR_VERSION 2
+#define YY_FLEX_MINOR_VERSION 5
+
+#include <stdio.h>
+// Eugen C. <eug@thekompany.com>
+#include <defines.h>
+#ifndef _QTWIN_
+#include <unistd.h>
+#else
+#include <io.h>
+#endif
+// Eugen C. <eug@thekompany.com>
+
+
+/* cfront 1.2 defines "c_plusplus" instead of "__cplusplus" */
+#ifdef c_plusplus
+#ifndef __cplusplus
+#define __cplusplus
+#endif
+#endif
+
+
+#ifdef __cplusplus
+
+#include <stdlib.h>
+
+/* Use prototypes in function declarations. */
+#define YY_USE_PROTOS
+
+/* The "const" storage-class-modifier is valid. */
+#define YY_USE_CONST
+
+        #else/* ! __cplusplus */
+
+#if __STDC__
+
+#define YY_USE_PROTOS
+#define YY_USE_CONST
+
+        #endif/* __STDC__ */
+        #endif/* ! __cplusplus */
+
+#ifdef __TURBOC__
+ #pragma warn -rch
+ #pragma warn -use
+#include <io.h>
+#include <stdlib.h>
+#define YY_USE_CONST
+#define YY_USE_PROTOS
+#endif
+
+#ifdef YY_USE_CONST
+#define yyconst const
+#else
+#define yyconst
+#endif
+
+
+#ifdef YY_USE_PROTOS
+#define YY_PROTO(proto) proto
+#else
+#define YY_PROTO(proto) ()
+#endif
+
+/* Returned upon end-of-file. */
+#define YY_NULL 0
+
+/* Promotes a possibly negative, possibly signed char to an unsigned
+ * integer for use as an array index.  If the signed char is negative,
+ * we want to instead treat it as an 8-bit unsigned char, hence the
+ * double cast.
+ */
+#define YY_SC_TO_UI(c) ((unsigned int) (unsigned char) c)
+
+/* Enter a start condition.  This macro really ought to take a parameter,
+ * but we do it the disgusting crufty way forced on us by the ()-less
+ * definition of BEGIN.
+ */
+#define BEGIN yy_start = 1 + 2 *
+
+/* Translate the current start state into a value that can be later handed
+ * to BEGIN to return to the state.  The YYSTATE alias is for lex
+ * compatibility.
+ */
+#define YY_START ((yy_start - 1) / 2)
+#define YYSTATE YY_START
+
+/* Action number for EOF rule of a given start state. */
+#define YY_STATE_EOF(state) (YY_END_OF_BUFFER + state + 1)
+
+/* Special action meaning "start processing a new file". */
+#define YY_NEW_FILE yyrestart( yyin )
+
+#define YY_END_OF_BUFFER_CHAR 0
+
+/* Size of default input buffer. */
+#define YY_BUF_SIZE 16384
+
+typedef struct yy_buffer_state *YY_BUFFER_STATE;
+
+extern int yyleng;
+extern FILE *yyin, *yyout;
+
+#define EOB_ACT_CONTINUE_SCAN 0
+#define EOB_ACT_END_OF_FILE 1
+#define EOB_ACT_LAST_MATCH 2
+
+/* The funky do-while in the following #define is used to turn the definition
+ * int a single C statement (which needs a semi-colon terminator).  This
+ * avoids problems with code like:
+ *
+         * if ( condition_holds )
+         *      yyless( 5 );
+         *else
+         *      do_something_else();
+ *
+ * Prior to using the do-while the compiler would get upset at the
+ * "else" because it interpreted the "if" statement as being all
+ * done when it reached the ';' after the yyless() call.
+ */
+
+/* Return all but the first 'n' matched characters back to the input stream. */
+
+#define yyless(n) \
+        do \
+                { \
+                /* Undo effects of setting up yytext. */ \
+                *yy_cp = yy_hold_char; \
+                YY_RESTORE_YY_MORE_OFFSET \
+                yy_c_buf_p = yy_cp = yy_bp + n - YY_MORE_ADJ; \
+                YY_DO_BEFORE_ACTION; /* set up yytext again */ \
+                } \
+        while ( 0 )
+
+#define unput(c) yyunput( c, yytext_ptr )
+
+/* The following is because we cannot portably get our hands on size_t
+ * (without autoconf's help, which isn't available because we want
+ * flex-generated scanners to compile on their own).
+ */
+typedef unsigned int yy_size_t;
+
+
+struct yy_buffer_state
+        {
+        FILE *yy_input_file;
+
+                char *yy_ch_buf;        /* input buffer */
+                char *yy_buf_pos;       /* current position in input buffer */
+
+        /* Size of input buffer in bytes, not including room for EOB
+         * characters.
+         */
+        yy_size_t yy_buf_size;
+
+        /* Number of characters read into yy_ch_buf, not including EOB
+         * characters.
+         */
+        int yy_n_chars;
+
+        /* Whether we "own" the buffer - i.e., we know we created it,
+         * and can realloc() it to grow it, and should free() it to
+         * delete it.
+         */
+        int yy_is_our_buffer;
+
+        /* Whether this is an "interactive" input source; if so, and
+         * if we're using stdio for input, then we want to use getc()
+         * instead of fread(), to make sure we stop fetching input after
+         * each newline.
+         */
+        int yy_is_interactive;
+
+        /* Whether we're considered to be at the beginning of a line.
+         * If so, '^' rules will be active on the next match, otherwise
+         * not.
+         */
+        int yy_at_bol;
+
+        /* Whether to try to fill the input buffer when we reach the
+         * end of it.
+         */
+        int yy_fill_buffer;
+
+        int yy_buffer_status;
+#define YY_BUFFER_NEW 0
+#define YY_BUFFER_NORMAL 1
+        /* When an EOF's been seen but there's still some text to process
+         * then we mark the buffer as YY_EOF_PENDING, to indicate that we
+         * shouldn't try reading from the input source any more.  We might
+         * still have a bunch of tokens to match, though, because of
+         * possible backing-up.
+         *
+         * When we actually see the EOF, we change the status to "new"
+         * (via yyrestart()), so that the user can continue scanning by
+         * just pointing yyin at a new input file.
+         */
+#define YY_BUFFER_EOF_PENDING 2
+        };
+
+static YY_BUFFER_STATE yy_current_buffer = 0;
+
+/* We provide macros for accessing buffer states in case in the
+ * future we want to put the buffer states in a more general
+ * "scanner state".
+ */
+#define YY_CURRENT_BUFFER yy_current_buffer
+
+
+/* yy_hold_char holds the character lost when yytext is formed. */
+static char yy_hold_char;
+
+        static int yy_n_chars;  /* number of characters read into yy_ch_buf */
+
+
+int yyleng;
+
+/* Points to current character in buffer. */
+static char *yy_c_buf_p = (char *) 0;
+        static int yy_init = 1;         /* whether we need to initialize */
+        static int yy_start = 0;/* start state number */
+
+/* Flag which is used to allow yywrap()'s to do buffer switches
+ * instead of setting up a fresh yyin.  A bit of a hack ...
+ */
+static int yy_did_buffer_switch_on_eof;
+
+void yyrestart YY_PROTO(( FILE *input_file ));
+
+void yy_switch_to_buffer YY_PROTO(( YY_BUFFER_STATE new_buffer ));
+void yy_load_buffer_state YY_PROTO(( void ));
+YY_BUFFER_STATE yy_create_buffer YY_PROTO(( FILE *file, int size ));
+void yy_delete_buffer YY_PROTO(( YY_BUFFER_STATE b ));
+void yy_init_buffer YY_PROTO(( YY_BUFFER_STATE b, FILE *file ));
+void yy_flush_buffer YY_PROTO(( YY_BUFFER_STATE b ));
+#define YY_FLUSH_BUFFER yy_flush_buffer( yy_current_buffer )
+
+YY_BUFFER_STATE yy_scan_buffer YY_PROTO(( char *base, yy_size_t size ));
+YY_BUFFER_STATE yy_scan_string YY_PROTO(( yyconst char *yy_str ));
+YY_BUFFER_STATE yy_scan_bytes YY_PROTO(( yyconst char *bytes, int len ));
+
+static void *yy_flex_alloc YY_PROTO(( yy_size_t ));
+static void *yy_flex_realloc YY_PROTO(( void *, yy_size_t ));
+static void yy_flex_free YY_PROTO(( void * ));
+
+#define yy_new_buffer yy_create_buffer
+
+#define yy_set_interactive(is_interactive) \
+        { \
+        if ( ! yy_current_buffer ) \
+                yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
+        yy_current_buffer->yy_is_interactive = is_interactive; \
+        }
+
+#define yy_set_bol(at_bol) \
+        { \
+        if ( ! yy_current_buffer ) \
+                yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE ); \
+        yy_current_buffer->yy_at_bol = at_bol; \
+        }
+
+#define YY_AT_BOL() (yy_current_buffer->yy_at_bol)
+
+typedef unsigned char YY_CHAR;
+FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
+typedef int yy_state_type;
+extern char yytext[];
+
+
+static yy_state_type yy_get_previous_state YY_PROTO(( void ));
+static yy_state_type yy_try_NUL_trans YY_PROTO(( yy_state_type current_state ));
+static int yy_get_next_buffer YY_PROTO(( void ));
+static void yy_fatal_error YY_PROTO(( yyconst char msg[] ));
+
+/* Done after the current pattern has been matched and before the
+ * corresponding action - sets up yytext.
+ */
+#define YY_DO_BEFORE_ACTION \
+        yytext_ptr = yy_bp; \
+        yyleng = (int) (yy_cp - yy_bp); \
+        yy_hold_char = *yy_cp; \
+        *yy_cp = '\0'; \
+        if ( yyleng >= YYLMAX ) \
+                YY_FATAL_ERROR( "token too large, exceeds YYLMAX" ); \
+        yy_flex_strncpy( yytext, yytext_ptr, yyleng + 1 ); \
+        yy_c_buf_p = yy_cp;
+
+#define YY_NUM_RULES 19
+#define YY_END_OF_BUFFER 20
+static yyconst short int yy_accept[47] =
+    {   0,
+        0,    0,    0,    0,    0,    0,   20,   18,   14,   14,
+       18,   13,   17,    4,   15,    7,    5,    8,   17,   17,
+       17,   17,   17,   14,    6,    0,   17,    9,   10,   17,
+       17,   12,   17,   17,   16,   11,   17,   17,   17,    2,
+       17,   17,   17,    3,    1,    0
+    } ;
+
+static yyconst int yy_ec[256] =
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
+        1,    1,    2,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    2,    4,    1,    1,    1,    1,    1,    5,    1,
+        1,    6,    1,    7,    6,    6,    1,    6,    6,    6,
+        6,    6,    6,    6,    6,    6,    6,    1,    8,    9,
+       10,   11,    1,    1,   12,    6,   13,   14,   15,   16,
+        6,   17,    6,    6,    6,   18,   19,   20,   21,    6,
+        6,   22,   23,   24,    6,    6,   25,    6,    6,    6,
+        1,    1,    1,    1,    1,    1,   12,    6,   13,   14,
+
+       15,   16,    6,   17,    6,    6,    6,   18,   19,   20,
+       21,    6,    6,   22,   23,   24,    6,    6,   25,    6,
+        6,    6,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1
+    } ;
+
+static yyconst int yy_meta[26] =
+    {   0,
+        1,    1,    1,    1,    1,    2,    1,    1,    1,    1,
+        1,    2,    2,    2,    2,    2,    2,    2,    2,    2,
+        2,    2,    2,    2,    2
+    } ;
+
+static yyconst short int yy_base[49] =
+    {   0,
+        0,    0,    0,    0,    0,    0,   53,   54,   24,   26,
+       42,    0,    0,   54,   54,   41,   54,   40,   29,   26,
+       25,   31,   28,   28,   54,   39,    0,   54,   54,   29,
+       21,    0,   23,   25,   54,    0,   20,   23,   15,    0,
+       23,   20,   10,    0,    0,   54,   31,   30
+    } ;
+
+static yyconst short int yy_def[49] =
+    {   0,
+       46,    1,    1,    1,    1,    1,   46,   46,   46,   46,
+       46,   47,   48,   46,   46,   46,   46,   46,   48,   48,
+       48,   48,   48,   46,   46,   47,   48,   46,   46,   48,
+       48,   48,   48,   48,   46,   48,   48,   48,   48,   48,
+       48,   48,   48,   48,   48,    0,   46,   46
+    } ;
+
+static yyconst short int yy_nxt[80] =
+    {   0,
+        8,    9,   10,   11,   12,   13,   14,   15,   16,   17,
+       18,   19,   13,   13,   13,   20,   13,   13,   13,   13,
+       21,   13,   22,   13,   23,   24,   24,   24,   24,   24,
+       24,   27,   26,   45,   44,   43,   42,   41,   40,   39,
+       38,   37,   36,   35,   34,   33,   32,   31,   30,   29,
+       28,   25,   46,    7,   46,   46,   46,   46,   46,   46,
+       46,   46,   46,   46,   46,   46,   46,   46,   46,   46,
+       46,   46,   46,   46,   46,   46,   46,   46,   46
+    } ;
+
+static yyconst short int yy_chk[80] =
+    {   0,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
+        1,    1,    1,    1,    1,    9,    9,   10,   10,   24,
+       24,   48,   47,   43,   42,   41,   39,   38,   37,   34,
+       33,   31,   30,   26,   23,   22,   21,   20,   19,   18,
+       16,   11,    7,   46,   46,   46,   46,   46,   46,   46,
+       46,   46,   46,   46,   46,   46,   46,   46,   46,   46,
+       46,   46,   46,   46,   46,   46,   46,   46,   46
+    } ;
+
+static yy_state_type yy_last_accepting_state;
+static char *yy_last_accepting_cpos;
+
+/* The intent behind this definition is that it'll catch
+ * any uses of REJECT which flex missed.
+ */
+#define REJECT reject_used_but_not_detected
+#define yymore() yymore_used_but_not_detected
+#define YY_MORE_ADJ 0
+#define YY_RESTORE_YY_MORE_OFFSET
+#ifndef YYLMAX
+#define YYLMAX 8192
+#endif
+
+char yytext[YYLMAX];
+char *yytext_ptr;
+#line 1 "icalsslexer.l"
+#define INITIAL 0
+#line 2 "icalsslexer.l"
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: icalsslexer.l
+  CREATOR: eric 8 Aug 2000
+  
+  DESCRIPTION:
+  
+  $Id$
+  $Locker$
+
+(C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+  ======================================================================*/
+
+#include "icalssyacc.h"
+#include "icalgaugeimpl.h"
+#include "assert.h"
+
+#include <string.h> /* For strdup() */
+
+int icalparser_flex_input(char* buf, int max_size);
+void icalparser_clear_flex_input();
+
+#undef YY_INPUT
+#define YY_INPUT(b,r,ms) ( r= icalparser_flex_input(b,ms))
+
+#undef SS_FATAL_ERROR
+#define SS_FATAL_ERROR(msg) sserror(msg)
+
+
+#define sql 1
+#define string_value 2
+
+#line 465 "icalsslexer.c"
+
+/* Macros after this point can all be overridden by user definitions in
+ * section 1.
+ */
+
+#ifndef YY_SKIP_YYWRAP
+#ifdef __cplusplus
+extern "C" int yywrap YY_PROTO(( void ));
+#else
+extern int yywrap YY_PROTO(( void ));
+#endif
+#endif
+
+#ifndef YY_NO_UNPUT
+static void yyunput YY_PROTO(( int c, char *buf_ptr ));
+#endif
+
+#ifndef yytext_ptr
+static void yy_flex_strncpy YY_PROTO(( char *, yyconst char *, int ));
+#endif
+
+#ifdef YY_NEED_STRLEN
+static int yy_flex_strlen YY_PROTO(( yyconst char * ));
+#endif
+
+#ifndef YY_NO_INPUT
+#ifdef __cplusplus
+static int yyinput YY_PROTO(( void ));
+#else
+static int input YY_PROTO(( void ));
+#endif
+#endif
+
+#if YY_STACK_USED
+static int yy_start_stack_ptr = 0;
+static int yy_start_stack_depth = 0;
+static int *yy_start_stack = 0;
+#ifndef YY_NO_PUSH_STATE
+static void yy_push_state YY_PROTO(( int new_state ));
+#endif
+#ifndef YY_NO_POP_STATE
+static void yy_pop_state YY_PROTO(( void ));
+#endif
+#ifndef YY_NO_TOP_STATE
+static int yy_top_state YY_PROTO(( void ));
+#endif
+
+#else
+#define YY_NO_PUSH_STATE 1
+#define YY_NO_POP_STATE 1
+#define YY_NO_TOP_STATE 1
+#endif
+
+#ifdef YY_MALLOC_DECL
+YY_MALLOC_DECL
+#else
+#if __STDC__
+#ifndef __cplusplus
+#include <stdlib.h>
+#endif
+#else
+/* Just try to get by without declaring the routines.  This will fail
+ * miserably on non-ANSI systems for which sizeof(size_t) != sizeof(int)
+ * or sizeof(void*) != sizeof(int).
+ */
+#endif
+#endif
+
+/* Amount of stuff to slurp up with each read. */
+#ifndef YY_READ_BUF_SIZE
+#define YY_READ_BUF_SIZE 8192
+#endif
+
+/* Copy whatever the last rule matched to the standard output. */
+
+#ifndef ECHO
+/* This used to be an fputs(), but since the string might contain NUL's,
+ * we now use fwrite().
+ */
+#define ECHO (void) fwrite( yytext, yyleng, 1, yyout )
+#endif
+
+/* Gets input and stuffs it into "buf".  number of characters read, or YY_NULL,
+ * is returned in "result".
+ */
+#ifndef YY_INPUT
+#define YY_INPUT(buf,result,max_size) \
+        if ( yy_current_buffer->yy_is_interactive ) \
+                { \
+                int c = '*', n; \
+                for ( n = 0; n < max_size && \
+                             (c = getc( yyin )) != EOF && c != '\n'; ++n ) \
+                        buf[n] = (char) c; \
+                if ( c == '\n' ) \
+                        buf[n++] = (char) c; \
+                if ( c == EOF && ferror( yyin ) ) \
+                        YY_FATAL_ERROR( "input in flex scanner failed" ); \
+                result = n; \
+                } \
+        else if ( ((result = fread( buf, 1, max_size, yyin )) == 0) \
+                  && ferror( yyin ) ) \
+                YY_FATAL_ERROR( "input in flex scanner failed" );
+#endif
+
+/* No semi-colon after return; correct usage is to write "yyterminate();" -
+ * we don't want an extra ';' after the "return" because that will cause
+ * some compilers to complain about unreachable statements.
+ */
+#ifndef yyterminate
+#define yyterminate() return YY_NULL
+#endif
+
+/* Number of entries by which start-condition stack grows. */
+#ifndef YY_START_STACK_INCR
+#define YY_START_STACK_INCR 25
+#endif
+
+/* Report a fatal error. */
+#ifndef YY_FATAL_ERROR
+#define YY_FATAL_ERROR(msg) yy_fatal_error( msg )
+#endif
+
+/* Default declaration of generated scanner - a define so the user can
+ * easily add parameters.
+ */
+#ifndef YY_DECL
+#define YY_DECL int yylex YY_PROTO(( void ))
+#endif
+
+/* Code executed at the beginning of each rule, after yytext and yyleng
+ * have been set up.
+ */
+#ifndef YY_USER_ACTION
+#define YY_USER_ACTION
+#endif
+
+/* Code executed at the end of each rule. */
+#ifndef YY_BREAK
+#define YY_BREAK break;
+#endif
+
+#define YY_RULE_SETUP \
+        YY_USER_ACTION
+
+YY_DECL
+        {
+        register yy_state_type yy_current_state;
+        register char *yy_cp = NULL, *yy_bp = NULL;
+        register int yy_act;
+
+#line 69 "icalsslexer.l"
+
+
+
+
+
+
+#line 623 "icalsslexer.c"
+
+        if ( yy_init )
+                {
+                yy_init = 0;
+
+#ifdef YY_USER_INIT
+                YY_USER_INIT;
+#endif
+
+                if ( ! yy_start )
+                                yy_start = 1;/* first start state */
+
+                if ( ! yyin )
+                        yyin = stdin;
+
+                if ( ! yyout )
+                        yyout = stdout;
+
+                if ( ! yy_current_buffer )
+                        yy_current_buffer =
+                                yy_create_buffer( yyin, YY_BUF_SIZE );
+
+                yy_load_buffer_state();
+                }
+
+                while ( 1 )     /* loops until end-of-file is reached */
+                {
+                yy_cp = yy_c_buf_p;
+
+                /* Support of yytext. */
+                *yy_cp = yy_hold_char;
+
+                /* yy_bp points to the position in yy_ch_buf of the start of
+                 * the current run.
+                 */
+                yy_bp = yy_cp;
+
+                yy_current_state = yy_start;
+yy_match:
+                do
+                        {
+                        register YY_CHAR yy_c = yy_ec[YY_SC_TO_UI(*yy_cp)];
+                        if ( yy_accept[yy_current_state] )
+                                {
+                                yy_last_accepting_state = yy_current_state;
+                                yy_last_accepting_cpos = yy_cp;
+                                }
+                        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+                                {
+                                yy_current_state = (int) yy_def[yy_current_state];
+                                if ( yy_current_state >= 47 )
+                                        yy_c = yy_meta[(unsigned int) yy_c];
+                                }
+                        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+                        ++yy_cp;
+                        }
+                while ( yy_base[yy_current_state] != 54 );
+
+yy_find_action:
+                yy_act = yy_accept[yy_current_state];
+                if ( yy_act == 0 )
+                        { /* have to back up */
+                        yy_cp = yy_last_accepting_cpos;
+                        yy_current_state = yy_last_accepting_state;
+                        yy_act = yy_accept[yy_current_state];
+                        }
+
+                YY_DO_BEFORE_ACTION;
+
+
+        do_action:/* This label is used only to access EOF actions. */
+
+
+                switch ( yy_act )
+        { /* beginning of action switch */
+                        case 0: /* must back up */
+                        /* undo the effects of YY_DO_BEFORE_ACTION */
+                        *yy_cp = yy_hold_char;
+                        yy_cp = yy_last_accepting_cpos;
+                        yy_current_state = yy_last_accepting_state;
+                        goto yy_find_action;
+
+case 1:
+YY_RULE_SETUP
+#line 75 "icalsslexer.l"
+{ return SELECT; }
+        YY_BREAK
+case 2:
+YY_RULE_SETUP
+#line 76 "icalsslexer.l"
+{ return FROM; }
+        YY_BREAK
+case 3:
+YY_RULE_SETUP
+#line 77 "icalsslexer.l"
+{ return WHERE; }
+        YY_BREAK
+case 4:
+YY_RULE_SETUP
+#line 78 "icalsslexer.l"
+{ return COMMA; }
+        YY_BREAK
+case 5:
+YY_RULE_SETUP
+#line 79 "icalsslexer.l"
+{ return EQUALS; }
+        YY_BREAK
+case 6:
+YY_RULE_SETUP
+#line 80 "icalsslexer.l"
+{ return NOTEQUALS; }
+        YY_BREAK
+case 7:
+YY_RULE_SETUP
+#line 81 "icalsslexer.l"
+{ return LESS; }
+        YY_BREAK
+case 8:
+YY_RULE_SETUP
+#line 82 "icalsslexer.l"
+{ return GREATER; }
+        YY_BREAK
+case 9:
+YY_RULE_SETUP
+#line 83 "icalsslexer.l"
+{ return LESSEQUALS; }
+        YY_BREAK
+case 10:
+YY_RULE_SETUP
+#line 84 "icalsslexer.l"
+{ return GREATEREQUALS; }
+        YY_BREAK
+case 11:
+YY_RULE_SETUP
+#line 85 "icalsslexer.l"
+{ return AND; }
+        YY_BREAK
+case 12:
+YY_RULE_SETUP
+#line 86 "icalsslexer.l"
+{ return OR; }
+        YY_BREAK
+case 13:
+YY_RULE_SETUP
+#line 87 "icalsslexer.l"
+{ return QUOTE; }
+        YY_BREAK
+case 14:
+YY_RULE_SETUP
+#line 88 "icalsslexer.l"
+        ;               
+        YY_BREAK
+case 15:
+YY_RULE_SETUP
+#line 89 "icalsslexer.l"
+{ return EOL; }
+        YY_BREAK
+case 16:
+YY_RULE_SETUP
+#line 90 "icalsslexer.l"
+{
+        int c = input();
+        unput(c);
+        if(c!='\''){
+                sslval.v_string= icalmemory_tmp_copy(sstext);
+                return STRING;
+        } else {
+                /*ssmore();*/
+        }
+}
+        YY_BREAK
+case 17:
+YY_RULE_SETUP
+#line 101 "icalsslexer.l"
+{ sslval.v_string= icalmemory_tmp_copy(sstext);
+                          return STRING; }
+        YY_BREAK
+case 18:
+YY_RULE_SETUP
+#line 105 "icalsslexer.l"
+{ return yytext[0]; }
+        YY_BREAK
+case 19:
+YY_RULE_SETUP
+#line 107 "icalsslexer.l"
+ECHO;
+        YY_BREAK
+#line 811 "icalsslexer.c"
+case YY_STATE_EOF(INITIAL):
+case YY_STATE_EOF(sql):
+case YY_STATE_EOF(string_value):
+        yyterminate();
+
+        case YY_END_OF_BUFFER:
+                {
+                /* Amount of text matched not including the EOB char. */
+                int yy_amount_of_matched_text = (int) (yy_cp - yytext_ptr) - 1;
+
+                /* Undo the effects of YY_DO_BEFORE_ACTION. */
+                *yy_cp = yy_hold_char;
+                YY_RESTORE_YY_MORE_OFFSET
+
+                if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_NEW )
+                        {
+                        /* We're scanning a new file or input source.  It's
+                         * possible that this happened because the user
+                         * just pointed yyin at a new source and called
+                         * yylex().  If so, then we have to assure
+                         * consistency between yy_current_buffer and our
+                         * globals.  Here is the right place to do so, because
+                         * this is the first action (other than possibly a
+                         * back-up) that will match for the new input source.
+                         */
+                        yy_n_chars = yy_current_buffer->yy_n_chars;
+                        yy_current_buffer->yy_input_file = yyin;
+                        yy_current_buffer->yy_buffer_status = YY_BUFFER_NORMAL;
+                        }
+
+                /* Note that here we test for yy_c_buf_p "<=" to the position
+                 * of the first EOB in the buffer, since yy_c_buf_p will
+                 * already have been incremented past the NUL character
+                 * (since all states make transitions on EOB to the
+                 * end-of-buffer state).  Contrast this with the test
+                 * in input().
+                 */
+                if ( yy_c_buf_p <= &yy_current_buffer->yy_ch_buf[yy_n_chars] )
+                        { /* This was really a NUL. */
+                        yy_state_type yy_next_state;
+
+                        yy_c_buf_p = yytext_ptr + yy_amount_of_matched_text;
+
+                        yy_current_state = yy_get_previous_state();
+
+                        /* Okay, we're now positioned to make the NUL
+                         * transition.  We couldn't have
+                         * yy_get_previous_state() go ahead and do it
+                         * for us because it doesn't know how to deal
+                         * with the possibility of jamming (and we don't
+                         * want to build jamming into it because then it
+                         * will run more slowly).
+                         */
+
+                        yy_next_state = yy_try_NUL_trans( yy_current_state );
+
+                        yy_bp = yytext_ptr + YY_MORE_ADJ;
+
+                        if ( yy_next_state )
+                                {
+                                /* Consume the NUL. */
+                                yy_cp = ++yy_c_buf_p;
+                                yy_current_state = yy_next_state;
+                                goto yy_match;
+                                }
+
+                        else
+                                {
+                                yy_cp = yy_c_buf_p;
+                                goto yy_find_action;
+                                }
+                        }
+
+                else switch ( yy_get_next_buffer() )
+                        {
+                        case EOB_ACT_END_OF_FILE:
+                                {
+                                yy_did_buffer_switch_on_eof = 0;
+
+                                if ( yywrap() )
+                                        {
+                                        /* Note: because we've taken care in
+                                         * yy_get_next_buffer() to have set up
+                                         * yytext, we can now set up
+                                         * yy_c_buf_p so that if some total
+                                         * hoser (like flex itself) wants to
+                                         * call the scanner after we return the
+                                         * YY_NULL, it'll still work - another
+                                         * YY_NULL will get returned.
+                                         */
+                                        yy_c_buf_p = yytext_ptr + YY_MORE_ADJ;
+
+                                        yy_act = YY_STATE_EOF(YY_START);
+                                        goto do_action;
+                                        }
+
+                                else
+                                        {
+                                        if ( ! yy_did_buffer_switch_on_eof )
+                                                YY_NEW_FILE;
+                                        }
+                                break;
+                                }
+
+                        case EOB_ACT_CONTINUE_SCAN:
+                                yy_c_buf_p =
+                                        yytext_ptr + yy_amount_of_matched_text;
+
+                                yy_current_state = yy_get_previous_state();
+
+                                yy_cp = yy_c_buf_p;
+                                yy_bp = yytext_ptr + YY_MORE_ADJ;
+                                goto yy_match;
+
+                        case EOB_ACT_LAST_MATCH:
+                                yy_c_buf_p =
+                                &yy_current_buffer->yy_ch_buf[yy_n_chars];
+
+                                yy_current_state = yy_get_previous_state();
+
+                                yy_cp = yy_c_buf_p;
+                                yy_bp = yytext_ptr + YY_MORE_ADJ;
+                                goto yy_find_action;
+                        }
+                break;
+                }
+
+        default:
+                YY_FATAL_ERROR(
+                        "fatal flex scanner internal error--no action found" );
+        } /* end of action switch */
+                } /* end of scanning one token */
+        } /* end of yylex */
+
+
+/* yy_get_next_buffer - try to read in a new buffer
+ *
+ * Returns a code representing an action:
+         *EOB_ACT_LAST_MATCH -
+         *EOB_ACT_CONTINUE_SCAN - continue scanning from current position
+         *EOB_ACT_END_OF_FILE - end of file
+ */
+
+static int yy_get_next_buffer()
+        {
+        register char *dest = yy_current_buffer->yy_ch_buf;
+        register char *source = yytext_ptr;
+        register int number_to_move, i;
+        int ret_val;
+
+        if ( yy_c_buf_p > &yy_current_buffer->yy_ch_buf[yy_n_chars + 1] )
+                YY_FATAL_ERROR(
+                "fatal flex scanner internal error--end of buffer missed" );
+
+        if ( yy_current_buffer->yy_fill_buffer == 0 )
+                { /* Don't try to fill the buffer, so this is an EOF. */
+                if ( yy_c_buf_p - yytext_ptr - YY_MORE_ADJ == 1 )
+                        {
+                        /* We matched a single character, the EOB, so
+                         * treat this as a final EOF.
+                         */
+                        return EOB_ACT_END_OF_FILE;
+                        }
+
+                else
+                        {
+                        /* We matched some text prior to the EOB, first
+                         * process it.
+                         */
+                        return EOB_ACT_LAST_MATCH;
+                        }
+                }
+
+        /* Try to read more data. */
+
+        /* First move last chars to start of buffer. */
+        number_to_move = (int) (yy_c_buf_p - yytext_ptr) - 1;
+
+        for ( i = 0; i < number_to_move; ++i )
+                *(dest++) = *(source++);
+
+        if ( yy_current_buffer->yy_buffer_status == YY_BUFFER_EOF_PENDING )
+                /* don't do the read, it's not guaranteed to return an EOF,
+                 * just force an EOF
+                 */
+                yy_current_buffer->yy_n_chars = yy_n_chars = 0;
+
+        else
+                {
+                int num_to_read =
+                        yy_current_buffer->yy_buf_size - number_to_move - 1;
+
+                while ( num_to_read <= 0 )
+                        { /* Not enough room in the buffer - grow it. */
+#ifdef YY_USES_REJECT
+                        YY_FATAL_ERROR(
+"input buffer overflow, can't enlarge buffer because scanner uses REJECT" );
+#else
+
+                        /* just a shorter name for the current buffer */
+                        YY_BUFFER_STATE b = yy_current_buffer;
+
+                        int yy_c_buf_p_offset =
+                                (int) (yy_c_buf_p - b->yy_ch_buf);
+
+                        if ( b->yy_is_our_buffer )
+                                {
+                                int new_size = b->yy_buf_size * 2;
+
+                                if ( new_size <= 0 )
+                                        b->yy_buf_size += b->yy_buf_size / 8;
+                                else
+                                        b->yy_buf_size *= 2;
+
+                                b->yy_ch_buf = (char *)
+                                        /* Include room in for 2 EOB chars. */
+                                        yy_flex_realloc( (void *) b->yy_ch_buf,
+                                                         b->yy_buf_size + 2 );
+                                }
+                        else
+                                /* Can't grow it, we don't own it. */
+                                b->yy_ch_buf = 0;
+
+                        if ( ! b->yy_ch_buf )
+                                YY_FATAL_ERROR(
+                                "fatal error - scanner input buffer overflow" );
+
+                        yy_c_buf_p = &b->yy_ch_buf[yy_c_buf_p_offset];
+
+                        num_to_read = yy_current_buffer->yy_buf_size -
+                                                number_to_move - 1;
+#endif
+                        }
+
+                if ( num_to_read > YY_READ_BUF_SIZE )
+                        num_to_read = YY_READ_BUF_SIZE;
+
+                /* Read in more data. */
+                YY_INPUT( (&yy_current_buffer->yy_ch_buf[number_to_move]),
+                        yy_n_chars, num_to_read );
+
+                yy_current_buffer->yy_n_chars = yy_n_chars;
+                }
+
+        if ( yy_n_chars == 0 )
+                {
+                if ( number_to_move == YY_MORE_ADJ )
+                        {
+                        ret_val = EOB_ACT_END_OF_FILE;
+                        yyrestart( yyin );
+                        }
+
+                else
+                        {
+                        ret_val = EOB_ACT_LAST_MATCH;
+                        yy_current_buffer->yy_buffer_status =
+                                YY_BUFFER_EOF_PENDING;
+                        }
+                }
+
+        else
+                ret_val = EOB_ACT_CONTINUE_SCAN;
+
+        yy_n_chars += number_to_move;
+        yy_current_buffer->yy_ch_buf[yy_n_chars] = YY_END_OF_BUFFER_CHAR;
+        yy_current_buffer->yy_ch_buf[yy_n_chars + 1] = YY_END_OF_BUFFER_CHAR;
+
+        yytext_ptr = &yy_current_buffer->yy_ch_buf[0];
+
+        return ret_val;
+        }
+
+
+/* yy_get_previous_state - get the state just before the EOB char was reached */
+
+static yy_state_type yy_get_previous_state()
+        {
+        register yy_state_type yy_current_state;
+        register char *yy_cp;
+
+        yy_current_state = yy_start;
+
+        for ( yy_cp = yytext_ptr + YY_MORE_ADJ; yy_cp < yy_c_buf_p; ++yy_cp )
+                {
+                register YY_CHAR yy_c = (*yy_cp ? yy_ec[YY_SC_TO_UI(*yy_cp)] : 1);
+                if ( yy_accept[yy_current_state] )
+                        {
+                        yy_last_accepting_state = yy_current_state;
+                        yy_last_accepting_cpos = yy_cp;
+                        }
+                while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+                        {
+                        yy_current_state = (int) yy_def[yy_current_state];
+                        if ( yy_current_state >= 47 )
+                                yy_c = yy_meta[(unsigned int) yy_c];
+                        }
+                yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+                }
+
+        return yy_current_state;
+        }
+
+
+/* yy_try_NUL_trans - try to make a transition on the NUL character
+ *
+ * synopsis
+         *next_state = yy_try_NUL_trans( current_state );
+ */
+
+#ifdef YY_USE_PROTOS
+static yy_state_type yy_try_NUL_trans( yy_state_type yy_current_state )
+#else
+static yy_state_type yy_try_NUL_trans( yy_current_state )
+yy_state_type yy_current_state;
+#endif
+        {
+        register int yy_is_jam;
+        register char *yy_cp = yy_c_buf_p;
+
+        register YY_CHAR yy_c = 1;
+        if ( yy_accept[yy_current_state] )
+                {
+                yy_last_accepting_state = yy_current_state;
+                yy_last_accepting_cpos = yy_cp;
+                }
+        while ( yy_chk[yy_base[yy_current_state] + yy_c] != yy_current_state )
+                {
+                yy_current_state = (int) yy_def[yy_current_state];
+                if ( yy_current_state >= 47 )
+                        yy_c = yy_meta[(unsigned int) yy_c];
+                }
+        yy_current_state = yy_nxt[yy_base[yy_current_state] + (unsigned int) yy_c];
+        yy_is_jam = (yy_current_state == 46);
+
+        return yy_is_jam ? 0 : yy_current_state;
+        }
+
+
+#ifndef YY_NO_UNPUT
+#ifdef YY_USE_PROTOS
+static void yyunput( int c, register char *yy_bp )
+#else
+static void yyunput( c, yy_bp )
+int c;
+register char *yy_bp;
+#endif
+        {
+        register char *yy_cp = yy_c_buf_p;
+
+        /* undo effects of setting up yytext */
+        *yy_cp = yy_hold_char;
+
+        if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
+                { /* need to shift things up to make room */
+                /* +2 for EOB chars. */
+                register int number_to_move = yy_n_chars + 2;
+                register char *dest = &yy_current_buffer->yy_ch_buf[
+                                        yy_current_buffer->yy_buf_size + 2];
+                register char *source =
+                                &yy_current_buffer->yy_ch_buf[number_to_move];
+
+                while ( source > yy_current_buffer->yy_ch_buf )
+                        *--dest = *--source;
+
+                yy_cp += (int) (dest - source);
+                yy_bp += (int) (dest - source);
+                yy_current_buffer->yy_n_chars =
+                        yy_n_chars = yy_current_buffer->yy_buf_size;
+
+                if ( yy_cp < yy_current_buffer->yy_ch_buf + 2 )
+                        YY_FATAL_ERROR( "flex scanner push-back overflow" );
+                }
+
+        *--yy_cp = (char) c;
+
+
+        yytext_ptr = yy_bp;
+        yy_hold_char = *yy_cp;
+        yy_c_buf_p = yy_cp;
+        }
+        #endif/* ifndef YY_NO_UNPUT */
+
+
+#ifdef __cplusplus
+static int yyinput()
+#else
+static int input()
+#endif
+        {
+        int c;
+
+        *yy_c_buf_p = yy_hold_char;
+
+        if ( *yy_c_buf_p == YY_END_OF_BUFFER_CHAR )
+                {
+                /* yy_c_buf_p now points to the character we want to return.
+                 * If this occurs *before* the EOB characters, then it's a
+                 * valid NUL; if not, then we've hit the end of the buffer.
+                 */
+                if ( yy_c_buf_p < &yy_current_buffer->yy_ch_buf[yy_n_chars] )
+                        /* This was really a NUL. */
+                        *yy_c_buf_p = '\0';
+
+                else
+                        { /* need more input */
+                        int offset = yy_c_buf_p - yytext_ptr;
+                        ++yy_c_buf_p;
+
+                        switch ( yy_get_next_buffer() )
+                                {
+                                case EOB_ACT_LAST_MATCH:
+                                        /* This happens because yy_g_n_b()
+                                         * sees that we've accumulated a
+                                         * token and flags that we need to
+                                         * try matching the token before
+                                         * proceeding.  But for input(),
+                                         * there's no matching to consider.
+                                         * So convert the EOB_ACT_LAST_MATCH
+                                         * to EOB_ACT_END_OF_FILE.
+                                         */
+
+                                        /* Reset buffer status. */
+                                        yyrestart( yyin );
+
+                                        /* fall through */
+
+                                case EOB_ACT_END_OF_FILE:
+                                        {
+                                        if ( yywrap() )
+                                                return EOF;
+
+                                        if ( ! yy_did_buffer_switch_on_eof )
+                                                YY_NEW_FILE;
+#ifdef __cplusplus
+                                        return yyinput();
+#else
+                                        return input();
+#endif
+                                        }
+
+                                case EOB_ACT_CONTINUE_SCAN:
+                                        yy_c_buf_p = yytext_ptr + offset;
+                                        break;
+                                }
+                        }
+                }
+
+                c = *(unsigned char *) yy_c_buf_p;/* cast for 8-bit char's */
+                *yy_c_buf_p = '\0';/* preserve yytext */
+        yy_hold_char = *++yy_c_buf_p;
+
+
+        return c;
+        }
+
+
+#ifdef YY_USE_PROTOS
+void yyrestart( FILE *input_file )
+#else
+void yyrestart( input_file )
+FILE *input_file;
+#endif
+        {
+        if ( ! yy_current_buffer )
+                yy_current_buffer = yy_create_buffer( yyin, YY_BUF_SIZE );
+
+        yy_init_buffer( yy_current_buffer, input_file );
+        yy_load_buffer_state();
+        }
+
+
+#ifdef YY_USE_PROTOS
+void yy_switch_to_buffer( YY_BUFFER_STATE new_buffer )
+#else
+void yy_switch_to_buffer( new_buffer )
+YY_BUFFER_STATE new_buffer;
+#endif
+        {
+        if ( yy_current_buffer == new_buffer )
+                return;
+
+        if ( yy_current_buffer )
+                {
+                /* Flush out information for old buffer. */
+                *yy_c_buf_p = yy_hold_char;
+                yy_current_buffer->yy_buf_pos = yy_c_buf_p;
+                yy_current_buffer->yy_n_chars = yy_n_chars;
+                }
+
+        yy_current_buffer = new_buffer;
+        yy_load_buffer_state();
+
+        /* We don't actually know whether we did this switch during
+         * EOF (yywrap()) processing, but the only time this flag
+         * is looked at is after yywrap() is called, so it's safe
+         * to go ahead and always set it.
+         */
+        yy_did_buffer_switch_on_eof = 1;
+        }
+
+
+#ifdef YY_USE_PROTOS
+void yy_load_buffer_state( void )
+#else
+void yy_load_buffer_state()
+#endif
+        {
+        yy_n_chars = yy_current_buffer->yy_n_chars;
+        yytext_ptr = yy_c_buf_p = yy_current_buffer->yy_buf_pos;
+        yyin = yy_current_buffer->yy_input_file;
+        yy_hold_char = *yy_c_buf_p;
+        }
+
+
+#ifdef YY_USE_PROTOS
+YY_BUFFER_STATE yy_create_buffer( FILE *file, int size )
+#else
+YY_BUFFER_STATE yy_create_buffer( file, size )
+FILE *file;
+int size;
+#endif
+        {
+        YY_BUFFER_STATE b;
+
+        b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
+        if ( ! b )
+                YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+
+        b->yy_buf_size = size;
+
+        /* yy_ch_buf has to be 2 characters longer than the size given because
+         * we need to put in 2 end-of-buffer characters.
+         */
+        b->yy_ch_buf = (char *) yy_flex_alloc( b->yy_buf_size + 2 );
+        if ( ! b->yy_ch_buf )
+                YY_FATAL_ERROR( "out of dynamic memory in yy_create_buffer()" );
+
+        b->yy_is_our_buffer = 1;
+
+        yy_init_buffer( b, file );
+
+        return b;
+        }
+
+
+#ifdef YY_USE_PROTOS
+void yy_delete_buffer( YY_BUFFER_STATE b )
+#else
+void yy_delete_buffer( b )
+YY_BUFFER_STATE b;
+#endif
+        {
+        if ( ! b )
+                return;
+
+        if ( b == yy_current_buffer )
+                yy_current_buffer = (YY_BUFFER_STATE) 0;
+
+        if ( b->yy_is_our_buffer )
+                yy_flex_free( (void *) b->yy_ch_buf );
+
+        yy_flex_free( (void *) b );
+        }
+
+
+
+#ifdef YY_USE_PROTOS
+void yy_init_buffer( YY_BUFFER_STATE b, FILE *file )
+#else
+void yy_init_buffer( b, file )
+YY_BUFFER_STATE b;
+FILE *file;
+#endif
+
+
+        {
+        yy_flush_buffer( b );
+
+        b->yy_input_file = file;
+        b->yy_fill_buffer = 1;
+
+#if YY_ALWAYS_INTERACTIVE
+        b->yy_is_interactive = 1;
+#else
+#if YY_NEVER_INTERACTIVE
+        b->yy_is_interactive = 0;
+#else
+
+#ifdef _QTWIN_
+        b->yy_is_interactive = file ? (_isatty( fileno(file) ) > 0) : 0;
+#else
+        b->yy_is_interactive = file ? (isatty( fileno(file) ) > 0) : 0;
+#endif
+
+#endif
+#endif
+        }
+
+
+#ifdef YY_USE_PROTOS
+void yy_flush_buffer( YY_BUFFER_STATE b )
+#else
+void yy_flush_buffer( b )
+YY_BUFFER_STATE b;
+#endif
+
+        {
+        if ( ! b )
+                return;
+
+        b->yy_n_chars = 0;
+
+        /* We always need two end-of-buffer characters.  The first causes
+         * a transition to the end-of-buffer state.  The second causes
+         * a jam in that state.
+         */
+        b->yy_ch_buf[0] = YY_END_OF_BUFFER_CHAR;
+        b->yy_ch_buf[1] = YY_END_OF_BUFFER_CHAR;
+
+        b->yy_buf_pos = &b->yy_ch_buf[0];
+
+        b->yy_at_bol = 1;
+        b->yy_buffer_status = YY_BUFFER_NEW;
+
+        if ( b == yy_current_buffer )
+                yy_load_buffer_state();
+        }
+
+
+#ifndef YY_NO_SCAN_BUFFER
+#ifdef YY_USE_PROTOS
+YY_BUFFER_STATE yy_scan_buffer( char *base, yy_size_t size )
+#else
+YY_BUFFER_STATE yy_scan_buffer( base, size )
+char *base;
+yy_size_t size;
+#endif
+        {
+        YY_BUFFER_STATE b;
+
+        if ( size < 2 ||
+             base[size-2] != YY_END_OF_BUFFER_CHAR ||
+             base[size-1] != YY_END_OF_BUFFER_CHAR )
+                /* They forgot to leave room for the EOB's. */
+                return 0;
+
+        b = (YY_BUFFER_STATE) yy_flex_alloc( sizeof( struct yy_buffer_state ) );
+        if ( ! b )
+                YY_FATAL_ERROR( "out of dynamic memory in yy_scan_buffer()" );
+
+                b->yy_buf_size = size - 2;/* "- 2" to take care of EOB's */
+        b->yy_buf_pos = b->yy_ch_buf = base;
+        b->yy_is_our_buffer = 0;
+        b->yy_input_file = 0;
+        b->yy_n_chars = b->yy_buf_size;
+        b->yy_is_interactive = 0;
+        b->yy_at_bol = 1;
+        b->yy_fill_buffer = 0;
+        b->yy_buffer_status = YY_BUFFER_NEW;
+
+        yy_switch_to_buffer( b );
+
+        return b;
+        }
+#endif
+
+
+#ifndef YY_NO_SCAN_STRING
+#ifdef YY_USE_PROTOS
+YY_BUFFER_STATE yy_scan_string( yyconst char *yy_str )
+#else
+YY_BUFFER_STATE yy_scan_string( yy_str )
+yyconst char *yy_str;
+#endif
+        {
+        int len;
+        for ( len = 0; yy_str[len]; ++len )
+                ;
+
+        return yy_scan_bytes( yy_str, len );
+        }
+#endif
+
+
+#ifndef YY_NO_SCAN_BYTES
+#ifdef YY_USE_PROTOS
+YY_BUFFER_STATE yy_scan_bytes( yyconst char *bytes, int len )
+#else
+YY_BUFFER_STATE yy_scan_bytes( bytes, len )
+yyconst char *bytes;
+int len;
+#endif
+        {
+        YY_BUFFER_STATE b;
+        char *buf;
+        yy_size_t n;
+        int i;
+
+        /* Get memory for full buffer, including space for trailing EOB's. */
+        n = len + 2;
+        buf = (char *) yy_flex_alloc( n );
+        if ( ! buf )
+                YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
+
+        for ( i = 0; i < len; ++i )
+                buf[i] = bytes[i];
+
+        buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;
+
+        b = yy_scan_buffer( buf, n );
+        if ( ! b )
+                YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
+
+        /* It's okay to grow etc. this buffer, and we should throw it
+         * away when we're done.
+         */
+        b->yy_is_our_buffer = 1;
+
+        return b;
+        }
+#endif
+
+
+#ifndef YY_NO_PUSH_STATE
+#ifdef YY_USE_PROTOS
+static void yy_push_state( int new_state )
+#else
+static void yy_push_state( new_state )
+int new_state;
+#endif
+        {
+        if ( yy_start_stack_ptr >= yy_start_stack_depth )
+                {
+                yy_size_t new_size;
+
+                yy_start_stack_depth += YY_START_STACK_INCR;
+                new_size = yy_start_stack_depth * sizeof( int );
+
+                if ( ! yy_start_stack )
+                        yy_start_stack = (int *) yy_flex_alloc( new_size );
+
+                else
+                        yy_start_stack = (int *) yy_flex_realloc(
+                                        (void *) yy_start_stack, new_size );
+
+                if ( ! yy_start_stack )
+                        YY_FATAL_ERROR(
+                        "out of memory expanding start-condition stack" );
+                }
+
+        yy_start_stack[yy_start_stack_ptr++] = YY_START;
+
+        BEGIN(new_state);
+        }
+#endif
+
+
+#ifndef YY_NO_POP_STATE
+static void yy_pop_state()
+        {
+        if ( --yy_start_stack_ptr < 0 )
+                YY_FATAL_ERROR( "start-condition stack underflow" );
+
+        BEGIN(yy_start_stack[yy_start_stack_ptr]);
+        }
+#endif
+
+
+#ifndef YY_NO_TOP_STATE
+static int yy_top_state()
+        {
+        return yy_start_stack[yy_start_stack_ptr - 1];
+        }
+#endif
+
+#ifndef YY_EXIT_FAILURE
+#define YY_EXIT_FAILURE 2
+#endif
+
+#ifdef YY_USE_PROTOS
+static void yy_fatal_error( yyconst char msg[] )
+#else
+static void yy_fatal_error( msg )
+char msg[];
+#endif
+        {
+        (void) fprintf( stderr, "%s\n", msg );
+        exit( YY_EXIT_FAILURE );
+        }
+
+
+
+/* Redefine yyless() so it works in section 3 code. */
+
+#undef yyless
+#define yyless(n) \
+        do \
+                { \
+                /* Undo effects of setting up yytext. */ \
+                yytext[yyleng] = yy_hold_char; \
+                yy_c_buf_p = yytext + n; \
+                yy_hold_char = *yy_c_buf_p; \
+                *yy_c_buf_p = '\0'; \
+                yyleng = n; \
+                } \
+        while ( 0 )
+
+
+/* Internal utility routines. */
+
+#ifndef yytext_ptr
+#ifdef YY_USE_PROTOS
+static void yy_flex_strncpy( char *s1, yyconst char *s2, int n )
+#else
+static void yy_flex_strncpy( s1, s2, n )
+char *s1;
+yyconst char *s2;
+int n;
+#endif
+        {
+        register int i;
+        for ( i = 0; i < n; ++i )
+                s1[i] = s2[i];
+        }
+#endif
+
+#ifdef YY_NEED_STRLEN
+#ifdef YY_USE_PROTOS
+static int yy_flex_strlen( yyconst char *s )
+#else
+static int yy_flex_strlen( s )
+yyconst char *s;
+#endif
+        {
+        register int n;
+        for ( n = 0; s[n]; ++n )
+                ;
+
+        return n;
+        }
+#endif
+
+
+#ifdef YY_USE_PROTOS
+static void *yy_flex_alloc( yy_size_t size )
+#else
+static void *yy_flex_alloc( size )
+yy_size_t size;
+#endif
+        {
+        return (void *) malloc( size );
+        }
+
+#ifdef YY_USE_PROTOS
+static void *yy_flex_realloc( void *ptr, yy_size_t size )
+#else
+static void *yy_flex_realloc( ptr, size )
+void *ptr;
+yy_size_t size;
+#endif
+        {
+        /* The cast to (char *) in the following accommodates both
+         * implementations that use char* generic pointers, and those
+         * that use void* generic pointers.  It works with the latter
+         * because both ANSI C and C++ allow castless assignment from
+         * any pointer type to void*, and deal with argument conversions
+         * as though doing an assignment.
+         */
+        return (void *) realloc( (char *) ptr, size );
+        }
+
+#ifdef YY_USE_PROTOS
+static void yy_flex_free( void *ptr )
+#else
+static void yy_flex_free( ptr )
+void *ptr;
+#endif
+        {
+        free( ptr );
+        }
+
+#if YY_MAIN
+int main()
+        {
+        yylex();
+        return 0;
+        }
+#endif
+#line 107 "icalsslexer.l"
+
+
+int sswrap()
+{
+     return 1;
+}
+
diff --git a/libical/src/libicalss/icalsslexer.l b/libical/src/libicalss/icalsslexer.l
new file mode 100644
index 0000000..58aa162
--- a/dev/null
+++ b/libical/src/libicalss/icalsslexer.l
@@ -0,0 +1,113 @@
+%{
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: icalsslexer.l
+  CREATOR: eric 8 Aug 2000
+  
+  DESCRIPTION:
+  
+  $Id$
+  $Locker$
+
+(C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+  ======================================================================*/
+
+#include "icalssyacc.h"
+#include "icalgaugeimpl.h"
+#include "assert.h"
+
+#include <string.h> /* For strdup() */
+
+int icalparser_flex_input(char* buf, int max_size);
+void icalparser_clear_flex_input();
+
+#undef YY_INPUT
+#define YY_INPUT(b,r,ms) ( r= icalparser_flex_input(b,ms))
+
+#undef SS_FATAL_ERROR
+#define SS_FATAL_ERROR(msg) sserror(msg)
+
+
+%}
+
+        crlf    \x0D?\x0A
+        space   [ ]
+        qsafechar[^\x00-\x1F\"]
+        safechar[^\x00-\x1F\"\:\;\,]
+        tsafechar[\x20-\x21\x23-\x2B\x2D-\x39\x3C-\x5B\x5D-\x7E]
+        valuechar[^\x00-\x08\x10-\x1F]
+        xname   X-[a-zA-Z0-9\-]+
+xname2          [a-zA-Z0-9\-\ ]
+        paramtext{safechar}+
+        value   {valuechar}+
+        quotedstring\"{qsafechar}+\"
+        digit   [0-9]
+
+%array /* Make yytext an array. Slow, but handy. HACK */
+
+%option caseless
+
+%s sql string_value
+
+
+
+%%
+
+%{
+%}
+
+
+        SELECT          { return SELECT; }
+        FROM            { return FROM; }
+        WHERE           { return WHERE; }
+        ,               { return COMMA; }
+        "="             { return EQUALS; }
+        "!="            { return NOTEQUALS; }
+        "<"             { return LESS; }
+        ">"             { return GREATER; }
+        "<="            { return LESSEQUALS; }
+        ">="            { return GREATEREQUALS; }
+        AND             { return AND; }
+        OR              { return OR; }
+\'                      { return QUOTE; }
+        [ \t\n\r]+ ;            
+        ;               { return EOL; }
+\'[\*A-Za-z0-9\-\.]+\' {
+        int c = input();
+        unput(c);
+        if(c!='\''){
+                sslval.v_string= icalmemory_tmp_copy(sstext);
+                return STRING;
+        } else {
+                /*ssmore();*/
+        }
+}
+
+        [\*A-Za-z0-9\-\.]+      { sslval.v_string= icalmemory_tmp_copy(sstext);
+                          return STRING; }
+
+
+        .               { return yytext[0]; }
+
+%% 
+
+int sswrap()
+{
+     return 1;
+}
+
diff --git a/libical/src/libicalss/icalssyacc.c b/libical/src/libicalss/icalssyacc.c
new file mode 100644
index 0000000..943123e
--- a/dev/null
+++ b/libical/src/libicalss/icalssyacc.c
@@ -0,0 +1,1381 @@
+/* A Bison parser, made from icalssyacc.y
+   by GNU bison 1.35.  */
+
+#define YYBISON 1  /* Identify Bison output.  */
+
+#define yyparse ssparse
+#define yylex sslex
+#define yyerror sserror
+#define yylval sslval
+#define yychar sschar
+#define yydebug ssdebug
+#define yynerrs ssnerrs
+        # define        STRING257
+        # define        SELECT258
+        # define        FROM259
+        # define        WHERE260
+        # define        COMMA261
+        # define        QUOTE262
+        # define        EQUALS263
+        # define        NOTEQUALS264
+        # define        LESS265
+        # define        GREATER266
+        # define        LESSEQUALS267
+        # define        GREATEREQUALS268
+        # define        AND269
+        # define        OR270
+        # define        EOL271
+        # define        END272
+
+#line 1 "icalssyacc.y"
+
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: icalssyacc.y
+  CREATOR: eric 08 Aug 2000
+  
+  DESCRIPTION:
+  
+  $Id$
+  $Locker$
+
+(C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+  ======================================================================*/
+
+#include <stdlib.h>
+#include <string.h> /* for strdup() */
+#include <limits.h> /* for SHRT_MAX*/
+#include "ical.h"
+#include "pvl.h"
+#include "icalgauge.h"
+#include "icalgaugeimpl.h"
+
+
+extern struct icalgauge_impl *icalss_yy_gauge;
+
+void ssyacc_add_where(struct icalgauge_impl* impl, char* prop, 
+        icalgaugecompare compare , char* value);
+void ssyacc_add_select(struct icalgauge_impl* impl, char* str1);
+void ssyacc_add_from(struct icalgauge_impl* impl, char* str1);
+void set_logic(struct icalgauge_impl* impl,icalgaugelogic l);
+void sserror(char *s); /* Don't know why I need this.... */
+
+
+
+
+#line 52 "icalssyacc.y"
+#ifndef YYSTYPE
+typedef union {
+        char* v_string;
+} yystype;
+# define YYSTYPE yystype
+# define YYSTYPE_IS_TRIVIAL 1
+#endif
+#ifndef YYDEBUG
+# define YYDEBUG 0
+#endif
+
+
+
+        #define         YYFINAL         34
+        #define         YYFLAG  -32768
+        #define         YYNTBASE19
+
+/* YYTRANSLATE(YYLEX) -- Bison token number corresponding to YYLEX. */
+#define YYTRANSLATE(x) ((unsigned)(x) <= 272 ? yytranslate[x] : 24)
+
+/* YYTRANSLATE[YYLEX] -- Bison token number corresponding to YYLEX. */
+static const char yytranslate[] =
+{
+       0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
+       2,     2,     2,     2,     2,     2,     1,     3,     4,     5,
+       6,     7,     8,     9,    10,    11,    12,    13,    14,    15,
+      16,    17,    18
+};
+
+#if YYDEBUG
+static const short yyprhs[] =
+{
+       0,     0,     7,     9,    11,    15,    17,    21,    22,    26,
+      30,    34,    38,    42,    46,    48,    52
+};
+static const short yyrhs[] =
+{
+       4,    20,     5,    21,     6,    23,     0,     1,     0,     3,
+       0,    20,     7,     3,     0,     3,     0,    21,     7,     3,
+       0,     0,     3,     9,     3,     0,     3,    10,     3,     0,
+       3,    11,     3,     0,     3,    12,     3,     0,     3,    13,
+       3,     0,     3,    14,     3,     0,    22,     0,    23,    15,
+      22,     0,    23,    16,    22,     0
+};
+
+#endif
+
+#if YYDEBUG
+/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
+static const short yyrline[] =
+{
+       0,    63,    64,    70,    72,    76,    78,    81,    83,    85,
+      86,    87,    88,    89,    92,    94,    95
+};
+#endif
+
+
+#if (YYDEBUG) || defined YYERROR_VERBOSE
+
+/* YYTNAME[TOKEN_NUM] -- String name of the token TOKEN_NUM. */
+static const char *const yytname[] =
+{
+  "$", "error", "$undefined.", "STRING", "SELECT", "FROM", "WHERE", "COMMA", 
+  "QUOTE", "EQUALS", "NOTEQUALS", "LESS", "GREATER", "LESSEQUALS", 
+  "GREATEREQUALS", "AND", "OR", "EOL", "END", "query_min", "select_list", 
+  "from_list", "where_clause", "where_list", 0
+};
+#endif
+
+/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
+static const short yyr1[] =
+{
+       0,    19,    19,    20,    20,    21,    21,    22,    22,    22,
+      22,    22,    22,    22,    23,    23,    23
+};
+
+/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
+static const short yyr2[] =
+{
+       0,     6,     1,     1,     3,     1,     3,     0,     3,     3,
+       3,     3,     3,     3,     1,     3,     3
+};
+
+/* YYDEFACT[S] -- default rule to reduce with in state S when YYTABLE
+   doesn't specify something else to do.  Zero means the default is an
+   error. */
+static const short yydefact[] =
+{
+       0,     2,     0,     3,     0,     0,     0,     5,     0,     4,
+       7,     0,     0,    14,     1,     6,     0,     0,     0,     0,
+       0,     0,     7,     7,     8,     9,    10,    11,    12,    13,
+      15,    16,     0,     0,     0
+};
+
+static const short yydefgoto[] =
+{
+      32,     4,     8,    13,    14
+};
+
+static const short yypact[] =
+{
+       5,-32768,     4,-32768,     3,     8,    15,-32768,     6,-32768,
+      16,    17,    -9,-32768,    -1,-32768,    18,    19,    20,    21,
+      22,    23,    16,    16,-32768,-32768,-32768,-32768,-32768,-32768,
+  -32768,-32768,    27,    28,-32768
+};
+
+static const short yypgoto[] =
+{
+  -32768,-32768,-32768,    -6,-32768
+};
+
+
+        #define         YYLAST  28
+
+
+static const short yytable[] =
+{
+      16,    17,    18,    19,    20,    21,     1,     3,     5,     2,
+       6,     7,    10,    11,    22,    23,    30,    31,     9,    12,
+      15,    24,    25,    26,    27,    28,    29,    33,    34
+};
+
+static const short yycheck[] =
+{
+       9,    10,    11,    12,    13,    14,     1,     3,     5,     4,
+       7,     3,     6,     7,    15,    16,    22,    23,     3,     3,
+       3,     3,     3,     3,     3,     3,     3,     0,     0
+};
+/* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
+#line 3 "/usr/share/bison/bison.simple"
+
+/* Skeleton output parser for bison,
+
+   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002 Free Software
+   Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+/* As a special exception, when this file is copied by Bison into a
+   Bison output file, you may use that output file without restriction.
+   This special exception was added by the Free Software Foundation
+   in version 1.24 of Bison.  */
+
+/* This is the parser code that is written into each bison parser when
+   the %semantic_parser declaration is not specified in the grammar.
+   It was written by Richard Stallman by simplifying the hairy parser
+   used when %semantic_parser is specified.  */
+
+/* All symbols defined below should begin with yy or YY, to avoid
+   infringing on user name space.  This should be done even for local
+   variables, as they might otherwise be expanded by user macros.
+   There are some unavoidable exceptions within include files to
+   define necessary library symbols; they are noted "INFRINGES ON
+   USER NAME SPACE" below.  */
+
+#if ! defined (yyoverflow) || defined (YYERROR_VERBOSE)
+
+/* The parser invokes alloca or malloc; define the necessary symbols.  */
+
+# if YYSTACK_USE_ALLOCA
+#  define YYSTACK_ALLOC alloca
+# else
+#  ifndef YYSTACK_USE_ALLOCA
+#   if defined (alloca) || defined (_ALLOCA_H)
+#    define YYSTACK_ALLOC alloca
+#   else
+#    ifdef __GNUC__
+#     define YYSTACK_ALLOC __builtin_alloca
+#    endif
+#   endif
+#  endif
+# endif
+
+# ifdef YYSTACK_ALLOC
+   /* Pacify GCC's `empty if-body' warning. */
+#  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
+# else
+#  if defined (__STDC__) || defined (__cplusplus)
+#   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
+#   define YYSIZE_T size_t
+#  endif
+#  define YYSTACK_ALLOC malloc
+#  define YYSTACK_FREE free
+# endif
+#endif /* ! defined (yyoverflow) || defined (YYERROR_VERBOSE) */
+
+
+#if (! defined (yyoverflow) \
+     && (! defined (__cplusplus) \
+         || (YYLTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
+
+/* A type that is properly aligned for any stack member.  */
+union yyalloc
+{
+  short yyss;
+  YYSTYPE yyvs;
+# if YYLSP_NEEDED
+  YYLTYPE yyls;
+# endif
+};
+
+/* The size of the maximum gap between one aligned stack and the next.  */
+# define YYSTACK_GAP_MAX (sizeof (union yyalloc) - 1)
+
+/* The size of an array large to enough to hold all stacks, each with
+   N elements.  */
+# if YYLSP_NEEDED
+#  define YYSTACK_BYTES(N) \
+             ((N) * (sizeof (short) + sizeof (YYSTYPE) + sizeof (YYLTYPE))\
+      + 2 * YYSTACK_GAP_MAX)
+# else
+#  define YYSTACK_BYTES(N) \
+             ((N) * (sizeof (short) + sizeof (YYSTYPE))                         \
+      + YYSTACK_GAP_MAX)
+# endif
+
+/* Copy COUNT objects from FROM to TO.  The source and destination do
+   not overlap.  */
+# ifndef YYCOPY
+#  if 1 < __GNUC__
+#   define YYCOPY(To, From, Count) \
+      __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
+#  else
+        #   define YYCOPY(To, From, Count)      \
+              do                                \
+                {                               \
+                  register YYSIZE_T yyi;        \
+                  for (yyi = 0; yyi < (Count); yyi++)\
+                    (To)[yyi] = (From)[yyi];    \
+                }                               \
+      while (0)
+#  endif
+# endif
+
+/* Relocate STACK from its old location to the new one.  The
+   local variables YYSIZE and YYSTACKSIZE give the old and new number of
+   elements in the stack, and YYPTR gives the new location of the
+   stack.  Advance YYPTR to a properly aligned location for the next
+   stack.  */
+        # define YYSTACK_RELOCATE(Stack)                                \
+            do                                                          \
+              {                                                                 \
+                YYSIZE_T yynewbytes;                                    \
+                YYCOPY (&yyptr->Stack, Stack, yysize);                  \
+                Stack = &yyptr->Stack;                                  \
+                yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAX;\
+                yyptr += yynewbytes / sizeof (*yyptr);                  \
+              }                                                                 \
+    while (0)
+
+#endif
+
+
+#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
+# define YYSIZE_T __SIZE_TYPE__
+#endif
+#if ! defined (YYSIZE_T) && defined (size_t)
+# define YYSIZE_T size_t
+#endif
+#if ! defined (YYSIZE_T)
+# if defined (__STDC__) || defined (__cplusplus)
+#  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
+#  define YYSIZE_T size_t
+# endif
+#endif
+#if ! defined (YYSIZE_T)
+# define YYSIZE_T unsigned int
+#endif
+
+        #define yyerrok         (yyerrstatus = 0)
+        #define yyclearin(yychar = YYEMPTY)
+        #define YYEMPTY         -2
+        #define YYEOF   0
+        #define YYACCEPTgoto yyacceptlab
+        #define YYABORT goto yyabortlab
+        #define YYERROR         goto yyerrlab1
+/* Like YYERROR except do call yyerror.  This remains here temporarily
+   to ease the transition to the new meaning of YYERROR, for GCC.
+   Once GCC version 2 has supplanted version 1, this can go.  */
+        #define YYFAIL  goto yyerrlab
+#define YYRECOVERING()  (!!yyerrstatus)
+        #define YYBACKUP(Token, Value)                          \
+        do                                                      \
+          if (yychar == YYEMPTY && yylen == 1)                  \
+            {                                                   \
+              yychar = (Token);                                         \
+              yylval = (Value);                                         \
+              yychar1 = YYTRANSLATE (yychar);                   \
+              YYPOPSTACK;                                       \
+              goto yybackup;                                    \
+            }                                                   \
+          else                                                  \
+            {                                                   \
+              yyerror ("syntax error: cannot back up");                 \
+              YYERROR;                                          \
+            }                                                   \
+while (0)
+
+        #define YYTERROR1
+        #define YYERRCODE256
+
+
+/* YYLLOC_DEFAULT -- Compute the default location (before the actions
+   are run).
+
+   When YYLLOC_DEFAULT is run, CURRENT is set the location of the
+   first token.  By default, to implement support for ranges, extend
+   its range to the last symbol.  */
+
+#ifndef YYLLOC_DEFAULT
+        # define YYLLOC_DEFAULT(Current, Rhs, N)       \
+           Current.last_line   = Rhs[N].last_line;\
+   Current.last_column = Rhs[N].last_column;
+#endif
+
+
+/* YYLEX -- calling `yylex' with the right arguments.  */
+
+#if YYPURE
+# if YYLSP_NEEDED
+#  ifdef YYLEX_PARAM
+        #   define YYLEX        yylex (&yylval, &yylloc, YYLEX_PARAM)
+#  else
+        #   define YYLEX        yylex (&yylval, &yylloc)
+#  endif
+# else /* !YYLSP_NEEDED */
+#  ifdef YYLEX_PARAM
+        #   define YYLEX        yylex (&yylval, YYLEX_PARAM)
+#  else
+        #   define YYLEX        yylex (&yylval)
+#  endif
+# endif /* !YYLSP_NEEDED */
+#else /* !YYPURE */
+        # define YYLEX          yylex ()
+#endif /* !YYPURE */
+
+
+/* Enable debugging if requested.  */
+#if YYDEBUG
+
+# ifndef YYFPRINTF
+#  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
+#  define YYFPRINTF fprintf
+# endif
+
+        # define YYDPRINTF(Args)                \
+        do {                                    \
+          if (yydebug)                          \
+            YYFPRINTF Args;                     \
+} while (0)
+/* Nonzero means print parse trace.  It is left uninitialized so that
+   multiple parsers can coexist.  */
+int yydebug;
+#else /* !YYDEBUG */
+# define YYDPRINTF(Args)
+#endif /* !YYDEBUG */
+
+/* YYINITDEPTH -- initial size of the parser's stacks.  */
+        #ifndefYYINITDEPTH
+# define YYINITDEPTH 200
+#endif
+
+/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
+   if the built-in stack extension method is used).
+
+   Do not make this value too large; the results are undefined if
+   SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
+   evaluated with infinite-precision integer arithmetic.  */
+
+#if YYMAXDEPTH == 0
+# undef YYMAXDEPTH
+#endif
+
+#ifndef YYMAXDEPTH
+# define YYMAXDEPTH 10000
+#endif
+
+#ifdef YYERROR_VERBOSE
+
+# ifndef yystrlen
+#  if defined (__GLIBC__) && defined (_STRING_H)
+#   define yystrlen strlen
+#  else
+/* Return the length of YYSTR.  */
+static YYSIZE_T
+#   if defined (__STDC__) || defined (__cplusplus)
+yystrlen (const char *yystr)
+#   else
+yystrlen (yystr)
+     const char *yystr;
+#   endif
+{
+  register const char *yys = yystr;
+
+  while (*yys++ != '\0')
+    continue;
+
+  return yys - yystr - 1;
+}
+#  endif
+# endif
+
+# ifndef yystpcpy
+#  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
+#   define yystpcpy stpcpy
+#  else
+/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
+   YYDEST.  */
+static char *
+#   if defined (__STDC__) || defined (__cplusplus)
+yystpcpy (char *yydest, const char *yysrc)
+#   else
+yystpcpy (yydest, yysrc)
+     char *yydest;
+     const char *yysrc;
+#   endif
+{
+  register char *yyd = yydest;
+  register const char *yys = yysrc;
+
+  while ((*yyd++ = *yys++) != '\0')
+    continue;
+
+  return yyd - 1;
+}
+#  endif
+# endif
+#endif
+
+#line 315 "/usr/share/bison/bison.simple"
+
+
+/* The user can define YYPARSE_PARAM as the name of an argument to be passed
+   into yyparse.  The argument should have type void *.
+   It should actually point to an object.
+   Grammar actions can access the variable by casting it
+   to the proper pointer type.  */
+
+#ifdef YYPARSE_PARAM
+# if defined (__STDC__) || defined (__cplusplus)
+#  define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
+#  define YYPARSE_PARAM_DECL
+# else
+#  define YYPARSE_PARAM_ARG YYPARSE_PARAM
+#  define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
+# endif
+#else /* !YYPARSE_PARAM */
+# define YYPARSE_PARAM_ARG
+# define YYPARSE_PARAM_DECL
+#endif /* !YYPARSE_PARAM */
+
+/* Prevent warning if -Wstrict-prototypes.  */
+#ifdef __GNUC__
+# ifdef YYPARSE_PARAM
+int yyparse (void *);
+# else
+int yyparse (void);
+# endif
+#endif
+
+/* YY_DECL_VARIABLES -- depending whether we use a pure parser,
+   variables are global, or local to YYPARSE.  */
+
+        #define YY_DECL_NON_LSP_VARIABLES               \
+        /* The lookahead symbol.  */                    \
+        int yychar;                                     \
+                                                        \
+        /* The semantic value of the lookahead symbol. */\
+        YYSTYPE yylval;                                         \
+                                                        \
+        /* Number of parse errors so far.  */           \
+int yynerrs;
+
+#if YYLSP_NEEDED
+        # define YY_DECL_VARIABLES              \
+        YY_DECL_NON_LSP_VARIABLES               \
+                                                \
+        /* Location data for the lookahead symbol.  */\
+YYLTYPE yylloc;
+#else
+        # define YY_DECL_VARIABLES              \
+YY_DECL_NON_LSP_VARIABLES
+#endif
+
+
+/* If nonreentrant, generate the variables here. */
+
+#if !YYPURE
+YY_DECL_VARIABLES
+#endif  /* !YYPURE */
+
+int
+yyparse (YYPARSE_PARAM_ARG)
+     YYPARSE_PARAM_DECL
+{
+  /* If reentrant, generate the variables here. */
+#if YYPURE
+  YY_DECL_VARIABLES
+#endif  /* !YYPURE */
+
+  register int yystate;
+  register int yyn;
+  int yyresult;
+  /* Number of tokens to shift before error messages enabled.  */
+  int yyerrstatus;
+  /* Lookahead token as an internal (translated) token number.  */
+  int yychar1 = 0;
+
+  /* Three stacks and their tools:
+     `yyss': related to states,
+     `yyvs': related to semantic values,
+     `yyls': related to locations.
+
+     Refer to the stacks thru separate pointers, to allow yyoverflow
+     to reallocate them elsewhere.  */
+
+  /* The state stack. */
+          shortyyssa[YYINITDEPTH];
+  short *yyss = yyssa;
+  register short *yyssp;
+
+  /* The semantic value stack.  */
+  YYSTYPE yyvsa[YYINITDEPTH];
+  YYSTYPE *yyvs = yyvsa;
+  register YYSTYPE *yyvsp;
+
+#if YYLSP_NEEDED
+  /* The location stack.  */
+  YYLTYPE yylsa[YYINITDEPTH];
+  YYLTYPE *yyls = yylsa;
+  YYLTYPE *yylsp;
+#endif
+
+#if YYLSP_NEEDED
+# define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
+#else
+# define YYPOPSTACK   (yyvsp--, yyssp--)
+#endif
+
+  YYSIZE_T yystacksize = YYINITDEPTH;
+
+
+  /* The variables used to return semantic value and location from the
+     action routines.  */
+  YYSTYPE yyval;
+#if YYLSP_NEEDED
+  YYLTYPE yyloc;
+#endif
+
+  /* When reducing, the number of symbols on the RHS of the reduced
+     rule. */
+  int yylen;
+
+  YYDPRINTF ((stderr, "Starting parse\n"));
+
+  yystate = 0;
+  yyerrstatus = 0;
+  yynerrs = 0;
+          yychar = YYEMPTY;     /* Cause a token to be read.  */
+
+  /* Initialize stack pointers.
+     Waste one element of value and location stack
+     so that they stay on the same level as the state stack.
+     The wasted elements are never initialized.  */
+
+  yyssp = yyss;
+  yyvsp = yyvs;
+#if YYLSP_NEEDED
+  yylsp = yyls;
+#endif
+  goto yysetstate;
+
+/*------------------------------------------------------------.
+| yynewstate -- Push a new state, which is found in yystate.  |
+`------------------------------------------------------------*/
+ yynewstate:
+  /* In all cases, when you get here, the value and location stacks
+     have just been pushed. so pushing a state here evens the stacks.
+     */
+  yyssp++;
+
+ yysetstate:
+  *yyssp = yystate;
+
+  if (yyssp >= yyss + yystacksize - 1)
+    {
+      /* Get the current used size of the three stacks, in elements.  */
+      YYSIZE_T yysize = yyssp - yyss + 1;
+
+#ifdef yyoverflow
+      {
+        /* Give user a chance to reallocate the stack. Use copies of
+           these so that the &'s don't force the real ones into
+           memory.  */
+        YYSTYPE *yyvs1 = yyvs;
+        short *yyss1 = yyss;
+
+        /* Each stack pointer address is followed by the size of the
+           data in use in that stack, in bytes.  */
+# if YYLSP_NEEDED
+        YYLTYPE *yyls1 = yyls;
+        /* This used to be a conditional around just the two extra args,
+           but that might be undefined if yyoverflow is a macro.  */
+        yyoverflow ("parser stack overflow",
+                    &yyss1, yysize * sizeof (*yyssp),
+                    &yyvs1, yysize * sizeof (*yyvsp),
+                    &yyls1, yysize * sizeof (*yylsp),
+                    &yystacksize);
+        yyls = yyls1;
+# else
+        yyoverflow ("parser stack overflow",
+                    &yyss1, yysize * sizeof (*yyssp),
+                    &yyvs1, yysize * sizeof (*yyvsp),
+                    &yystacksize);
+# endif
+        yyss = yyss1;
+        yyvs = yyvs1;
+      }
+#else /* no yyoverflow */
+# ifndef YYSTACK_RELOCATE
+      goto yyoverflowlab;
+# else
+      /* Extend the stack our own way.  */
+      if (yystacksize >= YYMAXDEPTH)
+        goto yyoverflowlab;
+      yystacksize *= 2;
+      if (yystacksize > YYMAXDEPTH)
+        yystacksize = YYMAXDEPTH;
+
+      {
+        short *yyss1 = yyss;
+        union yyalloc *yyptr =
+          (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
+        if (! yyptr)
+          goto yyoverflowlab;
+        YYSTACK_RELOCATE (yyss);
+        YYSTACK_RELOCATE (yyvs);
+# if YYLSP_NEEDED
+        YYSTACK_RELOCATE (yyls);
+# endif
+# undef YYSTACK_RELOCATE
+        if (yyss1 != yyssa)
+          YYSTACK_FREE (yyss1);
+      }
+# endif
+#endif /* no yyoverflow */
+
+      yyssp = yyss + yysize - 1;
+      yyvsp = yyvs + yysize - 1;
+#if YYLSP_NEEDED
+      yylsp = yyls + yysize - 1;
+#endif
+
+      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
+                  (unsigned long int) yystacksize));
+
+      if (yyssp >= yyss + yystacksize - 1)
+        YYABORT;
+    }
+
+  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
+
+  goto yybackup;
+
+
+/*-----------.
+| yybackup.  |
+`-----------*/
+yybackup:
+
+/* Do appropriate processing given the current state.  */
+/* Read a lookahead token if we need one and don't already have one.  */
+/* yyresume: */
+
+  /* First try to decide what to do without reference to lookahead token.  */
+
+  yyn = yypact[yystate];
+  if (yyn == YYFLAG)
+    goto yydefault;
+
+  /* Not known => get a lookahead token if don't already have one.  */
+
+  /* yychar is either YYEMPTY or YYEOF
+     or a valid token in external form.  */
+
+  if (yychar == YYEMPTY)
+    {
+      YYDPRINTF ((stderr, "Reading a token: "));
+      yychar = YYLEX;
+    }
+
+  /* Convert token to internal form (in yychar1) for indexing tables with */
+
+          if (yychar <= 0)      /* This means end of input. */
+    {
+      yychar1 = 0;
+              yychar = YYEOF;   /* Don't call YYLEX any more */
+
+      YYDPRINTF ((stderr, "Now at end of input.\n"));
+    }
+  else
+    {
+      yychar1 = YYTRANSLATE (yychar);
+
+#if YYDEBUG
+     /* We have to keep this `#if YYDEBUG', since we use variables
+        which are defined only if `YYDEBUG' is set.  */
+      if (yydebug)
+        {
+          YYFPRINTF (stderr, "Next token is %d (%s",
+                     yychar, yytname[yychar1]);
+          /* Give the individual parser a way to print the precise
+             meaning of a token, for further debugging info.  */
+# ifdef YYPRINT
+          YYPRINT (stderr, yychar, yylval);
+# endif
+          YYFPRINTF (stderr, ")\n");
+        }
+#endif
+    }
+
+  yyn += yychar1;
+  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
+    goto yydefault;
+
+  yyn = yytable[yyn];
+
+  /* yyn is what to do for this token type in this state.
+     Negative => reduce, -yyn is rule number.
+     Positive => shift, yyn is new state.
+       New state is final state => don't bother to shift,
+       just return success.
+     0, or most negative number => error.  */
+
+  if (yyn < 0)
+    {
+      if (yyn == YYFLAG)
+        goto yyerrlab;
+      yyn = -yyn;
+      goto yyreduce;
+    }
+  else if (yyn == 0)
+    goto yyerrlab;
+
+  if (yyn == YYFINAL)
+    YYACCEPT;
+
+  /* Shift the lookahead token.  */
+  YYDPRINTF ((stderr, "Shifting token %d (%s), ",
+              yychar, yytname[yychar1]));
+
+  /* Discard the token being shifted unless it is eof.  */
+  if (yychar != YYEOF)
+    yychar = YYEMPTY;
+
+  *++yyvsp = yylval;
+#if YYLSP_NEEDED
+  *++yylsp = yylloc;
+#endif
+
+  /* Count tokens shifted since error; after three, turn off error
+     status.  */
+  if (yyerrstatus)
+    yyerrstatus--;
+
+  yystate = yyn;
+  goto yynewstate;
+
+
+/*-----------------------------------------------------------.
+| yydefault -- do the default action for the current state.  |
+`-----------------------------------------------------------*/
+yydefault:
+  yyn = yydefact[yystate];
+  if (yyn == 0)
+    goto yyerrlab;
+  goto yyreduce;
+
+
+/*-----------------------------.
+| yyreduce -- Do a reduction.  |
+`-----------------------------*/
+yyreduce:
+  /* yyn is the number of a rule to reduce with.  */
+  yylen = yyr2[yyn];
+
+  /* If YYLEN is nonzero, implement the default value of the action:
+     `$$ = $1'.
+
+     Otherwise, the following line sets YYVAL to the semantic value of
+     the lookahead token.  This behavior is undocumented and Bison
+     users should not rely upon it.  Assigning to YYVAL
+     unconditionally makes the parser a bit smaller, and it avoids a
+     GCC warning that YYVAL may be used uninitialized.  */
+  yyval = yyvsp[1-yylen];
+
+#if YYLSP_NEEDED
+  /* Similarly for the default location.  Let the user run additional
+     commands if for instance locations are ranges.  */
+  yyloc = yylsp[1-yylen];
+  YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
+#endif
+
+#if YYDEBUG
+  /* We have to keep this `#if YYDEBUG', since we use variables which
+     are defined only if `YYDEBUG' is set.  */
+  if (yydebug)
+    {
+      int yyi;
+
+      YYFPRINTF (stderr, "Reducing via rule %d (line %d), ",
+                 yyn, yyrline[yyn]);
+
+      /* Print the symbols being reduced, and their result.  */
+      for (yyi = yyprhs[yyn]; yyrhs[yyi] > 0; yyi++)
+        YYFPRINTF (stderr, "%s ", yytname[yyrhs[yyi]]);
+      YYFPRINTF (stderr, " -> %s\n", yytname[yyr1[yyn]]);
+    }
+#endif
+
+  switch (yyn) {
+
+case 2:
+#line 64 "icalssyacc.y"
+{ 
+                 icalparser_clear_flex_input();
+                 yyclearin;
+           }
+    break;
+case 3:
+#line 71 "icalssyacc.y"
+{ssyacc_add_select(icalss_yy_gauge,yyvsp[0].v_string);}
+    break;
+case 4:
+#line 72 "icalssyacc.y"
+{ssyacc_add_select(icalss_yy_gauge,yyvsp[0].v_string);}
+    break;
+case 5:
+#line 77 "icalssyacc.y"
+{ssyacc_add_from(icalss_yy_gauge,yyvsp[0].v_string);}
+    break;
+case 6:
+#line 78 "icalssyacc.y"
+{ssyacc_add_from(icalss_yy_gauge,yyvsp[0].v_string);}
+    break;
+case 8:
+#line 83 "icalssyacc.y"
+{ssyacc_add_where(icalss_yy_gauge,yyvsp[-2].v_string,ICALGAUGECOMPARE_EQUAL,yyvsp[0].v_string); }
+    break;
+case 9:
+#line 85 "icalssyacc.y"
+{ssyacc_add_where(icalss_yy_gauge,yyvsp[-2].v_string,ICALGAUGECOMPARE_NOTEQUAL,yyvsp[0].v_string); }
+    break;
+case 10:
+#line 86 "icalssyacc.y"
+{ssyacc_add_where(icalss_yy_gauge,yyvsp[-2].v_string,ICALGAUGECOMPARE_LESS,yyvsp[0].v_string); }
+    break;
+case 11:
+#line 87 "icalssyacc.y"
+{ssyacc_add_where(icalss_yy_gauge,yyvsp[-2].v_string,ICALGAUGECOMPARE_GREATER,yyvsp[0].v_string); }
+    break;
+case 12:
+#line 88 "icalssyacc.y"
+{ssyacc_add_where(icalss_yy_gauge,yyvsp[-2].v_string,ICALGAUGECOMPARE_LESSEQUAL,yyvsp[0].v_string); }
+    break;
+case 13:
+#line 89 "icalssyacc.y"
+{ssyacc_add_where(icalss_yy_gauge,yyvsp[-2].v_string,ICALGAUGECOMPARE_GREATEREQUAL,yyvsp[0].v_string); }
+    break;
+case 14:
+#line 93 "icalssyacc.y"
+{set_logic(icalss_yy_gauge,ICALGAUGELOGIC_NONE);}
+    break;
+case 15:
+#line 94 "icalssyacc.y"
+{set_logic(icalss_yy_gauge,ICALGAUGELOGIC_AND);}
+    break;
+case 16:
+#line 95 "icalssyacc.y"
+{set_logic(icalss_yy_gauge,ICALGAUGELOGIC_OR);}
+    break;
+}
+
+#line 705 "/usr/share/bison/bison.simple"
+
+
+  yyvsp -= yylen;
+  yyssp -= yylen;
+#if YYLSP_NEEDED
+  yylsp -= yylen;
+#endif
+
+#if YYDEBUG
+  if (yydebug)
+    {
+      short *yyssp1 = yyss - 1;
+      YYFPRINTF (stderr, "state stack now");
+      while (yyssp1 != yyssp)
+        YYFPRINTF (stderr, " %d", *++yyssp1);
+      YYFPRINTF (stderr, "\n");
+    }
+#endif
+
+  *++yyvsp = yyval;
+#if YYLSP_NEEDED
+  *++yylsp = yyloc;
+#endif
+
+  /* Now `shift' the result of the reduction.  Determine what state
+     that goes to, based on the state we popped back to and the rule
+     number reduced by.  */
+
+  yyn = yyr1[yyn];
+
+  yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
+  if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
+    yystate = yytable[yystate];
+  else
+    yystate = yydefgoto[yyn - YYNTBASE];
+
+  goto yynewstate;
+
+
+/*------------------------------------.
+| yyerrlab -- here on detecting error |
+`------------------------------------*/
+yyerrlab:
+  /* If not already recovering from an error, report this error.  */
+  if (!yyerrstatus)
+    {
+      ++yynerrs;
+
+#ifdef YYERROR_VERBOSE
+      yyn = yypact[yystate];
+
+      if (yyn > YYFLAG && yyn < YYLAST)
+        {
+          YYSIZE_T yysize = 0;
+          char *yymsg;
+          int yyx, yycount;
+
+          yycount = 0;
+          /* Start YYX at -YYN if negative to avoid negative indexes in
+             YYCHECK.  */
+          for (yyx = yyn < 0 ? -yyn : 0;
+               yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
+            if (yycheck[yyx + yyn] == yyx)
+              yysize += yystrlen (yytname[yyx]) + 15, yycount++;
+          yysize += yystrlen ("parse error, unexpected ") + 1;
+          yysize += yystrlen (yytname[YYTRANSLATE (yychar)]);
+          yymsg = (char *) YYSTACK_ALLOC (yysize);
+          if (yymsg != 0)
+            {
+              char *yyp = yystpcpy (yymsg, "parse error, unexpected ");
+              yyp = yystpcpy (yyp, yytname[YYTRANSLATE (yychar)]);
+
+              if (yycount < 5)
+                {
+                  yycount = 0;
+                  for (yyx = yyn < 0 ? -yyn : 0;
+                       yyx < (int) (sizeof (yytname) / sizeof (char *));
+                       yyx++)
+                    if (yycheck[yyx + yyn] == yyx)
+                      {
+                        const char *yyq = ! yycount ? ", expecting " : " or ";
+                        yyp = yystpcpy (yyp, yyq);
+                        yyp = yystpcpy (yyp, yytname[yyx]);
+                        yycount++;
+                      }
+                }
+              yyerror (yymsg);
+              YYSTACK_FREE (yymsg);
+            }
+          else
+            yyerror ("parse error; also virtual memory exhausted");
+        }
+      else
+#endif /* defined (YYERROR_VERBOSE) */
+        yyerror ("parse error");
+    }
+  goto yyerrlab1;
+
+
+/*--------------------------------------------------.
+| yyerrlab1 -- error raised explicitly by an action |
+`--------------------------------------------------*/
+yyerrlab1:
+  if (yyerrstatus == 3)
+    {
+      /* If just tried and failed to reuse lookahead token after an
+         error, discard it.  */
+
+      /* return failure if at end of input */
+      if (yychar == YYEOF)
+        YYABORT;
+      YYDPRINTF ((stderr, "Discarding token %d (%s).\n",
+                  yychar, yytname[yychar1]));
+      yychar = YYEMPTY;
+    }
+
+  /* Else will try to reuse lookahead token after shifting the error
+     token.  */
+
+          yyerrstatus = 3;      /* Each real token shifted decrements this */
+
+  goto yyerrhandle;
+
+
+/*-------------------------------------------------------------------.
+| yyerrdefault -- current state does not do anything special for the |
+| error token.                                                       |
+`-------------------------------------------------------------------*/
+yyerrdefault:
+#if 0
+  /* This is wrong; only states that explicitly want error tokens
+     should shift them.  */
+
+  /* If its default is to accept any token, ok.  Otherwise pop it.  */
+  yyn = yydefact[yystate];
+  if (yyn)
+    goto yydefault;
+#endif
+
+
+/*---------------------------------------------------------------.
+| yyerrpop -- pop the current state because it cannot handle the |
+| error token                                                    |
+`---------------------------------------------------------------*/
+yyerrpop:
+  if (yyssp == yyss)
+    YYABORT;
+  yyvsp--;
+  yystate = *--yyssp;
+#if YYLSP_NEEDED
+  yylsp--;
+#endif
+
+#if YYDEBUG
+  if (yydebug)
+    {
+      short *yyssp1 = yyss - 1;
+      YYFPRINTF (stderr, "Error: state stack now");
+      while (yyssp1 != yyssp)
+        YYFPRINTF (stderr, " %d", *++yyssp1);
+      YYFPRINTF (stderr, "\n");
+    }
+#endif
+
+/*--------------.
+| yyerrhandle.  |
+`--------------*/
+yyerrhandle:
+  yyn = yypact[yystate];
+  if (yyn == YYFLAG)
+    goto yyerrdefault;
+
+  yyn += YYTERROR;
+  if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
+    goto yyerrdefault;
+
+  yyn = yytable[yyn];
+  if (yyn < 0)
+    {
+      if (yyn == YYFLAG)
+        goto yyerrpop;
+      yyn = -yyn;
+      goto yyreduce;
+    }
+  else if (yyn == 0)
+    goto yyerrpop;
+
+  if (yyn == YYFINAL)
+    YYACCEPT;
+
+  YYDPRINTF ((stderr, "Shifting error token, "));
+
+  *++yyvsp = yylval;
+#if YYLSP_NEEDED
+  *++yylsp = yylloc;
+#endif
+
+  yystate = yyn;
+  goto yynewstate;
+
+
+/*-------------------------------------.
+| yyacceptlab -- YYACCEPT comes here.  |
+`-------------------------------------*/
+yyacceptlab:
+  yyresult = 0;
+  goto yyreturn;
+
+/*-----------------------------------.
+| yyabortlab -- YYABORT comes here.  |
+`-----------------------------------*/
+yyabortlab:
+  yyresult = 1;
+  goto yyreturn;
+
+/*---------------------------------------------.
+| yyoverflowab -- parser overflow comes here.  |
+`---------------------------------------------*/
+yyoverflowlab:
+  yyerror ("parser stack overflow");
+  yyresult = 2;
+  /* Fall through.  */
+
+yyreturn:
+#ifndef yyoverflow
+  if (yyss != yyssa)
+    YYSTACK_FREE (yyss);
+#endif
+  return yyresult;
+}
+#line 99 "icalssyacc.y"
+
+
+void ssyacc_add_where(struct icalgauge_impl* impl, char* str1, 
+        icalgaugecompare compare , char* value_str)
+{
+
+    struct icalgauge_where *where;
+    char *compstr, *propstr, *c, *s,*l;
+    
+    if ( (where = malloc(sizeof(struct icalgauge_where))) ==0){
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        return;
+    }
+
+    memset(where,0,sizeof(struct icalgauge_where));
+    where->logic = ICALGAUGELOGIC_NONE;
+    where->compare = ICALGAUGECOMPARE_NONE;
+    where->comp = ICAL_NO_COMPONENT;
+    where->prop = ICAL_NO_PROPERTY;
+
+    /* remove enclosing quotes */
+    s = value_str;
+    if(*s == '\''){
+        s++;
+    }
+    l = s+strlen(s)-1;
+    if(*l == '\''){
+        *l=0;
+    }
+        
+    where->value = strdup(s);
+
+    /* Is there a period in str1 ? If so, the string specified both a
+       component and a property*/
+    if( (c = strrchr(str1,'.')) != 0){
+        compstr = str1;
+        propstr = c+1;
+        *c = '\0';
+    } else {
+        compstr = 0;
+        propstr = str1;
+    }
+
+
+    /* Handle the case where a component was specified */
+    if(compstr != 0){
+        where->comp = icalenum_string_to_component_kind(compstr);
+    } else {
+        where->comp = ICAL_NO_COMPONENT;
+    }
+
+    where->prop = icalenum_string_to_property_kind(propstr);    
+
+    where->compare = compare;
+
+    if(where->value == 0){
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        free(where->value);
+        return;
+    }
+
+    pvl_push(impl->where,where);
+}
+
+void set_logic(struct icalgauge_impl* impl,icalgaugelogic l)
+{
+    pvl_elem e = pvl_tail(impl->where);
+    struct icalgauge_where *where = pvl_data(e);
+
+    where->logic = l;
+   
+}
+
+
+
+void ssyacc_add_select(struct icalgauge_impl* impl, char* str1)
+{
+    char *c, *compstr, *propstr;
+    struct icalgauge_where *where;
+    
+    /* Uses only the prop and comp fields of the where structure */
+    if ( (where = malloc(sizeof(struct icalgauge_where))) ==0){
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        return;
+    }
+
+    memset(where,0,sizeof(struct icalgauge_where));
+    where->logic = ICALGAUGELOGIC_NONE;
+    where->compare = ICALGAUGECOMPARE_NONE;
+    where->comp = ICAL_NO_COMPONENT;
+    where->prop = ICAL_NO_PROPERTY;
+
+    /* Is there a period in str1 ? If so, the string specified both a
+       component and a property*/
+    if( (c = strrchr(str1,'.')) != 0){
+        compstr = str1;
+        propstr = c+1;
+        *c = '\0';
+    } else {
+        compstr = 0;
+        propstr = str1;
+    }
+
+
+    /* Handle the case where a component was specified */
+    if(compstr != 0){
+        where->comp = icalenum_string_to_component_kind(compstr);
+    } else {
+        where->comp = ICAL_NO_COMPONENT;
+    }
+
+
+    /* If the property was '*', then accept all properties */
+    if(strcmp("*",propstr) == 0) {
+                where->prop = ICAL_ANY_PROPERTY;     
+    } else {
+        where->prop = icalenum_string_to_property_kind(propstr);    
+    }
+    
+
+    if(where->prop == ICAL_NO_PROPERTY){
+        icalgauge_free(where);
+        icalerror_set_errno(ICAL_BADARG_ERROR);
+        return;
+    }
+
+    pvl_push(impl->select,where);
+}
+
+void ssyacc_add_from(struct icalgauge_impl* impl, char* str1)
+{
+    icalcomponent_kind ckind;
+
+    ckind = icalenum_string_to_component_kind(str1);
+
+    if(ckind == ICAL_NO_COMPONENT){
+        assert(0);
+    }
+
+    pvl_push(impl->from,(void*)ckind);
+
+}
+
+
+void sserror(char *s){
+    fprintf(stderr,"Parse error \'%s\'\n", s);
+}
diff --git a/libical/src/libicalss/icalssyacc.h b/libical/src/libicalss/icalssyacc.h
new file mode 100644
index 0000000..7d42f3c
--- a/dev/null
+++ b/libical/src/libicalss/icalssyacc.h
@@ -0,0 +1,31 @@
+#ifndef BISON_ICALSSYACC_H
+# define BISON_ICALSSYACC_H
+
+#ifndef YYSTYPE
+typedef union {
+        char* v_string;
+} yystype;
+# define YYSTYPE yystype
+# define YYSTYPE_IS_TRIVIAL 1
+#endif
+        # define        STRING257
+        # define        SELECT258
+        # define        FROM259
+        # define        WHERE260
+        # define        COMMA261
+        # define        QUOTE262
+        # define        EQUALS263
+        # define        NOTEQUALS264
+        # define        LESS265
+        # define        GREATER266
+        # define        LESSEQUALS267
+        # define        GREATEREQUALS268
+        # define        AND269
+        # define        OR270
+        # define        EOL271
+        # define        END272
+
+
+extern YYSTYPE sslval;
+
+#endif /* not BISON_ICALSSYACC_H */
diff --git a/libical/src/libicalss/icalssyacc.y b/libical/src/libicalss/icalssyacc.y
new file mode 100644
index 0000000..6482b58
--- a/dev/null
+++ b/libical/src/libicalss/icalssyacc.y
@@ -0,0 +1,245 @@
+%{
+/* -*- Mode: C -*-
+  ======================================================================
+  FILE: icalssyacc.y
+  CREATOR: eric 08 Aug 2000
+  
+  DESCRIPTION:
+  
+  $Id$
+  $Locker$
+
+(C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+
+ This program is free software; you can redistribute it and/or modify
+ it under the terms of either: 
+
+    The LGPL as published by the Free Software Foundation, version
+    2.1, available at: http://www.fsf.org/copyleft/lesser.html
+
+  Or:
+
+    The Mozilla Public License Version 1.0. You may obtain a copy of
+    the License at http://www.mozilla.org/MPL/
+
+ The Original Code is eric. The Initial Developer of the Original
+ Code is Eric Busboom
+
+  ======================================================================*/
+
+#include <stdlib.h>
+#include <string.h> /* for strdup() */
+#include <limits.h> /* for SHRT_MAX*/
+#include "ical.h"
+#include "pvl.h"
+#include "icalgauge.h"
+#include "icalgaugeimpl.h"
+
+
+extern struct icalgauge_impl *icalss_yy_gauge;
+
+void ssyacc_add_where(struct icalgauge_impl* impl, char* prop, 
+        icalgaugecompare compare , char* value);
+void ssyacc_add_select(struct icalgauge_impl* impl, char* str1);
+void ssyacc_add_from(struct icalgauge_impl* impl, char* str1);
+void set_logic(struct icalgauge_impl* impl,icalgaugelogic l);
+void sserror(char *s); /* Don't know why I need this.... */
+
+
+
+%}
+
+%union {
+        char* v_string;
+}
+
+
+%token <v_string> STRING
+%token SELECT FROM WHERE COMMA QUOTE EQUALS NOTEQUALS  LESS GREATER LESSEQUALS
+%token GREATEREQUALS AND OR EOL END
+
+%%
+
+query_min: SELECT select_list FROM from_list WHERE where_list
+           | error { 
+                 icalparser_clear_flex_input();
+                 yyclearin;
+                   }
+                   ;
+
+select_list:
+        STRING {ssyacc_add_select(icalss_yy_gauge,$1);}
+        | select_list COMMA STRING {ssyacc_add_select(icalss_yy_gauge,$3);}
+        ;
+
+
+from_list:
+        STRING {ssyacc_add_from(icalss_yy_gauge,$1);}
+        | from_list COMMA STRING {ssyacc_add_from(icalss_yy_gauge,$3);}
+        ;
+
+where_clause:
+        /* Empty */
+        | STRING EQUALS STRING {ssyacc_add_where(icalss_yy_gauge,$1,ICALGAUGECOMPARE_EQUAL,$3); }
+        
+        | STRING NOTEQUALS STRING {ssyacc_add_where(icalss_yy_gauge,$1,ICALGAUGECOMPARE_NOTEQUAL,$3); }
+        | STRING LESS STRING {ssyacc_add_where(icalss_yy_gauge,$1,ICALGAUGECOMPARE_LESS,$3); }
+        | STRING GREATER STRING {ssyacc_add_where(icalss_yy_gauge,$1,ICALGAUGECOMPARE_GREATER,$3); }
+        | STRING LESSEQUALS STRING {ssyacc_add_where(icalss_yy_gauge,$1,ICALGAUGECOMPARE_LESSEQUAL,$3); }
+        | STRING GREATEREQUALS STRING {ssyacc_add_where(icalss_yy_gauge,$1,ICALGAUGECOMPARE_GREATEREQUAL,$3); }
+        ;
+
+where_list:
+        where_clause {set_logic(icalss_yy_gauge,ICALGAUGELOGIC_NONE);}
+        | where_list AND where_clause {set_logic(icalss_yy_gauge,ICALGAUGELOGIC_AND);} 
+        | where_list OR where_clause {set_logic(icalss_yy_gauge,ICALGAUGELOGIC_OR);}
+        ;
+
+
+%%
+
+void ssyacc_add_where(struct icalgauge_impl* impl, char* str1, 
+        icalgaugecompare compare , char* value_str)
+{
+
+    struct icalgauge_where *where;
+    char *compstr, *propstr, *c, *s,*l;
+    
+    if ( (where = malloc(sizeof(struct icalgauge_where))) ==0){
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        return;
+    }
+
+    memset(where,0,sizeof(struct icalgauge_where));
+    where->logic = ICALGAUGELOGIC_NONE;
+    where->compare = ICALGAUGECOMPARE_NONE;
+    where->comp = ICAL_NO_COMPONENT;
+    where->prop = ICAL_NO_PROPERTY;
+
+    /* remove enclosing quotes */
+    s = value_str;
+    if(*s == '\''){
+        s++;
+    }
+    l = s+strlen(s)-1;
+    if(*l == '\''){
+        *l=0;
+    }
+        
+    where->value = strdup(s);
+
+    /* Is there a period in str1 ? If so, the string specified both a
+       component and a property*/
+    if( (c = strrchr(str1,'.')) != 0){
+        compstr = str1;
+        propstr = c+1;
+        *c = '\0';
+    } else {
+        compstr = 0;
+        propstr = str1;
+    }
+
+
+    /* Handle the case where a component was specified */
+    if(compstr != 0){
+        where->comp = icalenum_string_to_component_kind(compstr);
+    } else {
+        where->comp = ICAL_NO_COMPONENT;
+    }
+
+    where->prop = icalenum_string_to_property_kind(propstr);    
+
+    where->compare = compare;
+
+    if(where->value == 0){
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        free(where->value);
+        return;
+    }
+
+    pvl_push(impl->where,where);
+}
+
+void set_logic(struct icalgauge_impl* impl,icalgaugelogic l)
+{
+    pvl_elem e = pvl_tail(impl->where);
+    struct icalgauge_where *where = pvl_data(e);
+
+    where->logic = l;
+   
+}
+
+
+
+void ssyacc_add_select(struct icalgauge_impl* impl, char* str1)
+{
+    char *c, *compstr, *propstr;
+    struct icalgauge_where *where;
+    
+    /* Uses only the prop and comp fields of the where structure */
+    if ( (where = malloc(sizeof(struct icalgauge_where))) ==0){
+        icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+        return;
+    }
+
+    memset(where,0,sizeof(struct icalgauge_where));
+    where->logic = ICALGAUGELOGIC_NONE;
+    where->compare = ICALGAUGECOMPARE_NONE;
+    where->comp = ICAL_NO_COMPONENT;
+    where->prop = ICAL_NO_PROPERTY;
+
+    /* Is there a period in str1 ? If so, the string specified both a
+       component and a property*/
+    if( (c = strrchr(str1,'.')) != 0){
+        compstr = str1;
+        propstr = c+1;
+        *c = '\0';
+    } else {
+        compstr = 0;
+        propstr = str1;
+    }
+
+
+    /* Handle the case where a component was specified */
+    if(compstr != 0){
+        where->comp = icalenum_string_to_component_kind(compstr);
+    } else {
+        where->comp = ICAL_NO_COMPONENT;
+    }
+
+
+    /* If the property was '*', then accept all properties */
+    if(strcmp("*",propstr) == 0) {
+                where->prop = ICAL_ANY_PROPERTY;     
+    } else {
+        where->prop = icalenum_string_to_property_kind(propstr);    
+    }
+    
+
+    if(where->prop == ICAL_NO_PROPERTY){
+        icalgauge_free(where);
+        icalerror_set_errno(ICAL_BADARG_ERROR);
+        return;
+    }
+
+    pvl_push(impl->select,where);
+}
+
+void ssyacc_add_from(struct icalgauge_impl* impl, char* str1)
+{
+    icalcomponent_kind ckind;
+
+    ckind = icalenum_string_to_component_kind(str1);
+
+    if(ckind == ICAL_NO_COMPONENT){
+        assert(0);
+    }
+
+    pvl_push(impl->from,(void*)ckind);
+
+}
+
+
+void sserror(char *s){
+    fprintf(stderr,"Parse error \'%s\'\n", s);
+}
diff --git a/libical/src/libicalss/libicalss.pro b/libical/src/libicalss/libicalss.pro
new file mode 100644
index 0000000..a5cc80c
--- a/dev/null
+++ b/libical/src/libicalss/libicalss.pro
@@ -0,0 +1,43 @@
+include(../../../variables.pri)
+
+        TEMPLATE= lib
+
+TARGET          = icalss
+DESTDIR = ../../lib
+        CONFIG  += staticlib
+win32: DEFINES += _WIN32  _QTWIN_
+        HEADERS         = icalcalendar.h \
+                  icalclassify.h \
+                  icalcstp.h \
+                  icalcstpclient.h \
+                  icalcstpserver.h \
+                  icaldirset.h \
+                  icaldirsetimpl.h \
+                  icalfileset.h \
+                  icalfilesetimpl.h \
+                  icalgauge.h \
+                  icalgaugeimpl.h \
+                  icalmessage.h \
+                  icalset.h \
+                  icalspanlist.h \
+                  icalssyacc.h \
+                  config.h
+                  
+        SOURCES         = icalclassify.c \
+                  icalcstp.c \
+                  icalcstpclient.c \
+                  icalcstpserver.c \
+                  icaldirset.c \
+                  icalfileset.c \
+                  icalgauge.c \
+                  icalmessage.c \
+                  icalset.c \
+                  icalspanlist.c \
+                  icalsslexer.c \
+                  icalssyacc.c
+                  
+        INTERFACES= 
+
+INCLUDEPATH     += ../libical
+
+DEFINES += HAVE_CONFIG_H
diff --git a/libical/src/libicalss/libicalssE.pro b/libical/src/libicalss/libicalssE.pro
new file mode 100644
index 0000000..57d60bd
--- a/dev/null
+++ b/libical/src/libicalss/libicalssE.pro
@@ -0,0 +1,45 @@
+        TEMPLATE= lib
+        CONFIG  += warn_on  staticlib
+INCLUDEPATH     += ../libical
+INCLUDEPATH     += .
+DEFINES += HAVE_CONFIG_H
+OBJECTS_DIR = obj/$(PLATFORM)
+MOC_DIR = moc/$(PLATFORM)
+DESTDIR=../../lib/$(PLATFORM)
+TARGET          = icalss
+
+INTERFACES = \
+
+HEADERS = \
+ config.h \
+ icalcalendar.h \
+ icalclassify.h \
+ icalcstp.h \
+ icalcstpclient.h \
+ icalcstpserver.h \
+ icaldirset.h \
+ icaldirsetimpl.h \
+ icalfileset.h \
+ icalfilesetimpl.h \
+ icalgauge.h \
+ icalgaugeimpl.h \
+ icalmessage.h \
+ icalset.h \
+ icalspanlist.h \
+ icalss.h \
+ icalssyacc.h \
+
+SOURCES = \
+ icalclassify.c \
+ icalcstp.c \
+ icalcstpclient.c \
+ icalcstpserver.c \
+ icaldirset.c \
+ icalfileset.c \
+ icalgauge.c \
+ icalmessage.c \
+ icalset.c \
+ icalspanlist.c \
+ icalsslexer.c \
+ icalssyacc.c \
+
diff --git a/libical/src/src.pro b/libical/src/src.pro
new file mode 100644
index 0000000..de8f0c4
--- a/dev/null
+++ b/libical/src/src.pro
@@ -0,0 +1,4 @@
+
+
+TEMPLATE = subdirs
+SUBDIRS =  libical libicalss