| author | zautrix <zautrix> | 2004-06-26 19:01:18 (UTC) |
|---|---|---|
| committer | zautrix <zautrix> | 2004-06-26 19:01:18 (UTC) |
| commit | b9aad1f15dc600e4dbe4c62d3fcced6363188ba3 (patch) (side-by-side diff) | |
| tree | 2c3d4004fb21c72cba65793859f9bcd8ffd3a49c /libical/src | |
| download | kdepimpi-b9aad1f15dc600e4dbe4c62d3fcced6363188ba3.zip kdepimpi-b9aad1f15dc600e4dbe4c62d3fcced6363188ba3.tar.gz kdepimpi-b9aad1f15dc600e4dbe4c62d3fcced6363188ba3.tar.bz2 | |
Initial revision
94 files changed, 39285 insertions, 0 deletions
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(>m); + + 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 DIGITS 257 +#define INTNUMBER 258 +#define FLOATNUMBER 259 +#define STRING 260 +#define EOL 261 +#define EQUALS 262 +#define CHARACTER 263 +#define COLON 264 +#define COMMA 265 +#define SEMICOLON 266 +#define MINUS 267 +#define TIMESEPERATOR 268 +#define TRUE 269 +#define FALSE 270 +#define FREQ 271 +#define BYDAY 272 +#define BYHOUR 273 +#define BYMINUTE 274 +#define BYMONTH 275 +#define BYMONTHDAY 276 +#define BYSECOND 277 +#define BYSETPOS 278 +#define BYWEEKNO 279 +#define BYYEARDAY 280 +#define DAILY 281 +#define MINUTELY 282 +#define MONTHLY 283 +#define SECONDLY 284 +#define WEEKLY 285 +#define HOURLY 286 +#define YEARLY 287 +#define INTERVAL 288 +#define COUNT 289 +#define UNTIL 290 +#define WKST 291 +#define MO 292 +#define SA 293 +#define SU 294 +#define TU 295 +#define WE 296 +#define TH 297 +#define FR 298 +#define BIT8 299 +#define ACCEPTED 300 +#define ADD 301 +#define AUDIO 302 +#define BASE64 303 +#define BINARY 304 +#define BOOLEAN 305 +#define BUSY 306 +#define BUSYTENTATIVE 307 +#define BUSYUNAVAILABLE 308 +#define CALADDRESS 309 +#define CANCEL 310 +#define CANCELLED 311 +#define CHAIR 312 +#define CHILD 313 +#define COMPLETED 314 +#define CONFIDENTIAL 315 +#define CONFIRMED 316 +#define COUNTER 317 +#define DATE 318 +#define DATETIME 319 +#define DECLINECOUNTER 320 +#define DECLINED 321 +#define DELEGATED 322 +#define DISPLAY 323 +#define DRAFT 324 +#define DURATION 325 +#define EMAIL 326 +#define END 327 +#define FINAL 328 +#define FLOAT 329 +#define FREE 330 +#define GREGORIAN 331 +#define GROUP 332 +#define INDIVIDUAL 333 +#define INPROCESS 334 +#define INTEGER 335 +#define NEEDSACTION 336 +#define NONPARTICIPANT 337 +#define OPAQUE 338 +#define OPTPARTICIPANT 339 +#define PARENT 340 +#define PERIOD 341 +#define PRIVATE 342 +#define PROCEDURE 343 +#define PUBLIC 344 +#define PUBLISH 345 +#define RECUR 346 +#define REFRESH 347 +#define REPLY 348 +#define REQPARTICIPANT 349 +#define REQUEST 350 +#define RESOURCE 351 +#define ROOM 352 +#define SIBLING 353 +#define START 354 +#define TENTATIVE 355 +#define TEXT 356 +#define THISANDFUTURE 357 +#define THISANDPRIOR 358 +#define TIME 359 +#define TRANSPAENT 360 +#define UNKNOWN 361 +#define UTCOFFSET 362 +#define XNAME 363 +#define ALTREP 364 +#define CN 365 +#define CUTYPE 366 +#define DAYLIGHT 367 +#define DIR 368 +#define ENCODING 369 +#define EVENT 370 +#define FBTYPE 371 +#define FMTTYPE 372 +#define LANGUAGE 373 +#define MEMBER 374 +#define PARTSTAT 375 +#define RANGE 376 +#define RELATED 377 +#define RELTYPE 378 +#define ROLE 379 +#define RSVP 380 +#define SENTBY 381 +#define STANDARD 382 +#define URI 383 +#define TIME_CHAR 384 +#define UTC_CHAR 385 + +#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 YYNTBASE 141 + +#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 YYACCEPT goto 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 YYTERROR 1 +#define YYERRCODE 256 + +#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 */ + +#ifndef YYINITDEPTH +#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 DIGITS 257 +#define INTNUMBER 258 +#define FLOATNUMBER 259 +#define STRING 260 +#define EOL 261 +#define EQUALS 262 +#define CHARACTER 263 +#define COLON 264 +#define COMMA 265 +#define SEMICOLON 266 +#define MINUS 267 +#define TIMESEPERATOR 268 +#define TRUE 269 +#define FALSE 270 +#define FREQ 271 +#define BYDAY 272 +#define BYHOUR 273 +#define BYMINUTE 274 +#define BYMONTH 275 +#define BYMONTHDAY 276 +#define BYSECOND 277 +#define BYSETPOS 278 +#define BYWEEKNO 279 +#define BYYEARDAY 280 +#define DAILY 281 +#define MINUTELY 282 +#define MONTHLY 283 +#define SECONDLY 284 +#define WEEKLY 285 +#define HOURLY 286 +#define YEARLY 287 +#define INTERVAL 288 +#define COUNT 289 +#define UNTIL 290 +#define WKST 291 +#define MO 292 +#define SA 293 +#define SU 294 +#define TU 295 +#define WE 296 +#define TH 297 +#define FR 298 +#define BIT8 299 +#define ACCEPTED 300 +#define ADD 301 +#define AUDIO 302 +#define BASE64 303 +#define BINARY 304 +#define BOOLEAN 305 +#define BUSY 306 +#define BUSYTENTATIVE 307 +#define BUSYUNAVAILABLE 308 +#define CALADDRESS 309 +#define CANCEL 310 +#define CANCELLED 311 +#define CHAIR 312 +#define CHILD 313 +#define COMPLETED 314 +#define CONFIDENTIAL 315 +#define CONFIRMED 316 +#define COUNTER 317 +#define DATE 318 +#define DATETIME 319 +#define DECLINECOUNTER 320 +#define DECLINED 321 +#define DELEGATED 322 +#define DISPLAY 323 +#define DRAFT 324 +#define DURATION 325 +#define EMAIL 326 +#define END 327 +#define FINAL 328 +#define FLOAT 329 +#define FREE 330 +#define GREGORIAN 331 +#define GROUP 332 +#define INDIVIDUAL 333 +#define INPROCESS 334 +#define INTEGER 335 +#define NEEDSACTION 336 +#define NONPARTICIPANT 337 +#define OPAQUE 338 +#define OPTPARTICIPANT 339 +#define PARENT 340 +#define PERIOD 341 +#define PRIVATE 342 +#define PROCEDURE 343 +#define PUBLIC 344 +#define PUBLISH 345 +#define RECUR 346 +#define REFRESH 347 +#define REPLY 348 +#define REQPARTICIPANT 349 +#define REQUEST 350 +#define RESOURCE 351 +#define ROOM 352 +#define SIBLING 353 +#define START 354 +#define TENTATIVE 355 +#define TEXT 356 +#define THISANDFUTURE 357 +#define THISANDPRIOR 358 +#define TIME 359 +#define TRANSPAENT 360 +#define UNKNOWN 361 +#define UTCOFFSET 362 +#define XNAME 363 +#define ALTREP 364 +#define CN 365 +#define CUTYPE 366 +#define DAYLIGHT 367 +#define DIR 368 +#define ENCODING 369 +#define EVENT 370 +#define FBTYPE 371 +#define FMTTYPE 372 +#define LANGUAGE 373 +#define MEMBER 374 +#define PARTSTAT 375 +#define RANGE 376 +#define RELATED 377 +#define RELTYPE 378 +#define ROLE 379 +#define RSVP 380 +#define SENTBY 381 +#define STANDARD 382 +#define URI 383 +#define TIME_CHAR 384 +#define UTC_CHAR 385 + + +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: + + d The 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: + + l The list to add the item to + d Pointer 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: + + l The 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: + + l The list to operate on + d Pointer 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: + + l The 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. + + l The list to operate on + f Pointer 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: + + l The list to operate on + p The list element to add the item after + d Pointer 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: + + l The list to operate on + p The list element to add the item before + d Pointer 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: + + l The list to operate on + e The 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: + + l The list to operate on + f Pointer to the find function + v Pointer 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: + + l The list to operate on + f Pointer to the find function + v Pointer 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: + + l The list to operate on + f Pointer to the function to call + v Data 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 STRING 257 +# define SELECT 258 +# define FROM 259 +# define WHERE 260 +# define COMMA 261 +# define QUOTE 262 +# define EQUALS 263 +# define NOTEQUALS 264 +# define LESS 265 +# define GREATER 266 +# define LESSEQUALS 267 +# define GREATEREQUALS 268 +# define AND 269 +# define OR 270 +# define EOL 271 +# define END 272 + +#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 YYNTBASE 19 + +/* 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 YYACCEPT goto 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 YYTERROR 1 +#define YYERRCODE 256 + + +/* 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. */ +#ifndef YYINITDEPTH +# 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. */ + short yyssa[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 STRING 257 +# define SELECT 258 +# define FROM 259 +# define WHERE 260 +# define COMMA 261 +# define QUOTE 262 +# define EQUALS 263 +# define NOTEQUALS 264 +# define LESS 265 +# define GREATER 266 +# define LESSEQUALS 267 +# define GREATEREQUALS 268 +# define AND 269 +# define OR 270 +# define EOL 271 +# define END 272 + + +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 |