diff options
Diffstat (limited to 'libical/src')
40 files changed, 5634 insertions, 1653 deletions
diff --git a/libical/src/libical/Makefile.am b/libical/src/libical/Makefile.am index 35a08effc7..ee87c992e1 100644 --- a/libical/src/libical/Makefile.am +++ b/libical/src/libical/Makefile.am @@ -1,106 +1,175 @@ - -#AUTOMAKE_OPTIONS = no-dependencies - -#noinst_LTLIBRARIES = libical.la -lib_LIBRARIES = libical.a - -YFLAGS =-d -v -t - -libical_a_SOURCES = \ - ical.h \ - icalcomponent.c \ - icalcomponent.h \ - icalenums.c \ - icalenums.h \ - icalerror.c \ - icalerror.h \ - icalyacc.y \ - icallexer.l \ - icalmemory.c \ - icalmemory.h \ - icalparameter.c \ - icalparameter.h \ - icalparser.c \ - icalparser.h \ - icalproperty.c \ - icalproperty.h \ - icalrestriction.c \ - icalrestriction.h \ - icaltypes.c \ - icaltypes.h \ - icalvalue.c \ - icalvalue.h \ - icalrecur.c \ - icalrecur.h \ - icaltime.h \ - icaltime.c \ - pvl.c \ - pvl.h \ - sspm.c \ - sspm.h \ - icalmime.c \ - icalmime.h - -include_HEADERS=\ - ical.h \ - icalcomponent.h \ - icalenums.h \ - icalerror.h \ - icalmemory.h \ - icalparameter.h \ - icalparser.h \ - icalproperty.h \ - icalrestriction.h \ - icaltypes.h \ - icalvalue.h \ - icalrecur.h \ - icalversion.h \ - icaltime.h \ - pvl.h \ - sspm.h \ - icalmime.h - - -# -# static convenience library for use in conduits -# - -noinst_LTLIBRARIES = libical-static.la -libical_static_la_SOURCES = $(libical_a_SOURCES) -libical_static_la_LDFLAGS = --all-static - -EXTRA_DIST = icallexer.c icalyacc.c icalyacc.h - -CONFIG_CLEAN_FILES = y.output *~ - -DESIGNDATA = ../../design-data -ICALSCRIPTS = ../../scripts -derived: icalproperty icalparameter icalvalue icalrestriction - -icalproperty: - $(ICALSCRIPTS)/mkderivedproperties.pl -i icalproperty.h -h $(DESIGNDATA)/prop-to-value.txt ${DESIGNDATA}/value-c-types.txt > icalproperty.newh - mv icalproperty.newh icalproperty.h - - $(ICALSCRIPTS)/mkderivedproperties.pl -i icalproperty.c -c $(DESIGNDATA)/prop-to-value.txt ${DESIGNDATA}/value-c-types.txt > icalproperty.newc - mv icalproperty.newc icalproperty.c - - -icalparameter: - $(ICALSCRIPTS)/mkderivedparameters.pl -i icalparameter.h -h $(DESIGNDATA)/param-c-types.txt > icalparameter.newh - mv icalparameter.newh icalparameter.h - - $(ICALSCRIPTS)/mkderivedparameters.pl -i icalparameter.c -c $(DESIGNDATA)/param-c-types.txt > icalparameter.newc - mv icalparameter.newc icalparameter.c - -icalvalue: - $(ICALSCRIPTS)/mkderivedvalues.pl -i icalvalue.h -h $(DESIGNDATA)/value-c-types.txt > icalvalue.newh - mv icalvalue.newh icalvalue.h - - $(ICALSCRIPTS)/mkderivedvalues.pl -i icalvalue.c -c $(DESIGNDATA)/value-c-types.txt > icalvalue.newc - mv icalvalue.newc icalvalue.c - -icalrestriction: - $(ICALSCRIPTS)/mkrestrictiontable.pl -i icalrestriction.c $(DESIGNDATA)/restrictions.csv > icalrestriction.newc - mv icalrestriction.newc icalrestriction.c - - +DESIGNDATA = $(top_srcdir)/design-data +ICALSCRIPTS = $(top_srcdir)/scripts + +lib_LTLIBRARIES = libical.la + +YFLAGS = -d -v -t -pical_yy +LFLAGS = -Pical_yy +LEX_OUTPUT_ROOT = lex.ical_yy + +all: ical.h + +INCLUDES = \ + -I$(top_builddir) \ + -I$(top_srcdir)/src \ + -I$(top_builddir)/src \ + -I$(srcdir) + +libical_la_LDFLAGS = -version-info 0:0:0 + +libical_la_SOURCES = \ + icalcomponent.c \ + icalcomponent.h \ + icalenums.c \ + icalenums.h \ + icalerror.c \ + icalerror.h \ + icallexer.l \ + icalmemory.c \ + icalmemory.h \ + icalmime.c \ + icalmime.h \ + icalparameter.c \ + icalparameter.h \ + icalparser.c \ + icalparser.h \ + icalproperty.c \ + icalproperty.h \ + icalrecur.c \ + icalrecur.h \ + icalrestriction.c \ + icalrestriction.h \ + icaltime.c \ + icaltime.h \ + icaltypes.c \ + icaltypes.h \ + icalvalue.c \ + icalvalue.h \ + icalyacc.h \ + icalyacc.y \ + pvl.c \ + pvl.h \ + sspm.c \ + sspm.h + +libicalincludedir = $(includedir) + +libicalinclude_HEADERS = ical.h + +# ORDERING OF HEADERS IS SIGNIFICANT. Don't change this ordering. It +# is required to make the combined header ical.h properly +COMBINEDHEADERS = \ + $(top_builddir)/src/libical/icalversion.h \ + $(top_srcdir)/src/libical/icaltime.h \ + $(top_srcdir)/src/libical/icalenums.h \ + $(top_srcdir)/src/libical/icaltypes.h \ + $(top_srcdir)/src/libical/icalrecur.h \ + $(top_srcdir)/src/libical/icalvalue.h \ + $(top_srcdir)/src/libical/icalparameter.h \ + $(top_srcdir)/src/libical/icalproperty.h \ + $(top_srcdir)/src/libical/pvl.h \ + $(top_srcdir)/src/libical/icalcomponent.h \ + $(top_srcdir)/src/libical/icalparser.h \ + $(top_srcdir)/src/libical/icalmemory.h \ + $(top_srcdir)/src/libical/icalerror.h \ + $(top_srcdir)/src/libical/icalrestriction.h \ + $(top_srcdir)/src/libical/sspm.h \ + $(top_srcdir)/src/libical/icalmime.h + +BUILT_SOURCES = \ + icalparameter.c \ + icalparameter.h \ + icalproperty.c \ + icalproperty.h \ + icalrestriction.c \ + icalvalue.c \ + icalvalue.h + +ical.h: $(COMBINEDHEADERS) $(BUILT_SOURCES) + cat $(COMBINEDHEADERS) \ + | egrep -v "#include.*\"ical" \ + | egrep -v "#include.*\"pvl\.h\"" > ical.h + +icallexer.c : icalyacc.h + + +# parameters + +PARAMETERDEPS = \ + $(ICALSCRIPTS)/mkderivedparameters.pl \ + $(DESIGNDATA)/param-c-types.txt \ + icalparameter.c.in \ + icalparameter.h.in + +icalparameter.h: $(PARAMETERDEPS) + $(PERL) $(ICALSCRIPTS)/mkderivedparameters.pl -i icalparameter.h.in -h $(DESIGNDATA)/param-c-types.txt > icalparameter.newh \ + && mv icalparameter.newh icalparameter.h + +icalparameter.c: $(PARAMETERDEPS) icalparameter.h + $(PERL) $(ICALSCRIPTS)/mkderivedparameters.pl -i icalparameter.c.in -c $(DESIGNDATA)/param-c-types.txt > icalparameter.newc \ + && mv icalparameter.newc icalparameter.c + +# properties + +PROPERTYDEPS = \ + $(ICALSCRIPTS)/mkderivedproperties.pl \ + $(DESIGNDATA)/prop-to-value.txt \ + $(DESIGNDATA)/value-c-types.txt \ + icalproperty.c.in \ + icalproperty.h.in + + +icalproperty.h: $(PROPERTYDEPS) + $(PERL) $(ICALSCRIPTS)/mkderivedproperties.pl -i icalproperty.h.in -h \ + $(DESIGNDATA)/prop-to-value.txt \ + ${DESIGNDATA}/value-c-types.txt > icalproperty.h + +icalproperty.c: $(PROPERTYDEPS) icalproperty.h + $(PERL) $(ICALSCRIPTS)/mkderivedproperties.pl -i icalproperty.c.in -c \ + $(DESIGNDATA)/prop-to-value.txt \ + ${DESIGNDATA}/value-c-types.txt > icalproperty.c + +# restrictions + +RESTRICTIONDEPS = \ + $(ICALSCRIPTS)/mkrestrictiontable.pl \ + $(DESIGNDATA)/restrictions.csv \ + icalrestriction.c.in + +icalrestriction.c: $(RESTRICTIONDEPS) + $(PERL) $(ICALSCRIPTS)/mkrestrictiontable.pl -i icalrestriction.c.in \ + $(DESIGNDATA)/restrictions.csv > icalrestriction.c + +# values + +VALUEDEPS = \ + $(ICALSCRIPTS)/mkderivedvalues.pl \ + $(DESIGNDATA)/value-c-types.txt \ + icalvalue.c.in \ + icalvalue.h.in + +icalvalue.h: $(VALUEDEPS) + $(PERL) $(ICALSCRIPTS)/mkderivedvalues.pl -i icalvalue.h.in -h \ + $(DESIGNDATA)/value-c-types.txt > icalvalue.h + +icalvalue.c: $(VALUEDEPS) icalvalue.h + $(PERL) $(ICALSCRIPTS)/mkderivedvalues.pl -i icalvalue.c.in -c \ + $(DESIGNDATA)/value-c-types.txt > icalvalue.c + + + +# housekeeping +CONFIG_CLEAN_FILES = y.output + +EXTRA_DIST = \ + icalparameter.c.in \ + icalparameter.h.in \ + icalproperty.c.in \ + icalproperty.h.in \ + icalrestriction.c.in \ + icalvalue.c.in \ + icalvalue.h.in \ + icalversion.h.in \ + $(BUILT_SOURCES) \ + icallexer.c \ + icalyacc.c diff --git a/libical/src/libical/ical.h b/libical/src/libical/ical.h index 05e7ca82bc..506d69a6db 100644 --- a/libical/src/libical/ical.h +++ b/libical/src/libical/ical.h @@ -1,6 +1,596 @@ +#ifndef ICAL_VERSION_H +#define ICAL_VERSION_H + +#define ICAL_PACKAGE "libical" +#define ICAL_VERSION "0.21a" + +#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. */ +}; + +struct icaltimetype icaltime_null_time(void); + +int icaltime_is_null_time(struct icaltimetype t); + +struct icaltimetype icaltime_normalize(struct icaltimetype t); + +short icaltime_day_of_year(struct icaltimetype t); +struct icaltimetype icaltime_from_day_of_year(short doy, short year); + +short icaltime_day_of_week(struct icaltimetype t); +short icaltime_start_doy_of_week(struct icaltimetype t); + +struct icaltimetype icaltime_from_timet(time_t v, int is_date, int is_utc); +struct icaltimetype icaltime_from_string(const char* str); +time_t icaltime_as_timet(struct icaltimetype); +char* icaltime_as_ctime(struct icaltimetype); + +short icaltime_week_number(short day_of_month, short month, short year); + +struct icaltimetype icaltime_from_week_number(short week_number, short year); + +int icaltime_compare(struct icaltimetype a,struct icaltimetype b); + +int icaltime_compare_date_only(struct icaltimetype a, struct icaltimetype b); + + +short icaltime_days_in_month(short month,short year); + +/* 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 */ +time_t icaltime_utc_offset(struct icaltimetype tt, const char* tzid); + +time_t icaltime_local_utc_offset(); + + +/* convert tt, of timezone tzid, into a utc time */ +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); + + + +struct icaldurationtype +{ + int is_neg; + unsigned int days; + unsigned int weeks; + unsigned int hours; + unsigned int minutes; + unsigned int seconds; +}; + +struct icaldurationtype icaldurationtype_from_timet(time_t t); +struct icaldurationtype icaldurationtype_from_string(const char*); +time_t icaldurationtype_as_timet(struct icaldurationtype duration); + + +struct icalperiodtype +{ + struct icaltimetype start; /* Must be absolute */ + struct icaltimetype end; /* Must be absolute */ + struct icaldurationtype duration; +}; + +time_t icalperiodtype_duration(struct icalperiodtype period); +time_t icalperiodtype_end(struct icalperiodtype period); + + + +struct icaltimetype icaltime_add(struct icaltimetype t, + struct icaldurationtype d); + +struct icaldurationtype icaltime_subtract(struct icaltimetype t1, + struct icaltimetype t2); + + +#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; + +/*********************************************************************** + * Property Enumerations +**********************************************************************/ + +typedef enum icalproperty_kind { + ICAL_ANY_PROPERTY = 0, /* This must be the first enum, for iteration */ + ICAL_CALSCALE_PROPERTY, + ICAL_METHOD_PROPERTY, + ICAL_PRODID_PROPERTY, + ICAL_VERSION_PROPERTY, + ICAL_ATTACH_PROPERTY, + ICAL_CATEGORIES_PROPERTY, + ICAL_CLASS_PROPERTY, + ICAL_COMMENT_PROPERTY, + ICAL_DESCRIPTION_PROPERTY, + ICAL_GEO_PROPERTY, + ICAL_LOCATION_PROPERTY, + ICAL_PERCENTCOMPLETE_PROPERTY, + ICAL_PRIORITY_PROPERTY, + ICAL_RESOURCES_PROPERTY, + ICAL_STATUS_PROPERTY, + ICAL_SUMMARY_PROPERTY, + ICAL_COMPLETED_PROPERTY, + ICAL_DTEND_PROPERTY, + ICAL_DUE_PROPERTY, + ICAL_DTSTART_PROPERTY, + ICAL_DURATION_PROPERTY, + ICAL_FREEBUSY_PROPERTY, + ICAL_TRANSP_PROPERTY, + ICAL_TZID_PROPERTY, + ICAL_TZNAME_PROPERTY, + ICAL_TZOFFSETFROM_PROPERTY, + ICAL_TZOFFSETTO_PROPERTY, + ICAL_TZURL_PROPERTY, + ICAL_ATTENDEE_PROPERTY, + ICAL_CONTACT_PROPERTY, + ICAL_ORGANIZER_PROPERTY, + ICAL_RECURRENCEID_PROPERTY, + ICAL_RELATEDTO_PROPERTY, + ICAL_URL_PROPERTY, + ICAL_UID_PROPERTY, + ICAL_EXDATE_PROPERTY, + ICAL_EXRULE_PROPERTY, + ICAL_RDATE_PROPERTY, + ICAL_RRULE_PROPERTY, + ICAL_ACTION_PROPERTY, + ICAL_REPEAT_PROPERTY, + ICAL_TRIGGER_PROPERTY, + ICAL_CREATED_PROPERTY, + ICAL_DTSTAMP_PROPERTY, + ICAL_LASTMODIFIED_PROPERTY, + ICAL_SEQUENCE_PROPERTY, + ICAL_REQUESTSTATUS_PROPERTY, + ICAL_X_PROPERTY, + + /* CAP Properties */ + ICAL_SCOPE_PROPERTY, + ICAL_MAXRESULTS_PROPERTY, + ICAL_MAXRESULTSSIZE_PROPERTY, + ICAL_QUERY_PROPERTY, + ICAL_QUERYNAME_PROPERTY, + ICAL_TARGET_PROPERTY, + + /* libical private properties */ + ICAL_XLICERROR_PROPERTY, + ICAL_XLICCLUSTERCOUNT_PROPERTY, + ICAL_XLICMIMECONTENTTYPE_PROPERTY, + ICAL_XLICMIMEENCODING_PROPERTY, + ICAL_XLICMIMECID_PROPERTY, + ICAL_XLICMIMEFILENAME_PROPERTY, + ICAL_XLICMIMECHARSET_PROPERTY, + ICAL_XLICMIMEOPTINFO_PROPERTY, + + ICAL_NO_PROPERTY /* This must be the last enum, for iteration */ + +} icalproperty_kind; + +/*********************************************************************** + * Enumerations for the values of properties + ***********************************************************************/ + +typedef enum icalproperty_method { + ICAL_METHOD_PUBLISH, + ICAL_METHOD_REQUEST, + ICAL_METHOD_REPLY, + ICAL_METHOD_ADD, + ICAL_METHOD_CANCEL, + ICAL_METHOD_REFRESH, + ICAL_METHOD_COUNTER, + ICAL_METHOD_DECLINECOUNTER, + /* CAP Methods */ + ICAL_METHOD_CREATE, + ICAL_METHOD_READ, + ICAL_METHOD_RESPONSE, + ICAL_METHOD_MOVE, + ICAL_METHOD_MODIFY, + ICAL_METHOD_GENERATEUID, + ICAL_METHOD_DELETE, + ICAL_METHOD_NONE +} icalproperty_method ; + +typedef enum icalproperty_transp { + ICAL_TRANSP_OPAQUE, + ICAL_TRANS_TRANSPARENT +} icalproperty_trans; + +typedef enum icalproperty_calscale { + ICAL_CALSCALE_GREGORIAN +} icalproperty_calscale ; + + +typedef enum icalproperty_class { + ICAL_CLASS_PUBLIC, + ICAL_CLASS_PRIVATE, + ICAL_CLASS_CONFIDENTIAL, + ICAL_CLASS_XNAME +} icalproperty_class; + + +typedef enum icalproperty_status { + ICAL_STATUS_NONE, + ICAL_STATUS_TENTATIVE, + ICAL_STATUS_CONFIRMED, + ICAL_STATUS_CANCELLED, /* CANCELED? SIC from RFC*/ + ICAL_STATUS_NEEDSACTION, + ICAL_STATUS_COMPLETED, + ICAL_STATUS_INPROCESS, + ICAL_STATUS_DRAFT, + ICAL_STATUS_FINAL +} icalproperty_status; + +typedef enum icalproperty_action { + ICAL_ACTION_AUDIO, + ICAL_ACTION_DISPLAY, + ICAL_ACTION_EMAIL, + ICAL_ACTION_PROCEDURE, + ICAL_ACTION_XNAME +} icalproperty_action; + +/*********************************************************************** + * Value enumerations +**********************************************************************/ + +typedef enum icalvalue_kind { + ICAL_NO_VALUE, + ICAL_ATTACH_VALUE, /* Non-Standard*/ + ICAL_BINARY_VALUE, + ICAL_BOOLEAN_VALUE, + ICAL_CALADDRESS_VALUE, + ICAL_DATE_VALUE, + ICAL_DATETIME_VALUE, + ICAL_DATETIMEDATE_VALUE, /* Non-Standard */ + ICAL_DATETIMEPERIOD_VALUE, /* Non-Standard */ + ICAL_DURATION_VALUE, + ICAL_FLOAT_VALUE, + ICAL_GEO_VALUE, /* Non-Standard */ + ICAL_INTEGER_VALUE, + ICAL_METHOD_VALUE, /* Non-Standard */ + ICAL_STATUS_VALUE, /* Non-Standard */ + ICAL_PERIOD_VALUE, + ICAL_RECUR_VALUE, + ICAL_STRING_VALUE, /* Non-Standard */ + ICAL_TEXT_VALUE, + ICAL_TIME_VALUE, + ICAL_TRIGGER_VALUE, /* Non-Standard */ + ICAL_URI_VALUE, + ICAL_UTCOFFSET_VALUE, + ICAL_QUERY_VALUE, + ICAL_XNAME_VALUE +} icalvalue_kind; + + +/*********************************************************************** + * Parameter Enumerations + **********************************************************************/ + + +typedef enum icalparameter_kind { + ICAL_NO_PARAMETER, + ICAL_ANY_PARAMETER, + ICAL_ALTREP_PARAMETER, /* DQUOTE uri DQUOTE */ + ICAL_CN_PARAMETER, /* text */ + ICAL_CUTYPE_PARAMETER, /*INDIVIDUAL, GROUP, RESOURCE,ROOM,UNKNOWN, x-name*/ + ICAL_DELEGATEDFROM_PARAMETER, /* *("," DQUOTE cal-address DQUOTE) */ + ICAL_DELEGATEDTO_PARAMETER, /* *("," DQUOTE cal-address DQUOTE) */ + ICAL_DIR_PARAMETER, /* DQUOTE uri DQUOTE */ + ICAL_ENCODING_PARAMETER, /* *BIT, BASE64, x-name */ + ICAL_FMTTYPE_PARAMETER, /* registered MINE content type */ + ICAL_FBTYPE_PARAMETER, /* FREE, BUSY, BUSY-UNAVAILABLE, BUSY-TENTATIVE,x-name */ + ICAL_LANGUAGE_PARAMETER, /* text from RFC 1766 */ + ICAL_MEMBER_PARAMETER, /* DQUOTE cal-address DQUOTE */ + ICAL_PARTSTAT_PARAMETER, /* NEEDS-ACTION, ACCEPTED, DECLINED, TENTATIVE, DELEGATED, x-name */ + ICAL_RANGE_PARAMETER, /* THISANDPRIOR, THISANDFUTURE */ + ICAL_RELATED_PARAMETER, /* START, END */ + ICAL_RELTYPE_PARAMETER, /* PARENT, CHILD, SIBLING,x-name */ + ICAL_ROLE_PARAMETER, /* CHAIR, REQ_PARTICIPANT, OPT_PARTICIPANT, NON_PARTICIPANT, x-name */ + ICAL_RSVP_PARAMETER, /* TRUE. FALSE */ + ICAL_SENTBY_PARAMETER, /* DQUOTE uri DQUOTE */ + ICAL_TZID_PARAMETER, /* [tzidprefix] paramtext CRLF */ + ICAL_VALUE_PARAMETER, /* BINARY, BOOLEAN, CAL_ADDRESS, DATE, DATE-TIME, DURATION, FLOAT, INTEGER, PERIOD, RECUR, TEXT, TIME, UTC_OFFSET, x-name */ + ICAL_XLICERRORTYPE_PARAMETER, /*ICAL_XLICERROR_PARSE_ERROR,ICAL_XLICERROR_INVALID_ITIP*/ + ICAL_XLICCOMPARETYPE_PARAMETER, /**/ + ICAL_X_PARAMETER /* text */ +} icalparameter_kind; + +typedef enum icalparameter_cutype { + ICAL_CUTYPE_INDIVIDUAL, + ICAL_CUTYPE_GROUP, + ICAL_CUTYPE_RESOURCE, + ICAL_CUTYPE_ROOM, + ICAL_CUTYPE_UNKNOWN, + ICAL_CUTYPE_XNAME +} icalparameter_cutype; + + +typedef enum icalparameter_encoding { + ICAL_ENCODING_8BIT, + ICAL_ENCODING_BASE64, + ICAL_ENCODING_XNAME +} icalparameter_encoding; + +typedef enum icalparameter_fbtype { + ICAL_FBTYPE_FREE, + ICAL_FBTYPE_BUSY, + ICAL_FBTYPE_BUSYUNAVAILABLE, + ICAL_FBTYPE_BUSYTENTATIVE, + ICAL_FBTYPE_XNAME +} icalparameter_fbtype; + +typedef enum icalparameter_partstat { + ICAL_PARTSTAT_NEEDSACTION, + ICAL_PARTSTAT_ACCEPTED, + ICAL_PARTSTAT_DECLINED, + ICAL_PARTSTAT_TENTATIVE, + ICAL_PARTSTAT_DELEGATED, + ICAL_PARTSTAT_COMPLETED, + ICAL_PARTSTAT_INPROCESS, + ICAL_PARTSTAT_XNAME, + ICAL_PARTSTAT_NONE +} icalparameter_partstat; + +typedef enum icalparameter_range { + ICAL_RANGE_THISANDPRIOR, + ICAL_RANGE_THISANDFUTURE +} icalparameter_range; + +typedef enum icalparameter_related { + ICAL_RELATED_START, + ICAL_RELATED_END +} icalparameter_related; + +typedef enum icalparameter_reltype { + ICAL_RELTYPE_PARENT, + ICAL_RELTYPE_CHILD, + ICAL_RELTYPE_SIBLING, + ICAL_RELTYPE_XNAME +} icalparameter_reltype; + +typedef enum icalparameter_role { + ICAL_ROLE_CHAIR, + ICAL_ROLE_REQPARTICIPANT, + ICAL_ROLE_OPTPARTICIPANT, + ICAL_ROLE_NONPARTICIPANT, + ICAL_ROLE_XNAME +} icalparameter_role; + +typedef enum icalparameter_xlicerrortype { + ICAL_XLICERRORTYPE_COMPONENTPARSEERROR, + ICAL_XLICERRORTYPE_PARAMETERVALUEPARSEERROR, + ICAL_XLICERRORTYPE_PARAMETERNAMEPARSEERROR, + ICAL_XLICERRORTYPE_PROPERTYPARSEERROR, + ICAL_XLICERRORTYPE_VALUEPARSEERROR, + ICAL_XLICERRORTYPE_UNKVCALPROP, + ICAL_XLICERRORTYPE_INVALIDITIP, + ICAL_XLICERRORTYPE_MIMEPARSEERROR +} icalparameter_xlicerrortype; + +typedef enum icalparameter_xliccomparetype { + ICAL_XLICCOMPARETYPE_EQUAL=0, + ICAL_XLICCOMPARETYPE_LESS=-1, + ICAL_XLICCOMPARETYPE_LESSEQUAL=2, + ICAL_XLICCOMPARETYPE_GREATER=1, + ICAL_XLICCOMPARETYPE_GREATEREQUAL=3, + ICAL_XLICCOMPARETYPE_NOTEQUAL=4, + ICAL_XLICCOMPARETYPE_REGEX=5 +} icalparameter_xliccomparetype; + +typedef enum icalparameter_value { + ICAL_VALUE_XNAME = ICAL_XNAME_VALUE, + ICAL_VALUE_BINARY = ICAL_BINARY_VALUE, + ICAL_VALUE_BOOLEAN = ICAL_BOOLEAN_VALUE, + ICAL_VALUE_CALADDRESS = ICAL_CALADDRESS_VALUE, + ICAL_VALUE_DATE = ICAL_DATE_VALUE, + ICAL_VALUE_DATETIME = ICAL_DATETIME_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_TIME = ICAL_TIME_VALUE, + ICAL_VALUE_UTCOFFSET = ICAL_UTCOFFSET_VALUE, + ICAL_VALUE_URI = ICAL_URI_VALUE, + ICAL_VALUE_ERROR = ICAL_NO_VALUE +} icalparameter_value; + + +/*********************************************************************** + * 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 +**********************************************************************/ + +const char* icalenum_property_kind_to_string(icalproperty_kind kind); +icalproperty_kind icalenum_string_to_property_kind(char* string); + +const char* icalenum_value_kind_to_string(icalvalue_kind kind); +icalvalue_kind icalenum_value_kind_by_prop(icalproperty_kind kind); + +const char* icalenum_parameter_kind_to_string(icalparameter_kind kind); +icalparameter_kind icalenum_string_to_parameter_kind(char* string); + +const char* icalenum_component_kind_to_string(icalcomponent_kind kind); +icalcomponent_kind icalenum_string_to_component_kind(char* string); + +icalvalue_kind icalenum_property_kind_to_value_kind(icalproperty_kind kind); + +const char* icalenum_method_to_string(icalproperty_method); +icalproperty_method icalenum_string_to_method(const char* string); + +const char* icalenum_status_to_string(icalproperty_status); +icalproperty_status icalenum_string_to_status(const char* string); + +#endif /* !ICALENUMS_H */ + + + /* -*- Mode: C -*- */ /*====================================================================== - FILE: ical.h + FILE: icaltypes.h CREATOR: eric 20 March 1999 @@ -17,34 +607,1836 @@ 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 ical.h + The original code is icaltypes.h ======================================================================*/ -#ifndef ICAL_H -#define ICAL_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; +}; + + + +union icaltriggertype +{ + struct icaltimetype time; + struct icaldurationtype duration; +}; + + + +/* 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(char* str); +char* icalreqstattype_as_string(struct icalreqstattype); + +#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/ + + +======================================================================*/ + +#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 +}; + +const char* icalrecur_recurrence_to_string(icalrecurrencetype_frequency kind); +const char* icalrecur_weekday_to_string(icalrecurrencetype_weekday kind); + + +/********************** Recurrence type routines **************/ + +/* See RFC 2445 Section 4.3.10, RECUR Value, for an explaination of + the values and fields in struct icalrecurrencetype */ + + +struct icalrecurrencetype +{ + icalrecurrencetype_frequency freq; + + + /* until and count are mutually exclusive. */ + struct icaltimetype until; /* Hack. Must be time_t for general use */ + 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 + * ICALRECURRENCE_ARRAY_MAX unless the the list is full. + */ + + short by_second[61]; + short by_minute[61]; + short by_hour[25]; + short by_day[8]; /* Encoded value, see below */ + short by_month_day[32]; + short by_year_day[367]; + short by_week_no[54]; + short by_month[13]; + short by_set_pos[367]; +}; + + +void icalrecurrencetype_clear(struct icalrecurrencetype *r); + +/* The 'day' element of icalrecurrencetype_weekday 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); + +/* Return the next occurance of 'r' after the time specified by 'after' */ +struct icaltimetype icalrecurrencetype_next_occurance( + struct icalrecurrencetype *r, + struct icaltimetype *after); + + + +typedef void icalrecur_iterator; +void icalrecurrencetype_test(); + + +/********** recurrence routines ********************/ + +icalrecur_iterator* icalrecur_iterator_new(struct icalrecurrencetype rule, struct icaltimetype dtstart); + +struct icaltimetype icalrecur_iterator_next(icalrecur_iterator*); + +int icalrecur_iterator_count(icalrecur_iterator*); + +void icalrecur_iterator_free(icalrecur_iterator*); -#include "icalversion.h" -#include "icalenums.h" -#include "icalvalue.h" -#include "icalparameter.h" -#include "icalproperty.h" -#include "icalcomponent.h" -#include "icaltypes.h" -#include "icalparser.h" -#include "icalmemory.h" -#include "icalerror.h" -#include "icalrestriction.h" -#include "icaltime.h" -#include "icalrecur.h" -#ifdef DMALLOC -#include "dmalloc.h" #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 ICALVALUE_H +#define ICALVALUE_H + +#include <time.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); + +/* Everything below this line is machine generated. Do not edit. */ +/* ATTACH # Non-std */ +icalvalue* icalvalue_new_attach(struct icalattachtype v); +struct icalattachtype icalvalue_get_attach(icalvalue* value); +void icalvalue_set_attach(icalvalue* value, struct icalattachtype 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); + +/* BOOLEAN */ +icalvalue* icalvalue_new_boolean(int v); +int icalvalue_get_boolean(icalvalue* value); +void icalvalue_set_boolean(icalvalue* value, int 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); + +/* DATE */ +icalvalue* icalvalue_new_date(struct icaltimetype v); +struct icaltimetype icalvalue_get_date(icalvalue* value); +void icalvalue_set_date(icalvalue* value, struct icaltimetype 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); + +/* DATE-TIME-DATE # Non-std */ +icalvalue* icalvalue_new_datetimedate(struct icaltimetype v); +struct icaltimetype icalvalue_get_datetimedate(icalvalue* value); +void icalvalue_set_datetimedate(icalvalue* value, struct icaltimetype v); + +/* DATE-TIME-PERIOD # Non-std */ +icalvalue* icalvalue_new_datetimeperiod(struct icalperiodtype v); +struct icalperiodtype icalvalue_get_datetimeperiod(icalvalue* value); +void icalvalue_set_datetimeperiod(icalvalue* value, struct icalperiodtype 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); + +/* FLOAT */ +icalvalue* icalvalue_new_float(float v); +float icalvalue_get_float(icalvalue* value); +void icalvalue_set_float(icalvalue* value, float v); + +/* GEO # Non-std */ +icalvalue* icalvalue_new_geo(struct icalgeotype v); +struct icalgeotype icalvalue_get_geo(icalvalue* value); +void icalvalue_set_geo(icalvalue* value, struct icalgeotype v); + +/* INTEGER */ +icalvalue* icalvalue_new_integer(int v); +int icalvalue_get_integer(icalvalue* value); +void icalvalue_set_integer(icalvalue* value, int v); + +/* METHOD # Non-std */ +icalvalue* icalvalue_new_method(icalproperty_method v); +icalproperty_method icalvalue_get_method(icalvalue* value); +void icalvalue_set_method(icalvalue* value, icalproperty_method 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); + +/* RECUR */ +icalvalue* icalvalue_new_recur(struct icalrecurrencetype v); +struct icalrecurrencetype icalvalue_get_recur(icalvalue* value); +void icalvalue_set_recur(icalvalue* value, struct icalrecurrencetype v); + +/* STRING # Non-std */ +icalvalue* icalvalue_new_string(const char* v); +const char* icalvalue_get_string(icalvalue* value); +void icalvalue_set_string(icalvalue* value, const char* 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); + +/* TIME */ +icalvalue* icalvalue_new_time(struct icaltimetype v); +struct icaltimetype icalvalue_get_time(icalvalue* value); +void icalvalue_set_time(icalvalue* value, struct icaltimetype v); + +/* TRIGGER # Non-std */ +icalvalue* icalvalue_new_trigger(union icaltriggertype v); +union icaltriggertype icalvalue_get_trigger(icalvalue* value); +void icalvalue_set_trigger(icalvalue* value, union icaltriggertype 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); + +/* UTC-OFFSET */ +icalvalue* icalvalue_new_utcoffset(int v); +int icalvalue_get_utcoffset(icalvalue* value); +void icalvalue_set_utcoffset(icalvalue* value, int v); + +/* 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 #Non-st */ +icalvalue* icalvalue_new_status(icalproperty_status v); +icalproperty_status icalvalue_get_status(icalvalue* value); +void icalvalue_set_status(icalvalue* value, icalproperty_status 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 ICALPARAM_H +#define ICALPARAM_H + + +typedef void icalparameter; + +icalparameter* icalparameter_new(icalparameter_kind kind); +icalparameter* icalparameter_new_clone(icalparameter* p); +icalparameter* icalparameter_new_from_string(icalparameter_kind kind, 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); + + +/* Everything below this line is machine generated. Do not edit. */ +/* ALTREP */ +icalparameter* icalparameter_new_altrep(const char* v); +const char* icalparameter_get_altrep(icalparameter* value); +void icalparameter_set_altrep(icalparameter* value, const char* 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); + +/* CUTYPE */ +icalparameter* icalparameter_new_cutype(icalparameter_cutype v); +icalparameter_cutype icalparameter_get_cutype(icalparameter* value); +void icalparameter_set_cutype(icalparameter* value, icalparameter_cutype v); + +/* 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); + +/* DIR */ +icalparameter* icalparameter_new_dir(const char* v); +const char* icalparameter_get_dir(icalparameter* value); +void icalparameter_set_dir(icalparameter* value, const char* 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); + +/* FBTYPE */ +icalparameter* icalparameter_new_fbtype(icalparameter_fbtype v); +icalparameter_fbtype icalparameter_get_fbtype(icalparameter* value); +void icalparameter_set_fbtype(icalparameter* value, icalparameter_fbtype 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); + +/* LANGUAGE */ +icalparameter* icalparameter_new_language(const char* v); +const char* icalparameter_get_language(icalparameter* value); +void icalparameter_set_language(icalparameter* value, const char* 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); + +/* PARTSTAT */ +icalparameter* icalparameter_new_partstat(icalparameter_partstat v); +icalparameter_partstat icalparameter_get_partstat(icalparameter* value); +void icalparameter_set_partstat(icalparameter* value, icalparameter_partstat 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); + +/* RELATED */ +icalparameter* icalparameter_new_related(icalparameter_related v); +icalparameter_related icalparameter_get_related(icalparameter* value); +void icalparameter_set_related(icalparameter* value, icalparameter_related 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); + +/* ROLE */ +icalparameter* icalparameter_new_role(icalparameter_role v); +icalparameter_role icalparameter_get_role(icalparameter* value); +void icalparameter_set_role(icalparameter* value, icalparameter_role v); + +/* RSVP */ +icalparameter* icalparameter_new_rsvp(int v); +int icalparameter_get_rsvp(icalparameter* value); +void icalparameter_set_rsvp(icalparameter* value, int 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); + +/* TZID */ +icalparameter* icalparameter_new_tzid(const char* v); +const char* icalparameter_get_tzid(icalparameter* value); +void icalparameter_set_tzid(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); + +/* X */ +icalparameter* icalparameter_new_x(const char* v); +const char* icalparameter_get_x(icalparameter* value); +void icalparameter_set_x(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-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); + +#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 ICALPROPERTY_H +#define ICALPROPERTY_H + +#include <time.h> + +typedef void icalproperty; + +icalproperty* icalproperty_new(icalproperty_kind kind); + +icalproperty* icalproperty_new_clone(icalproperty * prop); + +icalproperty* icalproperty_new_from_string(char* str); + +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_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); +icalvalue* icalproperty_get_value(icalproperty* prop); + +/* Deal with X properties */ + +void icalproperty_set_x_name(icalproperty* prop, char* name); +char* icalproperty_get_x_name(icalproperty* prop); + +/* Everything below this line is machine generated. Do not edit. */ + +/* METHOD */ +icalproperty* icalproperty_new_method(icalproperty_method v); +icalproperty* icalproperty_vanew_method(icalproperty_method v, ...); +void icalproperty_set_method(icalproperty* prop, icalproperty_method v); +icalproperty_method icalproperty_get_method(icalproperty* prop); + +/* X-LIC-MIMECID */ +icalproperty* icalproperty_new_xlicmimecid(const char* v); +icalproperty* icalproperty_vanew_xlicmimecid(const char* v, ...); +void icalproperty_set_xlicmimecid(icalproperty* prop, const char* v); +const char* icalproperty_get_xlicmimecid(icalproperty* prop); + +/* LAST-MODIFIED */ +icalproperty* icalproperty_new_lastmodified(struct icaltimetype v); +icalproperty* icalproperty_vanew_lastmodified(struct icaltimetype v, ...); +void icalproperty_set_lastmodified(icalproperty* prop, struct icaltimetype v); +struct icaltimetype icalproperty_get_lastmodified(icalproperty* prop); + +/* UID */ +icalproperty* icalproperty_new_uid(const char* v); +icalproperty* icalproperty_vanew_uid(const char* v, ...); +void icalproperty_set_uid(icalproperty* prop, const char* v); +const char* icalproperty_get_uid(icalproperty* prop); + +/* PRODID */ +icalproperty* icalproperty_new_prodid(const char* v); +icalproperty* icalproperty_vanew_prodid(const char* v, ...); +void icalproperty_set_prodid(icalproperty* prop, const char* v); +const char* icalproperty_get_prodid(icalproperty* prop); + +/* STATUS */ +icalproperty* icalproperty_new_status(icalproperty_status v); +icalproperty* icalproperty_vanew_status(icalproperty_status v, ...); +void icalproperty_set_status(icalproperty* prop, icalproperty_status v); +icalproperty_status icalproperty_get_status(icalproperty* prop); + +/* DESCRIPTION */ +icalproperty* icalproperty_new_description(const char* v); +icalproperty* icalproperty_vanew_description(const char* v, ...); +void icalproperty_set_description(icalproperty* prop, const char* v); +const char* icalproperty_get_description(icalproperty* prop); + +/* DURATION */ +icalproperty* icalproperty_new_duration(struct icaldurationtype v); +icalproperty* icalproperty_vanew_duration(struct icaldurationtype v, ...); +void icalproperty_set_duration(icalproperty* prop, struct icaldurationtype v); +struct icaldurationtype icalproperty_get_duration(icalproperty* prop); + +/* CATEGORIES */ +icalproperty* icalproperty_new_categories(const char* v); +icalproperty* icalproperty_vanew_categories(const char* v, ...); +void icalproperty_set_categories(icalproperty* prop, const char* v); +const char* icalproperty_get_categories(icalproperty* prop); + +/* VERSION */ +icalproperty* icalproperty_new_version(const char* v); +icalproperty* icalproperty_vanew_version(const char* v, ...); +void icalproperty_set_version(icalproperty* prop, const char* v); +const char* icalproperty_get_version(icalproperty* prop); + +/* TZOFFSETFROM */ +icalproperty* icalproperty_new_tzoffsetfrom(int v); +icalproperty* icalproperty_vanew_tzoffsetfrom(int v, ...); +void icalproperty_set_tzoffsetfrom(icalproperty* prop, int v); +int icalproperty_get_tzoffsetfrom(icalproperty* prop); + +/* RRULE */ +icalproperty* icalproperty_new_rrule(struct icalrecurrencetype v); +icalproperty* icalproperty_vanew_rrule(struct icalrecurrencetype v, ...); +void icalproperty_set_rrule(icalproperty* prop, struct icalrecurrencetype v); +struct icalrecurrencetype icalproperty_get_rrule(icalproperty* prop); + +/* ATTENDEE */ +icalproperty* icalproperty_new_attendee(const char* v); +icalproperty* icalproperty_vanew_attendee(const char* v, ...); +void icalproperty_set_attendee(icalproperty* prop, const char* v); +const char* icalproperty_get_attendee(icalproperty* prop); + +/* CONTACT */ +icalproperty* icalproperty_new_contact(const char* v); +icalproperty* icalproperty_vanew_contact(const char* v, ...); +void icalproperty_set_contact(icalproperty* prop, const char* v); +const char* icalproperty_get_contact(icalproperty* prop); + +/* X-LIC-MIMECONTENTTYPE */ +icalproperty* icalproperty_new_xlicmimecontenttype(const char* v); +icalproperty* icalproperty_vanew_xlicmimecontenttype(const char* v, ...); +void icalproperty_set_xlicmimecontenttype(icalproperty* prop, const char* v); +const char* icalproperty_get_xlicmimecontenttype(icalproperty* prop); + +/* X-LIC-MIMEOPTINFO */ +icalproperty* icalproperty_new_xlicmimeoptinfo(const char* v); +icalproperty* icalproperty_vanew_xlicmimeoptinfo(const char* v, ...); +void icalproperty_set_xlicmimeoptinfo(icalproperty* prop, const char* v); +const char* icalproperty_get_xlicmimeoptinfo(icalproperty* prop); + +/* RELATED-TO */ +icalproperty* icalproperty_new_relatedto(const char* v); +icalproperty* icalproperty_vanew_relatedto(const char* v, ...); +void icalproperty_set_relatedto(icalproperty* prop, const char* v); +const char* icalproperty_get_relatedto(icalproperty* prop); + +/* ORGANIZER */ +icalproperty* icalproperty_new_organizer(const char* v); +icalproperty* icalproperty_vanew_organizer(const char* v, ...); +void icalproperty_set_organizer(icalproperty* prop, const char* v); +const char* icalproperty_get_organizer(icalproperty* prop); + +/* COMMENT */ +icalproperty* icalproperty_new_comment(const char* v); +icalproperty* icalproperty_vanew_comment(const char* v, ...); +void icalproperty_set_comment(icalproperty* prop, const char* v); +const char* icalproperty_get_comment(icalproperty* prop); + +/* X-LIC-ERROR */ +icalproperty* icalproperty_new_xlicerror(const char* v); +icalproperty* icalproperty_vanew_xlicerror(const char* v, ...); +void icalproperty_set_xlicerror(icalproperty* prop, const char* v); +const char* icalproperty_get_xlicerror(icalproperty* prop); + +/* TRIGGER */ +icalproperty* icalproperty_new_trigger(union icaltriggertype v); +icalproperty* icalproperty_vanew_trigger(union icaltriggertype v, ...); +void icalproperty_set_trigger(icalproperty* prop, union icaltriggertype v); +union icaltriggertype icalproperty_get_trigger(icalproperty* prop); + +/* CLASS */ +icalproperty* icalproperty_new_class(const char* v); +icalproperty* icalproperty_vanew_class(const char* v, ...); +void icalproperty_set_class(icalproperty* prop, const char* v); +const char* icalproperty_get_class(icalproperty* prop); + +/* X */ +icalproperty* icalproperty_new_x(const char* v); +icalproperty* icalproperty_vanew_x(const char* v, ...); +void icalproperty_set_x(icalproperty* prop, const char* v); +const char* icalproperty_get_x(icalproperty* prop); + +/* TZOFFSETTO */ +icalproperty* icalproperty_new_tzoffsetto(int v); +icalproperty* icalproperty_vanew_tzoffsetto(int v, ...); +void icalproperty_set_tzoffsetto(icalproperty* prop, int v); +int icalproperty_get_tzoffsetto(icalproperty* prop); + +/* TRANSP */ +icalproperty* icalproperty_new_transp(const char* v); +icalproperty* icalproperty_vanew_transp(const char* v, ...); +void icalproperty_set_transp(icalproperty* prop, const char* v); +const char* icalproperty_get_transp(icalproperty* prop); + +/* X-LIC-MIMEENCODING */ +icalproperty* icalproperty_new_xlicmimeencoding(const char* v); +icalproperty* icalproperty_vanew_xlicmimeencoding(const char* v, ...); +void icalproperty_set_xlicmimeencoding(icalproperty* prop, const char* v); +const char* icalproperty_get_xlicmimeencoding(icalproperty* prop); + +/* SEQUENCE */ +icalproperty* icalproperty_new_sequence(int v); +icalproperty* icalproperty_vanew_sequence(int v, ...); +void icalproperty_set_sequence(icalproperty* prop, int v); +int icalproperty_get_sequence(icalproperty* prop); + +/* LOCATION */ +icalproperty* icalproperty_new_location(const char* v); +icalproperty* icalproperty_vanew_location(const char* v, ...); +void icalproperty_set_location(icalproperty* prop, const char* v); +const char* icalproperty_get_location(icalproperty* prop); + +/* REQUEST-STATUS */ +icalproperty* icalproperty_new_requeststatus(const char* v); +icalproperty* icalproperty_vanew_requeststatus(const char* v, ...); +void icalproperty_set_requeststatus(icalproperty* prop, const char* v); +const char* icalproperty_get_requeststatus(icalproperty* prop); + +/* EXDATE */ +icalproperty* icalproperty_new_exdate(struct icaltimetype v); +icalproperty* icalproperty_vanew_exdate(struct icaltimetype v, ...); +void icalproperty_set_exdate(icalproperty* prop, struct icaltimetype v); +struct icaltimetype icalproperty_get_exdate(icalproperty* prop); + +/* TZID */ +icalproperty* icalproperty_new_tzid(const char* v); +icalproperty* icalproperty_vanew_tzid(const char* v, ...); +void icalproperty_set_tzid(icalproperty* prop, const char* v); +const char* icalproperty_get_tzid(icalproperty* prop); + +/* RESOURCES */ +icalproperty* icalproperty_new_resources(const char* v); +icalproperty* icalproperty_vanew_resources(const char* v, ...); +void icalproperty_set_resources(icalproperty* prop, const char* v); +const char* icalproperty_get_resources(icalproperty* prop); + +/* TZURL */ +icalproperty* icalproperty_new_tzurl(const char* v); +icalproperty* icalproperty_vanew_tzurl(const char* v, ...); +void icalproperty_set_tzurl(icalproperty* prop, const char* v); +const char* icalproperty_get_tzurl(icalproperty* prop); + +/* REPEAT */ +icalproperty* icalproperty_new_repeat(int v); +icalproperty* icalproperty_vanew_repeat(int v, ...); +void icalproperty_set_repeat(icalproperty* prop, int v); +int icalproperty_get_repeat(icalproperty* prop); + +/* PRIORITY */ +icalproperty* icalproperty_new_priority(int v); +icalproperty* icalproperty_vanew_priority(int v, ...); +void icalproperty_set_priority(icalproperty* prop, int v); +int icalproperty_get_priority(icalproperty* prop); + +/* FREEBUSY */ +icalproperty* icalproperty_new_freebusy(struct icalperiodtype v); +icalproperty* icalproperty_vanew_freebusy(struct icalperiodtype v, ...); +void icalproperty_set_freebusy(icalproperty* prop, struct icalperiodtype v); +struct icalperiodtype icalproperty_get_freebusy(icalproperty* prop); + +/* DTSTART */ +icalproperty* icalproperty_new_dtstart(struct icaltimetype v); +icalproperty* icalproperty_vanew_dtstart(struct icaltimetype v, ...); +void icalproperty_set_dtstart(icalproperty* prop, struct icaltimetype v); +struct icaltimetype icalproperty_get_dtstart(icalproperty* prop); + +/* RECURRENCE-ID */ +icalproperty* icalproperty_new_recurrenceid(struct icaltimetype v); +icalproperty* icalproperty_vanew_recurrenceid(struct icaltimetype v, ...); +void icalproperty_set_recurrenceid(icalproperty* prop, struct icaltimetype v); +struct icaltimetype icalproperty_get_recurrenceid(icalproperty* prop); + +/* SUMMARY */ +icalproperty* icalproperty_new_summary(const char* v); +icalproperty* icalproperty_vanew_summary(const char* v, ...); +void icalproperty_set_summary(icalproperty* prop, const char* v); +const char* icalproperty_get_summary(icalproperty* prop); + +/* DTEND */ +icalproperty* icalproperty_new_dtend(struct icaltimetype v); +icalproperty* icalproperty_vanew_dtend(struct icaltimetype v, ...); +void icalproperty_set_dtend(icalproperty* prop, struct icaltimetype v); +struct icaltimetype icalproperty_get_dtend(icalproperty* prop); + +/* TZNAME */ +icalproperty* icalproperty_new_tzname(const char* v); +icalproperty* icalproperty_vanew_tzname(const char* v, ...); +void icalproperty_set_tzname(icalproperty* prop, const char* v); +const char* icalproperty_get_tzname(icalproperty* prop); + +/* RDATE */ +icalproperty* icalproperty_new_rdate(struct icalperiodtype v); +icalproperty* icalproperty_vanew_rdate(struct icalperiodtype v, ...); +void icalproperty_set_rdate(icalproperty* prop, struct icalperiodtype v); +struct icalperiodtype icalproperty_get_rdate(icalproperty* prop); + +/* X-LIC-MIMEFILENAME */ +icalproperty* icalproperty_new_xlicmimefilename(const char* v); +icalproperty* icalproperty_vanew_xlicmimefilename(const char* v, ...); +void icalproperty_set_xlicmimefilename(icalproperty* prop, const char* v); +const char* icalproperty_get_xlicmimefilename(icalproperty* prop); + +/* URL */ +icalproperty* icalproperty_new_url(const char* v); +icalproperty* icalproperty_vanew_url(const char* v, ...); +void icalproperty_set_url(icalproperty* prop, const char* v); +const char* icalproperty_get_url(icalproperty* prop); + +/* X-LIC-CLUSTERCOUNT */ +icalproperty* icalproperty_new_xlicclustercount(int v); +icalproperty* icalproperty_vanew_xlicclustercount(int v, ...); +void icalproperty_set_xlicclustercount(icalproperty* prop, int v); +int icalproperty_get_xlicclustercount(icalproperty* prop); + +/* ATTACH */ +icalproperty* icalproperty_new_attach(struct icalattachtype v); +icalproperty* icalproperty_vanew_attach(struct icalattachtype v, ...); +void icalproperty_set_attach(icalproperty* prop, struct icalattachtype v); +struct icalattachtype icalproperty_get_attach(icalproperty* prop); + +/* EXRULE */ +icalproperty* icalproperty_new_exrule(struct icalrecurrencetype v); +icalproperty* icalproperty_vanew_exrule(struct icalrecurrencetype v, ...); +void icalproperty_set_exrule(icalproperty* prop, struct icalrecurrencetype v); +struct icalrecurrencetype icalproperty_get_exrule(icalproperty* prop); + +/* QUERY */ +icalproperty* icalproperty_new_query(const char* v); +icalproperty* icalproperty_vanew_query(const char* v, ...); +void icalproperty_set_query(icalproperty* prop, const char* v); +const char* icalproperty_get_query(icalproperty* prop); + +/* PERCENT-COMPLETE */ +icalproperty* icalproperty_new_percentcomplete(int v); +icalproperty* icalproperty_vanew_percentcomplete(int v, ...); +void icalproperty_set_percentcomplete(icalproperty* prop, int v); +int icalproperty_get_percentcomplete(icalproperty* prop); + +/* CALSCALE */ +icalproperty* icalproperty_new_calscale(const char* v); +icalproperty* icalproperty_vanew_calscale(const char* v, ...); +void icalproperty_set_calscale(icalproperty* prop, const char* v); +const char* icalproperty_get_calscale(icalproperty* prop); + +/* CREATED */ +icalproperty* icalproperty_new_created(struct icaltimetype v); +icalproperty* icalproperty_vanew_created(struct icaltimetype v, ...); +void icalproperty_set_created(icalproperty* prop, struct icaltimetype v); +struct icaltimetype icalproperty_get_created(icalproperty* prop); + +/* GEO */ +icalproperty* icalproperty_new_geo(struct icalgeotype v); +icalproperty* icalproperty_vanew_geo(struct icalgeotype v, ...); +void icalproperty_set_geo(icalproperty* prop, struct icalgeotype v); +struct icalgeotype icalproperty_get_geo(icalproperty* prop); + +/* X-LIC-MIMECHARSET */ +icalproperty* icalproperty_new_xlicmimecharset(const char* v); +icalproperty* icalproperty_vanew_xlicmimecharset(const char* v, ...); +void icalproperty_set_xlicmimecharset(icalproperty* prop, const char* v); +const char* icalproperty_get_xlicmimecharset(icalproperty* prop); + +/* COMPLETED */ +icalproperty* icalproperty_new_completed(struct icaltimetype v); +icalproperty* icalproperty_vanew_completed(struct icaltimetype v, ...); +void icalproperty_set_completed(icalproperty* prop, struct icaltimetype v); +struct icaltimetype icalproperty_get_completed(icalproperty* prop); + +/* DTSTAMP */ +icalproperty* icalproperty_new_dtstamp(struct icaltimetype v); +icalproperty* icalproperty_vanew_dtstamp(struct icaltimetype v, ...); +void icalproperty_set_dtstamp(icalproperty* prop, struct icaltimetype v); +struct icaltimetype icalproperty_get_dtstamp(icalproperty* prop); + +/* DUE */ +icalproperty* icalproperty_new_due(struct icaltimetype v); +icalproperty* icalproperty_vanew_due(struct icaltimetype v, ...); +void icalproperty_set_due(icalproperty* prop, struct icaltimetype v); +struct icaltimetype icalproperty_get_due(icalproperty* prop); + +/* ACTION */ +icalproperty* icalproperty_new_action(const char* v); +icalproperty* icalproperty_vanew_action(const char* v, ...); +void icalproperty_set_action(icalproperty* prop, const char* v); +const char* icalproperty_get_action(icalproperty* prop); +#endif /*ICALPROPERTY_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); + +/* Return a null-terminated array of icalproperties*/ + +icalproperty** icalcomponent_get_properties(icalcomponent* component, + icalproperty_kind kind); + + +/* + * Working with components + */ + + +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. + +The internal iterators are deprecated. */ + +/* Using external iterators */ +icalcompiter icalcomponent_begin_component(icalcomponent* component, + icalcomponent_kind kind); + +icalcompiter icalcomponent_end_component(icalcomponent* component, + icalcomponent_kind kind); + +/* 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); + + + + +/* 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. You don't see these... */ +icalcomponent* icalcomponent_get_parent(icalcomponent* component); +void icalcomponent_set_parent(icalcomponent* component, + icalcomponent* parent); +/* External component iterator */ +icalcomponent* icalcompiter_next(icalcompiter* i); +icalcomponent* icalcompiter_prior(icalcompiter* i); +icalcomponent* icalcompiter_deref(icalcompiter* i); + +/************* 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_organizer(icalcomponent* comp, const char* v); +const char* icalcomponent_get_organizer(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); + +/*************** Type Specific routines ***************/ + +icalcomponent* icalcomponent_new_vcalendar(); +icalcomponent* icalcomponent_new_vevent(); +icalcomponent* icalcomponent_new_vtodo(); +icalcomponent* icalcomponent_new_vjournal(); +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_claim(icalparser* parser); +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(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 */ +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 + + +/* 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); + +#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 +#define icalerror_assert(test,message) +#endif + +/* Check & abort if check fails */ +#ifdef ICAL_ERRORS_ARE_FATAL +#define icalerror_check_arg(test,arg) icalerror_stop_here();assert(test) +#else +#define icalerror_check_arg(test,arg) +#endif +/* Check & return void if check fails*/ + +#ifdef ICAL_ERRORS_ARE_FATAL +#define icalerror_check_arg_rv(test,arg) icalerror_stop_here();assert(test); +#else +#define icalerror_check_arg_rv(test,arg) if(!(test)) { icalerror_set_errno(ICAL_BADARG_ERROR); return; } +#endif + +/* Check & return 0 if check fails*/ +#ifdef ICAL_ERRORS_ARE_FATAL +#define icalerror_check_arg_rz(test,arg) icalerror_stop_here();assert(test); +#else +#define icalerror_check_arg_rz(test,arg) if(!(test)) {icalerror_set_errno(ICAL_BADARG_ERROR); return 0;} +#endif + + +/* Check & return an error if check fails*/ +#ifdef ICAL_ERRORS_ARE_FATAL +#define icalerror_check_arg_re(test,arg,error) icalerror_stop_here();assert(test); +#else +#define icalerror_check_arg_re(test,arg,error) if(!(test)) {icalerror_stop_here(); return error;} +#endif + + +/* Warning messages */ + +#ifdef ICAL_ERRORS_ARE_FATAL + +#ifdef __GNUC__ +#define icalerror_warn(message) {fprintf(stderr,"%s(), %s:%d: %s\n",__FUNCTION__,__FILE__,__LINE__,message); abort();} +#else /* __GNU_C__ */ +#define icalerror_warn(message) {fprintf(stderr,"%s:%d: %s\n",__FILE__,__LINE__,message); abort();} +#endif /* __GNU_C__ */ + +#else /*ICAL_ERRORS_ARE_FATAL */ + +#ifdef __GNUC__ +#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__ */ + +#endif /*ICAL_ERRORS_ARE_FATAL*/ + +typedef enum icalerrorenum { + + ICAL_BADARG_ERROR, + ICAL_NEWFAILED_ERROR, + ICAL_MALFORMEDDATA_ERROR, + ICAL_PARSE_ERROR, + ICAL_INTERNAL_ERROR, /* Like assert --internal consist. prob */ + ICAL_FILE_ERROR, + ICAL_ALLOCATION_ERROR, + ICAL_USAGE_ERROR, + ICAL_NO_ERROR, + ICAL_MULTIPLEINCLUSION_ERROR, + ICAL_TIMEDOUT_ERROR, + ICAL_UNKNOWN_ERROR /* Used for problems in input to icalerror_strerror()*/ + +} icalerrorenum; + +extern icalerrorenum icalerrno; + + +void icalerror_clear_errno(void); +void icalerror_set_errno(icalerrorenum); + +char* icalerror_strerror(icalerrorenum e); + + +#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_major_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 /* !ICAL_H */ +#endif /* !ICALMIME_H */ diff --git a/libical/src/libical/icalcomponent.c b/libical/src/libical/icalcomponent.c index 65d1d55e36..2b8ddb5137 100644 --- a/libical/src/libical/icalcomponent.c +++ b/libical/src/libical/icalcomponent.c @@ -26,28 +26,21 @@ #include "config.h" #endif -#include "ical.h" +#include "icalcomponent.h" #include "pvl.h" /* "Pointer-to-void list" */ +#include "icalerror.h" +#include "icalmemory.h" +#include "icalenums.h" +#include "icaltime.h" + #include <stdlib.h> /* for malloc */ #include <stdarg.h> /* for va_list, etc */ #include <errno.h> -#include "icalerror.h" #include <assert.h> #include <stdio.h> /* for fprintf */ -#include "icalmemory.h" -#include "icalenums.h" #define MAX_TMP 1024 - -/* icalproperty functions that only components get to use */ -void icalproperty_set_parent(icalproperty* property, - icalcomponent* component); - -icalcomponent* icalproperty_get_parent(icalproperty* property); - - - struct icalcomponent_impl { char id[5]; @@ -60,6 +53,15 @@ struct icalcomponent_impl 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; @@ -255,7 +257,7 @@ icalcomponent_as_ical_string (icalcomponent* component) icalproperty *p; icalcomponent_kind kind = icalcomponent_isa(component); - char* kind_string; + const char* kind_string; buf = icalmemory_new_buffer(buf_size); buf_ptr = buf; @@ -359,7 +361,7 @@ icalcomponent_isa_component (void* component) int icalcomponent_property_sorter(void *a, void *b) { icalproperty_kind kinda, kindb; - char *ksa, *ksb; + const char *ksa, *ksb; kinda = icalproperty_isa((icalproperty*)a); kindb = icalproperty_isa((icalproperty*)b); @@ -530,7 +532,7 @@ icalcomponent_add_component (icalcomponent* parent, icalcomponent* child) impl = (struct icalcomponent_impl*)parent; cimpl = (struct icalcomponent_impl*)child; - icalerror_assert( (cimpl->parent ==0),"The child component has already been added to a parent component. Remove the component with icalcomponent_remove_componenet before calling icalcomponent_add_component"); + icalerror_assert( (cimpl->parent ==0),"The child component has already been added to a parent component. Remove the component with icalcomponent_remove_component before calling icalcomponent_add_component"); cimpl->parent = parent; @@ -580,8 +582,7 @@ icalcomponent_count_components (icalcomponent* component, { int count=0; pvl_elem itr; - struct icalcomponent_impl *impl = - (struct icalcomponent_impl*)component; + struct icalcomponent_impl *impl = (struct icalcomponent_impl*)component; icalerror_check_arg_rz( (component!=0), "component"); @@ -662,9 +663,186 @@ icalcomponent_get_next_component (icalcomponent* component, icalcomponent_kind k return 0; } +icalcomponent* icalcomponent_get_first_real_component(icalcomponent *c) +{ + icalcomponent *comp; -icalproperty** -icalcomponent_get_component (icalcomponent* component, icalproperty_kind kind); + 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 ){ + 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_set_errno(ICAL_MALFORMEDDATA_ERROR); + icalerror_warn("icalcomponent_get_span: component has a UTC DTSTART with a timezone specified "); + 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_local_utc_offset(); + 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_timet(dur); + span.end = span.start+durt; + } + + return span; + +} int icalcomponent_count_errors(icalcomponent* component) @@ -840,7 +1018,7 @@ icalcomponent_begin_component(icalcomponent* component,icalcomponent_kind kind) } } - return icalcompiter_null;; + return icalcompiter_null; } icalcompiter @@ -876,6 +1054,8 @@ icalcomponent* icalcompiter_next(icalcompiter* i) 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)) { @@ -923,3 +1103,298 @@ icalcomponent* icalcompiter_deref(icalcompiter* i) 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); + time_t startt = icaltime_as_timet(start); + struct icaldurationtype duration = + icalproperty_get_duration(dur_prop); + time_t durt = icaldurationtype_as_timet(duration); + + return icaltime_from_timet(startt+durt,start.is_date,start.is_utc); + } 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); + time_t startt = icaltime_as_timet(start); + + struct icaltimetype end = + icalcomponent_get_dtend(inner); + time_t endt = icaltime_as_timet(end); + + struct icaldurationtype dur + = icaldurationtype_from_timet(endt-startt); + + 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); + time_t startt = icaltime_as_timet(start); + + time_t durt = icaldurationtype_as_timet(v); + + struct icaltimetype new_end + = icaltime_from_timet(startt+durt,start.is_date,start.is_utc); + + icalproperty_set_dtend(end_prop,new_end); + + } else if ( dur_prop != 0) { + icalproperty_set_duration(end_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_timet(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); +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_organizer(icalcomponent* comp, const char* v); +const char* icalcomponent_get_organizer(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_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 index b0d1e33630..b08d488db3 100644 --- a/libical/src/libical/icalcomponent.h +++ b/libical/src/libical/icalcomponent.h @@ -119,9 +119,6 @@ icalcomponent* icalcomponent_get_next_component(icalcomponent* component, -/* Return a null-terminated array of icalproperties*/ -icalproperty** icalcomponent_get_component(icalcomponent* component, - icalproperty_kind kind); /* Working with embedded error properties */ @@ -137,14 +134,82 @@ void icalcomponent_convert_errors(icalcomponent* component); icalcomponent* icalcomponent_get_parent(icalcomponent* component); void icalcomponent_set_parent(icalcomponent* component, icalcomponent* parent); - - - /* External component iterator */ icalcomponent* icalcompiter_next(icalcompiter* i); icalcomponent* icalcompiter_prior(icalcompiter* i); icalcomponent* icalcompiter_deref(icalcompiter* i); +/************* 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_organizer(icalcomponent* comp, const char* v); +const char* icalcomponent_get_organizer(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); + +/*************** Type Specific routines ***************/ + +icalcomponent* icalcomponent_new_vcalendar(); +icalcomponent* icalcomponent_new_vevent(); +icalcomponent* icalcomponent_new_vtodo(); +icalcomponent* icalcomponent_new_vjournal(); +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/icalenums.c b/libical/src/libical/icalenums.c index 50d23c8d41..2e04214739 100644 --- a/libical/src/libical/icalenums.c +++ b/libical/src/libical/icalenums.c @@ -5,6 +5,7 @@ $Id$ + (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org This program is free software; you can redistribute it and/or modify @@ -29,9 +30,13 @@ #include "icalenums.h" +#include <stdio.h> /* For fprintf */ +#include <stdio.h> /* For stderr */ +#include <assert.h> + struct icalproperty_kind_map { icalproperty_kind kind; - char *name; + const char *name; }; static struct icalproperty_kind_map property_map[] = @@ -107,7 +112,7 @@ static struct icalproperty_kind_map property_map[] = }; -char* icalenum_property_kind_to_string(icalproperty_kind kind) +const char* icalenum_property_kind_to_string(icalproperty_kind kind) { int i; @@ -179,7 +184,7 @@ static struct icalparameter_kind_map parameter_map[] = { ICAL_NO_PARAMETER, ""} }; -char* icalenum_parameter_kind_to_string(icalparameter_kind kind) +const char* icalenum_parameter_kind_to_string(icalparameter_kind kind) { int i; @@ -232,6 +237,7 @@ static struct icalvalue_kind_map value_map[] = { ICAL_URI_VALUE, "URI"}, { ICAL_UTCOFFSET_VALUE, "UTC-OFFSET"}, { ICAL_METHOD_VALUE, "METHOD"}, /* Not an RFC2445 type */ + { ICAL_STATUS_VALUE, "STATUS"}, /* Not an RFC2445 type */ { ICAL_GEO_VALUE, "FLOAT"}, /* Not an RFC2445 type */ { ICAL_ATTACH_VALUE, "XATTACH"}, /* Not an RFC2445 type */ { ICAL_DATETIMEDATE_VALUE, "XDATETIMEDATE"}, /* Not an RFC2445 type */ @@ -240,7 +246,7 @@ static struct icalvalue_kind_map value_map[] = { ICAL_NO_VALUE, ""}, }; -char* icalenum_value_kind_to_string(icalvalue_kind kind) +const char* icalenum_value_kind_to_string(icalvalue_kind kind) { int i; @@ -256,7 +262,9 @@ char* icalenum_value_kind_to_string(icalvalue_kind kind) icalvalue_kind icalenum_value_kind_by_prop(icalproperty_kind kind) { - + fprintf(stderr,"icalenum_value_kind_by_prop is not implemented\n"); + assert(0) ; + kind = ICAL_NO_VALUE; return ICAL_NO_VALUE; } @@ -297,7 +305,7 @@ static struct icalcomponent_kind_map component_map[] = { ICAL_NO_COMPONENT, "" }, }; -char* icalenum_component_kind_to_string(icalcomponent_kind kind) +const char* icalenum_component_kind_to_string(icalcomponent_kind kind) { int i; @@ -347,7 +355,7 @@ static struct icalproperty_kind_value_map propval_map[] = { ICAL_PERCENTCOMPLETE_PROPERTY, ICAL_INTEGER_VALUE }, { ICAL_PRIORITY_PROPERTY, ICAL_INTEGER_VALUE }, { ICAL_RESOURCES_PROPERTY, ICAL_TEXT_VALUE }, - { ICAL_STATUS_PROPERTY, ICAL_TEXT_VALUE }, + { ICAL_STATUS_PROPERTY, ICAL_STATUS_VALUE }, { ICAL_SUMMARY_PROPERTY, ICAL_TEXT_VALUE }, { ICAL_COMPLETED_PROPERTY, ICAL_DATETIME_VALUE }, { ICAL_FREEBUSY_PROPERTY, ICAL_PERIOD_VALUE }, @@ -416,65 +424,13 @@ icalvalue_kind icalenum_property_kind_to_value_kind(icalproperty_kind kind) return ICAL_NO_VALUE; } -struct {icalrecurrencetype_weekday wd; 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} -}; - -char* icalenum_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; -} - - -struct { - icalrecurrencetype_frequency kind; - 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} -}; - -char* icalenum_recurrence_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; -} - struct { - icalrecurrencetype_frequency kind; + enum icalrequeststatus kind; int major; int minor; - char* str; -} status_map[] = { + 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."}, @@ -511,14 +467,14 @@ struct { }; -char* icalenum_reqstat_desc(icalrequeststatus stat) +const char* icalenum_reqstat_desc(icalrequeststatus stat) { int i; - for (i=0; status_map[i].kind != ICAL_UNKNOWN_STATUS; i++) { - if ( status_map[i].kind == stat) { - return status_map[i].str; + 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; } } @@ -530,9 +486,9 @@ short icalenum_reqstat_major(icalrequeststatus stat) { int i; - for (i=0; status_map[i].kind != ICAL_UNKNOWN_STATUS; i++) { - if ( status_map[i].kind == stat) { - return status_map[i].major; + 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; @@ -542,9 +498,9 @@ short icalenum_reqstat_minor(icalrequeststatus stat) { int i; - for (i=0; status_map[i].kind != ICAL_UNKNOWN_STATUS; i++) { - if ( status_map[i].kind == stat) { - return status_map[i].minor; + 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; @@ -555,9 +511,9 @@ icalrequeststatus icalenum_num_to_reqstat(short major, short minor) { int i; - for (i=0; status_map[i].kind != ICAL_UNKNOWN_STATUS; i++) { - if ( status_map[i].major == major && status_map[i].minor == minor) { - return status_map[i].kind; + 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; @@ -565,7 +521,7 @@ icalrequeststatus icalenum_num_to_reqstat(short major, short minor) -struct {icalproperty_method method; char* str;} method_map[] = { +struct {icalproperty_method method; const char* str;} method_map[] = { {ICAL_METHOD_PUBLISH,"PUBLISH"}, {ICAL_METHOD_REQUEST,"REQUEST"}, {ICAL_METHOD_REPLY,"REPLY"}, @@ -586,7 +542,7 @@ struct {icalproperty_method method; char* str;} method_map[] = { }; -char* icalenum_method_to_string(icalproperty_method method) +const char* icalenum_method_to_string(icalproperty_method method) { int i; @@ -599,7 +555,7 @@ char* icalenum_method_to_string(icalproperty_method method) return method_map[i].str; /* should be ICAL_METHOD_NONE */ } -icalproperty_method icalenum_string_to_method(char* str) +icalproperty_method icalenum_string_to_method(const char* str) { int i; @@ -616,3 +572,46 @@ icalproperty_method icalenum_string_to_method(char* str) return ICAL_METHOD_NONE; } + + +struct {icalproperty_status status; const char* str;} status_map[] = { + {ICAL_STATUS_TENTATIVE,"TENTATIVE"}, + {ICAL_STATUS_CONFIRMED,"CONFIRMED"}, + {ICAL_STATUS_NEEDSACTION,"NEEDS-ACTION"}, + {ICAL_STATUS_COMPLETED,"COMPLETED"}, + {ICAL_STATUS_INPROCESS,"IN-PROCESS"}, + {ICAL_STATUS_DRAFT,"DRAFT"}, + {ICAL_STATUS_FINAL,"FINAL"}, + {ICAL_STATUS_NONE,"NONE"} +}; + +const char* icalenum_status_to_string(icalproperty_status status) +{ + int i; + + for (i=0; status_map[i].status != ICAL_STATUS_NONE; i++) { + if ( status_map[i].status == status) { + return status_map[i].str; + } + } + + return status_map[i].str; /* should be ICAL_STATUS_NONE */ +} + +icalproperty_status icalenum_string_to_status(const char* str) +{ + int i; + + while(*str == ' '){ + str++; + } + + + for (i=0; status_map[i].status != ICAL_STATUS_NONE; i++) { + if ( strcmp(status_map[i].str, str) == 0) { + return status_map[i].status; + } + } + + return ICAL_STATUS_NONE; +} diff --git a/libical/src/libical/icalenums.h b/libical/src/libical/icalenums.h index ba3137803e..ab25532cf6 100644 --- a/libical/src/libical/icalenums.h +++ b/libical/src/libical/icalenums.h @@ -183,9 +183,10 @@ typedef enum icalproperty_class { typedef enum icalproperty_status { + ICAL_STATUS_NONE, ICAL_STATUS_TENTATIVE, ICAL_STATUS_CONFIRMED, - ICAL_STATUS_CANCELLED, /* CANCELED? SIC */ + ICAL_STATUS_CANCELLED, /* CANCELED? SIC from RFC*/ ICAL_STATUS_NEEDSACTION, ICAL_STATUS_COMPLETED, ICAL_STATUS_INPROCESS, @@ -220,6 +221,7 @@ typedef enum icalvalue_kind { ICAL_GEO_VALUE, /* Non-Standard */ ICAL_INTEGER_VALUE, ICAL_METHOD_VALUE, /* Non-Standard */ + ICAL_STATUS_VALUE, /* Non-Standard */ ICAL_PERIOD_VALUE, ICAL_RECUR_VALUE, ICAL_STRING_VALUE, /* Non-Standard */ @@ -298,7 +300,8 @@ typedef enum icalparameter_partstat { ICAL_PARTSTAT_DELEGATED, ICAL_PARTSTAT_COMPLETED, ICAL_PARTSTAT_INPROCESS, - ICAL_PARTSTAT_XNAME + ICAL_PARTSTAT_XNAME, + ICAL_PARTSTAT_NONE } icalparameter_partstat; typedef enum icalparameter_range { @@ -334,7 +337,7 @@ typedef enum icalparameter_xlicerrortype { ICAL_XLICERRORTYPE_VALUEPARSEERROR, ICAL_XLICERRORTYPE_UNKVCALPROP, ICAL_XLICERRORTYPE_INVALIDITIP, - ICAL_XLICERRORTYPE_MIMEPARSEERROR, + ICAL_XLICERRORTYPE_MIMEPARSEERROR } icalparameter_xlicerrortype; typedef enum icalparameter_xliccomparetype { @@ -366,46 +369,6 @@ typedef enum icalparameter_value { ICAL_VALUE_ERROR = ICAL_NO_VALUE } icalparameter_value; -/*********************************************************************** - * Recurrances -**********************************************************************/ - -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 -}; - - -char* icalenum_recurrence_to_string(icalrecurrencetype_frequency kind); -char* icalenum_weekday_to_string(icalrecurrencetype_weekday kind); /*********************************************************************** * Request Status codes @@ -448,7 +411,7 @@ typedef enum icalrequeststatus { } icalrequeststatus; -char* icalenum_reqstat_desc(icalrequeststatus stat); +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); @@ -457,22 +420,25 @@ icalrequeststatus icalenum_num_to_reqstat(short major, short minor); * Conversion functions **********************************************************************/ -char* icalenum_property_kind_to_string(icalproperty_kind kind); +const char* icalenum_property_kind_to_string(icalproperty_kind kind); icalproperty_kind icalenum_string_to_property_kind(char* string); -char* icalenum_value_kind_to_string(icalvalue_kind kind); +const char* icalenum_value_kind_to_string(icalvalue_kind kind); icalvalue_kind icalenum_value_kind_by_prop(icalproperty_kind kind); -char* icalenum_parameter_kind_to_string(icalparameter_kind kind); +const char* icalenum_parameter_kind_to_string(icalparameter_kind kind); icalparameter_kind icalenum_string_to_parameter_kind(char* string); -char* icalenum_component_kind_to_string(icalcomponent_kind kind); +const char* icalenum_component_kind_to_string(icalcomponent_kind kind); icalcomponent_kind icalenum_string_to_component_kind(char* string); icalvalue_kind icalenum_property_kind_to_value_kind(icalproperty_kind kind); -char* icalenum_method_to_string(icalproperty_method); -icalproperty_method icalenum_string_to_method(char* string); +const char* icalenum_method_to_string(icalproperty_method); +icalproperty_method icalenum_string_to_method(const char* string); + +const char* icalenum_status_to_string(icalproperty_status); +icalproperty_status icalenum_string_to_status(const char* string); #endif /* !ICALENUMS_H */ diff --git a/libical/src/libical/icalerror.c b/libical/src/libical/icalerror.c index c7641da504..de9ea4392b 100644 --- a/libical/src/libical/icalerror.c +++ b/libical/src/libical/icalerror.c @@ -5,9 +5,6 @@ $Id$ - $Locker$ - - (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org This program is free software; you can redistribute it and/or modify @@ -56,6 +53,11 @@ void icalerror_clear_errno() { void icalerror_set_errno(icalerrorenum e) { +#ifdef ICAL_ERRORS_ARE_FATAL + fprintf(stderr,"libical: icalerrno_set_error: %s",icalerror_strerror(e)); + icalerror_crash_here(); +#endif + icalerror_stop_here(); icalerrno = e; } @@ -68,9 +70,9 @@ struct icalerror_string_map { static struct icalerror_string_map string_map[] = { - {ICAL_BADARG_ERROR,"Bad argumnet to function"}, + {ICAL_BADARG_ERROR,"Bad argument to function"}, {ICAL_NEWFAILED_ERROR,"Failed to create a new object via a *_new() routine"}, - {ICAL_MALFORMEDDATA_ERROR,"An input string was not correctly formed"}, + {ICAL_MALFORMEDDATA_ERROR,"An input string was not correctly formed or a component has missing or extra properties"}, {ICAL_PARSE_ERROR,"Failed to parse a part of an iCal componet"}, {ICAL_INTERNAL_ERROR,"Random internal error. This indicates an error in the library code, not an error in use"}, {ICAL_FILE_ERROR,"An operation on a file failed. Check errno for more detail."}, diff --git a/libical/src/libical/icalerror.h b/libical/src/libical/icalerror.h index fbf6076dd6..d954b4d7f3 100644 --- a/libical/src/libical/icalerror.h +++ b/libical/src/libical/icalerror.h @@ -30,6 +30,12 @@ #include <assert.h> #include <stdio.h> /* For icalerror_warn() */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + + /* 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 */ @@ -58,14 +64,13 @@ void icalerror_crash_here(void); #define icalerror_assert(test,message) #endif - /* Check & abort if check fails */ #ifdef ICAL_ERRORS_ARE_FATAL #define icalerror_check_arg(test,arg) icalerror_stop_here();assert(test) #else #define icalerror_check_arg(test,arg) #endif -/* Check & return void if check failes*/ +/* Check & return void if check fails*/ #ifdef ICAL_ERRORS_ARE_FATAL #define icalerror_check_arg_rv(test,arg) icalerror_stop_here();assert(test); @@ -73,7 +78,7 @@ void icalerror_crash_here(void); #define icalerror_check_arg_rv(test,arg) if(!(test)) { icalerror_set_errno(ICAL_BADARG_ERROR); return; } #endif -/* Check & return 0 if check failes*/ +/* Check & return 0 if check fails*/ #ifdef ICAL_ERRORS_ARE_FATAL #define icalerror_check_arg_rz(test,arg) icalerror_stop_here();assert(test); #else @@ -81,7 +86,7 @@ void icalerror_crash_here(void); #endif -/* Check & return an error if check failes*/ +/* Check & return an error if check fails*/ #ifdef ICAL_ERRORS_ARE_FATAL #define icalerror_check_arg_re(test,arg,error) icalerror_stop_here();assert(test); #else @@ -113,7 +118,7 @@ typedef enum icalerrorenum { ICAL_BADARG_ERROR, ICAL_NEWFAILED_ERROR, - ICAL_MALFORMEDDATA_ERROR, + ICAL_MALFORMEDDATA_ERROR, ICAL_PARSE_ERROR, ICAL_INTERNAL_ERROR, /* Like assert --internal consist. prob */ ICAL_FILE_ERROR, @@ -129,7 +134,7 @@ typedef enum icalerrorenum { extern icalerrorenum icalerrno; -void icalerror_clear_errno(); +void icalerror_clear_errno(void); void icalerror_set_errno(icalerrorenum); char* icalerror_strerror(icalerrorenum e); diff --git a/libical/src/libical/icallexer.l b/libical/src/libical/icallexer.l index 8a6db2f93b..6f922ae428 100644 --- a/libical/src/libical/icallexer.l +++ b/libical/src/libical/icallexer.l @@ -6,8 +6,7 @@ DESCRIPTION: - $Id: icallexer.l,v 1.4 2000/06/06 22:48:09 alves Exp $ - $Locker: $ + $Id: icallexer.l,v 1.5 2000/12/11 23:01:19 federico Exp $ (C) COPYRIGHT 1999 Eric Busboom http://www.softwarestudio.org @@ -28,16 +27,16 @@ ======================================================================*/ -#include "icalyacc.h" #include "icalparser.h" #include "icalenums.h" #include "icalmemory.h" #include "assert.h" +#include "icalyacc.h" #include <string.h> /* For strdup() */ int icalparser_flex_input(char* buf, int max_size); -void icalparser_clear_flex_input(); +void icalparser_clear_flex_input(void); #define ICAL_MAX_STR_CONST 1024 @@ -47,15 +46,15 @@ void icalparser_clear_flex_input(); #undef yywrap #undef YY_FATAL_ERROR -#define YY_FATAL_ERROR(msg) yyerror(msg) +#define YY_FATAL_ERROR(msg) ical_yyerror(msg) icalvalue_kind value_kind=ICAL_NO_VALUE; -void set_parser_value_state(); +void set_parser_value_state(icalvalue_kind kind); extern int yydebug; -void yyerror(char *s); +void ical_yyerror(char *s); -void init_str_buf(); +void init_str_buf(void); int last_state; @@ -63,6 +62,11 @@ 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 ); %} @@ -96,7 +100,7 @@ digit [0-9] <binary_value>{ -.* { yylval.v_string= icalmemory_tmp_copy(yytext); +.* { ical_yylval.v_string= icalmemory_tmp_copy(yytext); return STRING;} {crlf} { return EOL;} @@ -109,7 +113,7 @@ digit [0-9] } <uri_value>{ -.* { yylval.v_string= icalmemory_tmp_copy(yytext); +.* { ical_yylval.v_string= icalmemory_tmp_copy(yytext); return STRING;} {crlf} { return EOL;} @@ -117,7 +121,7 @@ digit [0-9] <time_value>{ -{digit}* { yylval.v_string= icalmemory_tmp_copy(yytext); +{digit}* { ical_yylval.v_string= icalmemory_tmp_copy(yytext); return DIGITS; } T { return TIME_CHAR; } Z { return UTC_CHAR; } @@ -127,7 +131,7 @@ Z { return UTC_CHAR; } } <duration_value>{ -{digit}+ { yylval.v_string =icalmemory_tmp_copy(yytext); +{digit}+ { ical_yylval.v_string =icalmemory_tmp_copy(yytext); return DIGITS; } T { return TIME_CHAR; } [\+\-PTWHMSD] { return yytext[0]; } @@ -136,14 +140,14 @@ T { return TIME_CHAR; } } <number_value>{ -[\+\-\.0-9]+ { yylval.v_int=atoi(yytext); return INTNUMBER; } +[\+\-\.0-9]+ { ical_yylval.v_int=atoi(yytext); return INTNUMBER; } {crlf} { return EOL;} . { return CHARACTER; } } <period_value>{ -{digit}+ { yylval.v_string =icalmemory_tmp_copy(yytext) ; +{digit}+ { ical_yylval.v_string =icalmemory_tmp_copy(yytext) ; return DIGITS; } T { return TIME_CHAR; } Z { return UTC_CHAR; } @@ -184,7 +188,8 @@ FR { return FR; } = { return EQUALS; } , { return COMMA; } ; { return SEMICOLON; } -[\-\+0-9]+ { yylval.v_string= icalmemory_tmp_copy(yytext); +- { return MINUS; } +[\+0-9]+ { ical_yylval.v_string= icalmemory_tmp_copy(yytext); return DIGITS; } T { return TIME_CHAR; } Z { return UTC_CHAR; } @@ -194,7 +199,7 @@ Z { return UTC_CHAR; } <utcoffset_value>{ {crlf} { return EOL;} \-|\+ { return yytext[0]; } -{digit}{digit} { yylval.v_int=atoi(yytext); return INTNUMBER; } +{digit}{digit} { ical_yylval.v_int=atoi(yytext); return INTNUMBER; } } @@ -275,7 +280,7 @@ void set_parser_value_state(icalvalue_kind kind) } } -void init_str_buf() +void init_str_buf(void) { str_buf = icalmemory_tmp_buffer(ICAL_MAX_STR_CONST); str_buf_p = str_buf; diff --git a/libical/src/libical/icalmemory.c b/libical/src/libical/icalmemory.c index e13c2c42ca..97cefe65c6 100644 --- a/libical/src/libical/icalmemory.c +++ b/libical/src/libical/icalmemory.c @@ -4,8 +4,6 @@ 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 @@ -31,20 +29,6 @@ The Original Code is icalmemory.h - 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 ======================================================================*/ /* libical often passes strings back to the caller. To make these @@ -73,11 +57,14 @@ #include <stdio.h> /* for printf (debugging) */ #include <stdlib.h> /* for malloc, realloc */ -#include <string.h> /* for memset() */ +#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; @@ -155,7 +142,7 @@ void icalmemory_free_ring() /* Like strdup, but the buffer is on the ring. */ char* -icalmemory_tmp_copy(char* str) +icalmemory_tmp_copy(const char* str) { char* b = icalmemory_tmp_buffer(strlen(str)+1); @@ -218,7 +205,7 @@ void icalmemory_free_buffer(void* buf) void icalmemory_append_string(char** buf, char** pos, size_t* buf_size, - char* string) + const char* string) { char *new_buf; char *new_pos; diff --git a/libical/src/libical/icalmemory.h b/libical/src/libical/icalmemory.h index 6c974cdc95..678f018b52 100644 --- a/libical/src/libical/icalmemory.h +++ b/libical/src/libical/icalmemory.h @@ -3,33 +3,7 @@ FILE: icalmemory.h 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 This program is free software; you can redistribute it and/or modify it under the terms of either: @@ -52,18 +26,19 @@ #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(char* str); +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 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 @@ -87,7 +62,7 @@ void icalmemory_free_buffer(void* buf); have memory problems. */ void icalmemory_append_string(char** buf, char** pos, size_t* buf_size, - char* string); + 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, diff --git a/libical/src/libical/icalparameter.c b/libical/src/libical/icalparameter.c index 5bbaff68ef..cee4259099 100644 --- a/libical/src/libical/icalparameter.c +++ b/libical/src/libical/icalparameter.c @@ -5,9 +5,6 @@ $Id$ - $Locker$ - - (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org This program is free software; you can redistribute it and/or modify @@ -27,42 +24,47 @@ Graham Davison (g.m.davison@computer.org) ======================================================================*/ - +#line 29 "icalparameter.c.in" #ifdef HAVE_CONFIG_H -#include "config.h" +#include <config.h> #endif -#include "ical.h" + +#include "icalparameter.h" +#include "icalproperty.h" #include "icalerror.h" +#include "icalmemory.h" + #include <stdlib.h> /* for malloc() */ #include <errno.h> #include <string.h> /* for memset() */ -#include "icalmemory.h" + +union icalparameter_impl_data { + int v_int; + int v_rsvp; + icalparameter_cutype v_cutype; + icalparameter_encoding v_encoding; + icalparameter_fbtype v_fbtype; + icalparameter_partstat v_partstat; + icalparameter_range v_range; + icalparameter_related v_related; + icalparameter_reltype v_reltype; + icalparameter_role v_role; + icalparameter_value v_value; + icalparameter_xlicerrortype v_xlicerrortype; + icalparameter_xliccomparetype v_xliccomparetype; +} data; struct icalparameter_impl { icalparameter_kind kind; char id[5]; int size; - char* string; - char* x_name; + const char* string; + const char* x_name; icalproperty* parent; - union data { - int v_int; - int v_rsvp; - icalparameter_cutype v_cutype; - icalparameter_encoding v_encoding; - icalparameter_fbtype v_fbtype; - icalparameter_partstat v_partstat; - icalparameter_range v_range; - icalparameter_related v_related; - icalparameter_reltype v_reltype; - icalparameter_role v_role; - icalparameter_value v_value; - icalparameter_xlicerrortype v_xlicerrortype; - icalparameter_xliccomparetype v_xliccomparetype; - } data; + union icalparameter_impl_data data; }; struct icalparameter_impl* icalparameter_new_impl(icalparameter_kind kind) @@ -134,10 +136,16 @@ icalparameter_new_clone(icalparameter* param) #if 0 +<<<<<<< icalparameter.c +======= +#if 1 +/* The following code is meant to replace most of the case-switch + statements, but it is still a work in progress */ +>>>>>>> 1.1.1.5 struct param_string_map { icalparameter_kind kind; int val; /* Actually, union of several types of enums */ - char* str; + const char* str; } param_string_map[] = { {ICAL_CUTYPE_PARAMETER,ICAL_CUTYPE_INDIVIDUAL,"INDIVIDUAL"}, @@ -164,6 +172,9 @@ struct param_string_map { {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_PARAMETER,"TRUE"}, {ICAL_RSVP_PARAMETER,ICAL_RSVP_PARAMETER,"FALSE"}, {ICAL_VALUE_PARAMETER,ICAL_VALUE_BINARY,"BINARY"}, @@ -197,8 +208,39 @@ struct param_string_map { }; +void icalparameter_set_impl_data(icalparameter_kind kind, + union icalparameter_impl_data *data, + int value) +{ -icalparameter* icalparameter_new_from_string(icalparameter_kind kind, char* val) + switch (kind){ + case ICAL_CUTYPE_PARAMETER: + data->v_cutype=value; break; + case ICAL_FBTYPE_PARAMETER: + data->v_fbtype=value; break; + case ICAL_PARTSTAT_PARAMETER: + data->v_partstat=value; break; + case ICAL_RANGE_PARAMETER: + data->v_range=value; break; + case ICAL_RELATED_PARAMETER: + data->v_related=value; break; + case ICAL_RELTYPE_PARAMETER: + data->v_reltype=value; break; + case ICAL_ROLE_PARAMETER: + data->v_role=value; break; + case ICAL_RSVP_PARAMETER: + data->v_rsvp=value; break; + case ICAL_VALUE_PARAMETER: + data->v_value=value; break; + case ICAL_XLICERRORTYPE_PARAMETER: + data->v_xlicerrortype=value; break; + case ICAL_XLICCOMPARETYPE_PARAMETER: + data->v_xliccomparetype=value; break; + default: + } +} + +icalparameter* icalparameter_new_from_string_test(icalparameter_kind kind, char* val) { int i =0; icalparameter* param=0; @@ -206,6 +248,8 @@ icalparameter* icalparameter_new_from_string(icalparameter_kind kind, char* val) icalerror_check_arg_rz((val!=0),"val"); switch(kind){ + + /* These are all string values parameters */ case ICAL_SENTBY_PARAMETER: case ICAL_TZID_PARAMETER: case ICAL_X_PARAMETER: @@ -218,9 +262,15 @@ icalparameter* icalparameter_new_from_string(icalparameter_kind kind, char* val) case ICAL_ALTREP_PARAMETER: case ICAL_CN_PARAMETER: { - if (impl->string == 0){ return no_parameter;} - strcpy(tend,impl->string);break; - break; + struct icalparameter_impl *impl = icalparameter_new_impl(kind); + if (impl == 0) { + return 0; + } + ((struct icalparameter_impl*)param)->string = + icalmemory_strdup(val); + + return (icalparameter*) impl; + } case ICAL_NO_PARAMETER: @@ -229,18 +279,41 @@ icalparameter* icalparameter_new_from_string(icalparameter_kind kind, char* val) } default: { + int found = 0; /* All other types are enumerated */ - for(i = 0; param_string_map[i].kind != ICAL_NO_PARAMETER){ + for(i = 0; param_string_map[i].kind != ICAL_NO_PARAMETER; i++){ + if(kind == param_string_map[i].kind && - strcmp(val,param_string_map[i].str) == 0){ - - - } + strcmp(val,param_string_map[i].str) == 0){ + + struct icalparameter_impl *impl = + icalparameter_new_impl(kind); + found = 1; + + icalparameter_set_impl_data(kind,&impl->data, + param_string_map[i].val); + + return (icalparameter*)impl; + } } + + /* Didn't find the standard enumerated type, so it must be + an X parameter */ + if (found ==0) { + icalparameter *param = icalparameter_new(kind); + + icalparameter_set_xvalue(param,val); + + return param; + + } } + } + + return 0; } - -#endif + +#endif icalparameter* icalparameter_new_from_string(icalparameter_kind kind, char* val) @@ -616,11 +689,11 @@ icalparameter_free (icalparameter* parameter) if (impl->string != 0){ - free (impl->string); + free ((void*)impl->string); } if (impl->x_name != 0){ - free (impl->x_name); + free ((void*)impl->x_name); } memset(impl,0,sizeof(impl)); @@ -640,7 +713,7 @@ icalparameter_as_ical_string (icalparameter* parameter) char* buf; char* buf_ptr; char *out_buf; - char *kind_string; + const char *kind_string; char tend[1024]; /* HACK . Should be using memory buffer ring */ @@ -1085,14 +1158,14 @@ icalparameter_isa_parameter (void* parameter) void -icalparameter_set_xname (icalparameter* param, char* v) +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(impl->x_name); + free((void*)impl->x_name); } impl->x_name = icalmemory_strdup(v); @@ -1103,7 +1176,7 @@ icalparameter_set_xname (icalparameter* param, char* v) } -char* +const char* icalparameter_get_xname (icalparameter* param) { struct icalparameter_impl *impl = (struct icalparameter_impl*)param; @@ -1113,7 +1186,7 @@ icalparameter_get_xname (icalparameter* param) } void -icalparameter_set_xvalue (icalparameter* param, char* v) +icalparameter_set_xvalue (icalparameter* param, const char* v) { struct icalparameter_impl *impl = (struct icalparameter_impl*)param; @@ -1121,7 +1194,7 @@ icalparameter_set_xvalue (icalparameter* param, char* v) icalerror_check_arg_rv( (v!=0),"v"); if (impl->string != 0){ - free(impl->string); + free((void*)impl->string); } impl->string = icalmemory_strdup(v); @@ -1132,7 +1205,7 @@ icalparameter_set_xvalue (icalparameter* param, char* v) } -char* +const char* icalparameter_get_xvalue (icalparameter* param) { struct icalparameter_impl *impl = (struct icalparameter_impl*)param; @@ -1165,7 +1238,7 @@ icalproperty* icalparameter_get_parent(icalparameter* param) /* Everything below this line is machine generated. Do not edit. */ /* ALTREP */ -icalparameter* icalparameter_new_altrep(char* v) +icalparameter* icalparameter_new_altrep(const char* v) { struct icalparameter_impl *impl; icalerror_clear_errno(); @@ -1184,24 +1257,24 @@ icalparameter* icalparameter_new_altrep(char* v) return (icalparameter*) impl; } -char* icalparameter_get_altrep(icalparameter* param) +const char* icalparameter_get_altrep(icalparameter* param) { icalerror_clear_errno(); icalerror_check_arg_rz( (param!=0), "param"); return ((struct icalparameter_impl*)param)->string; } -void icalparameter_set_altrep(icalparameter* param, char* v) +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); + ((struct icalparameter_impl*)param)->string = strdup(v); } /* CN */ -icalparameter* icalparameter_new_cn(char* v) +icalparameter* icalparameter_new_cn(const char* v) { struct icalparameter_impl *impl; icalerror_clear_errno(); @@ -1220,20 +1293,20 @@ icalparameter* icalparameter_new_cn(char* v) return (icalparameter*) impl; } -char* icalparameter_get_cn(icalparameter* param) +const char* icalparameter_get_cn(icalparameter* param) { icalerror_clear_errno(); icalerror_check_arg_rz( (param!=0), "param"); return ((struct icalparameter_impl*)param)->string; } -void icalparameter_set_cn(icalparameter* param, char* v) +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); + ((struct icalparameter_impl*)param)->string = strdup(v); } /* CUTYPE */ @@ -1278,7 +1351,7 @@ void icalparameter_set_cutype(icalparameter* param, icalparameter_cutype v) } /* DELEGATED-FROM */ -icalparameter* icalparameter_new_delegatedfrom(char* v) +icalparameter* icalparameter_new_delegatedfrom(const char* v) { struct icalparameter_impl *impl; icalerror_clear_errno(); @@ -1297,24 +1370,24 @@ icalparameter* icalparameter_new_delegatedfrom(char* v) return (icalparameter*) impl; } -char* icalparameter_get_delegatedfrom(icalparameter* param) +const char* icalparameter_get_delegatedfrom(icalparameter* param) { icalerror_clear_errno(); icalerror_check_arg_rz( (param!=0), "param"); return ((struct icalparameter_impl*)param)->string; } -void icalparameter_set_delegatedfrom(icalparameter* param, char* v) +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); + ((struct icalparameter_impl*)param)->string = strdup(v); } /* DELEGATED-TO */ -icalparameter* icalparameter_new_delegatedto(char* v) +icalparameter* icalparameter_new_delegatedto(const char* v) { struct icalparameter_impl *impl; icalerror_clear_errno(); @@ -1333,24 +1406,24 @@ icalparameter* icalparameter_new_delegatedto(char* v) return (icalparameter*) impl; } -char* icalparameter_get_delegatedto(icalparameter* param) +const char* icalparameter_get_delegatedto(icalparameter* param) { icalerror_clear_errno(); icalerror_check_arg_rz( (param!=0), "param"); return ((struct icalparameter_impl*)param)->string; } -void icalparameter_set_delegatedto(icalparameter* param, char* v) +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); + ((struct icalparameter_impl*)param)->string = strdup(v); } /* DIR */ -icalparameter* icalparameter_new_dir(char* v) +icalparameter* icalparameter_new_dir(const char* v) { struct icalparameter_impl *impl; icalerror_clear_errno(); @@ -1369,20 +1442,20 @@ icalparameter* icalparameter_new_dir(char* v) return (icalparameter*) impl; } -char* icalparameter_get_dir(icalparameter* param) +const char* icalparameter_get_dir(icalparameter* param) { icalerror_clear_errno(); icalerror_check_arg_rz( (param!=0), "param"); return ((struct icalparameter_impl*)param)->string; } -void icalparameter_set_dir(icalparameter* param, char* v) +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); + ((struct icalparameter_impl*)param)->string = strdup(v); } /* ENCODING */ @@ -1468,7 +1541,7 @@ void icalparameter_set_fbtype(icalparameter* param, icalparameter_fbtype v) } /* FMTTYPE */ -icalparameter* icalparameter_new_fmttype(char* v) +icalparameter* icalparameter_new_fmttype(const char* v) { struct icalparameter_impl *impl; icalerror_clear_errno(); @@ -1487,24 +1560,24 @@ icalparameter* icalparameter_new_fmttype(char* v) return (icalparameter*) impl; } -char* icalparameter_get_fmttype(icalparameter* param) +const char* icalparameter_get_fmttype(icalparameter* param) { icalerror_clear_errno(); icalerror_check_arg_rz( (param!=0), "param"); return ((struct icalparameter_impl*)param)->string; } -void icalparameter_set_fmttype(icalparameter* param, char* v) +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); + ((struct icalparameter_impl*)param)->string = strdup(v); } /* LANGUAGE */ -icalparameter* icalparameter_new_language(char* v) +icalparameter* icalparameter_new_language(const char* v) { struct icalparameter_impl *impl; icalerror_clear_errno(); @@ -1523,24 +1596,24 @@ icalparameter* icalparameter_new_language(char* v) return (icalparameter*) impl; } -char* icalparameter_get_language(icalparameter* param) +const char* icalparameter_get_language(icalparameter* param) { icalerror_clear_errno(); icalerror_check_arg_rz( (param!=0), "param"); return ((struct icalparameter_impl*)param)->string; } -void icalparameter_set_language(icalparameter* param, char* v) +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); + ((struct icalparameter_impl*)param)->string = strdup(v); } /* MEMBER */ -icalparameter* icalparameter_new_member(char* v) +icalparameter* icalparameter_new_member(const char* v) { struct icalparameter_impl *impl; icalerror_clear_errno(); @@ -1559,20 +1632,20 @@ icalparameter* icalparameter_new_member(char* v) return (icalparameter*) impl; } -char* icalparameter_get_member(icalparameter* param) +const char* icalparameter_get_member(icalparameter* param) { icalerror_clear_errno(); icalerror_check_arg_rz( (param!=0), "param"); return ((struct icalparameter_impl*)param)->string; } -void icalparameter_set_member(icalparameter* param, char* v) +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); + ((struct icalparameter_impl*)param)->string = strdup(v); } /* PARTSTAT */ @@ -1813,7 +1886,7 @@ void icalparameter_set_rsvp(icalparameter* param, int v) } /* SENT-BY */ -icalparameter* icalparameter_new_sentby(char* v) +icalparameter* icalparameter_new_sentby(const char* v) { struct icalparameter_impl *impl; icalerror_clear_errno(); @@ -1832,24 +1905,24 @@ icalparameter* icalparameter_new_sentby(char* v) return (icalparameter*) impl; } -char* icalparameter_get_sentby(icalparameter* param) +const char* icalparameter_get_sentby(icalparameter* param) { icalerror_clear_errno(); icalerror_check_arg_rz( (param!=0), "param"); return ((struct icalparameter_impl*)param)->string; } -void icalparameter_set_sentby(icalparameter* param, char* v) +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); + ((struct icalparameter_impl*)param)->string = strdup(v); } /* TZID */ -icalparameter* icalparameter_new_tzid(char* v) +icalparameter* icalparameter_new_tzid(const char* v) { struct icalparameter_impl *impl; icalerror_clear_errno(); @@ -1868,20 +1941,20 @@ icalparameter* icalparameter_new_tzid(char* v) return (icalparameter*) impl; } -char* icalparameter_get_tzid(icalparameter* param) +const char* icalparameter_get_tzid(icalparameter* param) { icalerror_clear_errno(); icalerror_check_arg_rz( (param!=0), "param"); return ((struct icalparameter_impl*)param)->string; } -void icalparameter_set_tzid(icalparameter* param, char* v) +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); + ((struct icalparameter_impl*)param)->string = strdup(v); } /* VALUE */ @@ -1926,7 +1999,7 @@ void icalparameter_set_value(icalparameter* param, icalparameter_value v) } /* X */ -icalparameter* icalparameter_new_x(char* v) +icalparameter* icalparameter_new_x(const char* v) { struct icalparameter_impl *impl; icalerror_clear_errno(); @@ -1945,20 +2018,20 @@ icalparameter* icalparameter_new_x(char* v) return (icalparameter*) impl; } -char* icalparameter_get_x(icalparameter* param) +const char* icalparameter_get_x(icalparameter* param) { icalerror_clear_errno(); icalerror_check_arg_rz( (param!=0), "param"); return ((struct icalparameter_impl*)param)->string; } -void icalparameter_set_x(icalparameter* param, char* v) +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); + ((struct icalparameter_impl*)param)->string = strdup(v); } /* X-LIC-ERRORTYPE */ diff --git a/libical/src/libical/icalparameter.h b/libical/src/libical/icalparameter.h index ad97f34e58..7e1da4e1fe 100644 --- a/libical/src/libical/icalparameter.h +++ b/libical/src/libical/icalparameter.h @@ -5,8 +5,6 @@ $Id$ - $Locker$ - (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org @@ -29,7 +27,7 @@ #ifndef ICALPARAM_H #define ICALPARAM_H -#include "icalenums.h" /* defined icalparameter_kind and other enums */ +#include "icalenums.h" typedef void icalparameter; @@ -48,22 +46,22 @@ 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, char* v); -char* icalparameter_get_xname(icalparameter* param); -void icalparameter_set_xvalue (icalparameter* param, char* v); -char* icalparameter_get_xvalue(icalparameter* param); +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); /* Everything below this line is machine generated. Do not edit. */ /* ALTREP */ -icalparameter* icalparameter_new_altrep(char* v); -char* icalparameter_get_altrep(icalparameter* value); -void icalparameter_set_altrep(icalparameter* value, char* v); +icalparameter* icalparameter_new_altrep(const char* v); +const char* icalparameter_get_altrep(icalparameter* value); +void icalparameter_set_altrep(icalparameter* value, const char* v); /* CN */ -icalparameter* icalparameter_new_cn(char* v); -char* icalparameter_get_cn(icalparameter* value); -void icalparameter_set_cn(icalparameter* value, char* v); +icalparameter* icalparameter_new_cn(const char* v); +const char* icalparameter_get_cn(icalparameter* value); +void icalparameter_set_cn(icalparameter* value, const char* v); /* CUTYPE */ icalparameter* icalparameter_new_cutype(icalparameter_cutype v); @@ -71,19 +69,19 @@ icalparameter_cutype icalparameter_get_cutype(icalparameter* value); void icalparameter_set_cutype(icalparameter* value, icalparameter_cutype v); /* DELEGATED-FROM */ -icalparameter* icalparameter_new_delegatedfrom(char* v); -char* icalparameter_get_delegatedfrom(icalparameter* value); -void icalparameter_set_delegatedfrom(icalparameter* value, char* v); +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(char* v); -char* icalparameter_get_delegatedto(icalparameter* value); -void icalparameter_set_delegatedto(icalparameter* value, char* v); +icalparameter* icalparameter_new_delegatedto(const char* v); +const char* icalparameter_get_delegatedto(icalparameter* value); +void icalparameter_set_delegatedto(icalparameter* value, const char* v); /* DIR */ -icalparameter* icalparameter_new_dir(char* v); -char* icalparameter_get_dir(icalparameter* value); -void icalparameter_set_dir(icalparameter* value, char* v); +icalparameter* icalparameter_new_dir(const char* v); +const char* icalparameter_get_dir(icalparameter* value); +void icalparameter_set_dir(icalparameter* value, const char* v); /* ENCODING */ icalparameter* icalparameter_new_encoding(icalparameter_encoding v); @@ -96,19 +94,19 @@ icalparameter_fbtype icalparameter_get_fbtype(icalparameter* value); void icalparameter_set_fbtype(icalparameter* value, icalparameter_fbtype v); /* FMTTYPE */ -icalparameter* icalparameter_new_fmttype(char* v); -char* icalparameter_get_fmttype(icalparameter* value); -void icalparameter_set_fmttype(icalparameter* value, char* v); +icalparameter* icalparameter_new_fmttype(const char* v); +const char* icalparameter_get_fmttype(icalparameter* value); +void icalparameter_set_fmttype(icalparameter* value, const char* v); /* LANGUAGE */ -icalparameter* icalparameter_new_language(char* v); -char* icalparameter_get_language(icalparameter* value); -void icalparameter_set_language(icalparameter* value, char* v); +icalparameter* icalparameter_new_language(const char* v); +const char* icalparameter_get_language(icalparameter* value); +void icalparameter_set_language(icalparameter* value, const char* v); /* MEMBER */ -icalparameter* icalparameter_new_member(char* v); -char* icalparameter_get_member(icalparameter* value); -void icalparameter_set_member(icalparameter* value, char* v); +icalparameter* icalparameter_new_member(const char* v); +const char* icalparameter_get_member(icalparameter* value); +void icalparameter_set_member(icalparameter* value, const char* v); /* PARTSTAT */ icalparameter* icalparameter_new_partstat(icalparameter_partstat v); @@ -141,14 +139,14 @@ int icalparameter_get_rsvp(icalparameter* value); void icalparameter_set_rsvp(icalparameter* value, int v); /* SENT-BY */ -icalparameter* icalparameter_new_sentby(char* v); -char* icalparameter_get_sentby(icalparameter* value); -void icalparameter_set_sentby(icalparameter* value, char* v); +icalparameter* icalparameter_new_sentby(const char* v); +const char* icalparameter_get_sentby(icalparameter* value); +void icalparameter_set_sentby(icalparameter* value, const char* v); /* TZID */ -icalparameter* icalparameter_new_tzid(char* v); -char* icalparameter_get_tzid(icalparameter* value); -void icalparameter_set_tzid(icalparameter* value, char* v); +icalparameter* icalparameter_new_tzid(const char* v); +const char* icalparameter_get_tzid(icalparameter* value); +void icalparameter_set_tzid(icalparameter* value, const char* v); /* VALUE */ icalparameter* icalparameter_new_value(icalparameter_value v); @@ -156,9 +154,9 @@ icalparameter_value icalparameter_get_value(icalparameter* value); void icalparameter_set_value(icalparameter* value, icalparameter_value v); /* X */ -icalparameter* icalparameter_new_x(char* v); -char* icalparameter_get_x(icalparameter* value); -void icalparameter_set_x(icalparameter* value, char* v); +icalparameter* icalparameter_new_x(const char* v); +const char* icalparameter_get_x(icalparameter* value); +void icalparameter_set_x(icalparameter* value, const char* v); /* X-LIC-ERRORTYPE */ icalparameter* icalparameter_new_xlicerrortype(icalparameter_xlicerrortype v); @@ -170,4 +168,4 @@ icalparameter* icalparameter_new_xliccomparetype(icalparameter_xliccomparetype v icalparameter_xliccomparetype icalparameter_get_xliccomparetype(icalparameter* value); void icalparameter_set_xliccomparetype(icalparameter* value, icalparameter_xliccomparetype v); -#endif ICALPARAMETER_H +#endif /*ICALPARAMETER_H*/ diff --git a/libical/src/libical/icalparser.c b/libical/src/libical/icalparser.c index 11a505244f..1de5945e7b 100644 --- a/libical/src/libical/icalparser.c +++ b/libical/src/libical/icalparser.c @@ -4,8 +4,6 @@ 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 @@ -39,10 +37,15 @@ #endif -#include "ical.h" -#include "pvl.h" #include "icalparser.h" +#include "pvl.h" #include "icalmemory.h" +#include "icalerror.h" +#include "icalvalue.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 */ @@ -50,7 +53,7 @@ extern icalvalue* icalparser_yy_value; void set_parser_value_state(icalvalue_kind kind); -int ical_yy_parse(void); +int ical_yyparse(void); char* icalparser_get_next_char(char c, char *str); char* icalparser_get_next_parameter(char* line,char** end); @@ -78,10 +81,9 @@ struct icalparser_impl }; -icalparser* icalparser_new() +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); @@ -178,8 +180,8 @@ char* make_segment(char* start, char* end) } -char* input_buffer; -char* input_buffer_p; +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) @@ -195,7 +197,7 @@ int icalparser_flex_input(char* buf, int max_size) } } -void icalparser_clear_flex_input() +void icalparser_clear_flex_input(void) { input_buffer_p = input_buffer+strlen(input_buffer); } @@ -203,7 +205,7 @@ void icalparser_clear_flex_input() /* Cal the flex parser to parse a complex value */ icalvalue* icalparser_parse_value(icalvalue_kind kind, - char* str, icalproperty** error) + const char* str, icalproperty** error) { int r; input_buffer_p = input_buffer = str; @@ -211,7 +213,7 @@ icalvalue* icalparser_parse_value(icalvalue_kind kind, set_parser_value_state(kind); icalparser_yy_value = 0; - r = ical_yy_parse(); + r = ical_yyparse(); /* Error. Parse failed */ if( icalparser_yy_value == 0 || r != 0){ diff --git a/libical/src/libical/icalparser.h b/libical/src/libical/icalparser.h index 161127379f..7940bc8cca 100644 --- a/libical/src/libical/icalparser.h +++ b/libical/src/libical/icalparser.h @@ -5,7 +5,6 @@ $Id$ - (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org This program is free software; you can redistribute it and/or modify @@ -27,7 +26,10 @@ #ifndef ICALPARSER_H #define ICALPARSER_H -#include "ical.h" +#include "icalenums.h" +#include "icaltypes.h" +#include"icalcomponent.h" + #include <stdio.h> /* For FILE* */ typedef void* icalparser; @@ -49,7 +51,7 @@ typedef enum icalparser_state { ICALPARSER_IN_PROGRESS } icalparser_state; -icalparser* icalparser_new(); +icalparser* icalparser_new(void); icalcomponent* icalparser_add_line(icalparser* parser, char* str ); icalcomponent* icalparser_claim(icalparser* parser); icalcomponent* icalparser_clean(icalparser* parser); @@ -80,7 +82,8 @@ icalcomponent* icalparser_parse_string(char* str); ***********************************************************************/ /* Use the flex/bison parser to turn a string into a value type */ -icalvalue* icalparser_parse_value(icalvalue_kind kind, char* str, icalcomponent** errors); +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)); diff --git a/libical/src/libical/icalproperty.c b/libical/src/libical/icalproperty.c index b63c8a960a..84d6605160 100644 --- a/libical/src/libical/icalproperty.c +++ b/libical/src/libical/icalproperty.c @@ -6,7 +6,6 @@ $Id$ - (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org This program is free software; you can redistribute it and/or modify @@ -23,24 +22,26 @@ The original code is icalproperty.c ======================================================================*/ +#line 27 "icalproperty.c.in" #ifdef HAVE_CONFIG_H -#include "config.h" +#include <config.h> #endif -#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. */ - -#include "ical.h" +#include "icalproperty.h" +#include "icalcomponent.h" #include "pvl.h" #include "icalenums.h" #include "icalerror.h" #include "icalmemory.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 /* Private routines for icalproperty */ @@ -87,6 +88,7 @@ void icalproperty_add_parameters(struct icalproperty_impl *impl,va_list args) } + struct icalproperty_impl* icalproperty_new_impl (icalproperty_kind kind) { @@ -251,18 +253,14 @@ icalproperty_as_ical_string (icalproperty* prop) by libical, so it can be given to the caller without fear of the caller forgetting to free it */ - char* property_name = 0; + 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; -#ifdef ICAL_UNIX_NEWLINE char newline[] = "\n"; -#else - char newline[] = "\r\n"; -#endif struct icalproperty_impl *impl = (struct icalproperty_impl*)prop; @@ -315,7 +313,7 @@ icalproperty_as_ical_string (icalproperty* prop) value = icalproperty_get_value(prop); if (value != 0){ - char *str = icalvalue_as_ical_string(value); + 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 { @@ -378,14 +376,32 @@ icalproperty_add_parameter (icalproperty* prop,icalparameter* parameter) } +void +icalproperty_set_parameter (icalproperty* prop,icalparameter* parameter) +{ + icalproperty_kind kind; + + kind = icalparameter_isa(parameter); + + icalproperty_remove_parameter(prop,kind); + + icalproperty_add_parameter(prop,parameter); +} + void icalproperty_remove_parameter (icalproperty* prop, icalparameter_kind kind) { +<<<<<<< icalproperty.c struct icalproperty_impl *p = (struct icalproperty_impl*)prop; icalparameter *param; pvl_elem elem; +======= + pvl_elem p; + struct icalproperty_impl *impl = (struct icalproperty_impl*)prop; +>>>>>>> 1.1.1.5 +<<<<<<< icalproperty.c icalerror_check_arg_rv((prop!=0),"prop"); /* This routine is now implemented, so disregard the following @@ -402,6 +418,18 @@ icalproperty_remove_parameter (icalproperty* prop, icalparameter_kind kind) } elem = pvl_next (elem); } +======= + 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; + } + } +>>>>>>> 1.1.1.5 } @@ -432,27 +460,45 @@ icalproperty_get_first_parameter (icalproperty* prop, icalparameter_kind kind) return 0; } - return (icalparameter*) pvl_data(p->parameter_iterator); + 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; - } - - p->parameter_iterator = pvl_next(p->parameter_iterator); - - if (p->parameter_iterator == 0 ) { - return 0; - } + 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; - return (icalparameter*) pvl_data(p->parameter_iterator); } void @@ -589,7 +635,7 @@ icalproperty_method icalproperty_get_method(icalproperty* prop) /* X-LIC-MIMECID */ -icalproperty* icalproperty_new_xlicmimecid(char* v) +icalproperty* icalproperty_new_xlicmimecid(const char* v) { struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICMIMECID_PROPERTY); icalerror_check_arg_rz( (v!=0),"v"); @@ -600,7 +646,7 @@ icalproperty* icalproperty_new_xlicmimecid(char* v) return (icalproperty*)impl; } -icalproperty* icalproperty_vanew_xlicmimecid(char* v, ...) +icalproperty* icalproperty_vanew_xlicmimecid(const char* v, ...) { va_list args; struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICMIMECID_PROPERTY); @@ -616,7 +662,7 @@ icalproperty* icalproperty_vanew_xlicmimecid(char* v, ...) return (icalproperty*)impl; } -void icalproperty_set_xlicmimecid(icalproperty* prop, char* v) +void icalproperty_set_xlicmimecid(icalproperty* prop, const char* v) { icalvalue *value; @@ -630,7 +676,7 @@ void icalproperty_set_xlicmimecid(icalproperty* prop, char* v) } -char* icalproperty_get_xlicmimecid(icalproperty* prop) +const char* icalproperty_get_xlicmimecid(icalproperty* prop) { icalvalue *value; icalerror_check_arg( (prop!=0),"prop"); @@ -692,7 +738,7 @@ struct icaltimetype icalproperty_get_lastmodified(icalproperty* prop) /* UID */ -icalproperty* icalproperty_new_uid(char* v) +icalproperty* icalproperty_new_uid(const char* v) { struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_UID_PROPERTY); icalerror_check_arg_rz( (v!=0),"v"); @@ -703,7 +749,7 @@ icalproperty* icalproperty_new_uid(char* v) return (icalproperty*)impl; } -icalproperty* icalproperty_vanew_uid(char* v, ...) +icalproperty* icalproperty_vanew_uid(const char* v, ...) { va_list args; struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_UID_PROPERTY); @@ -719,7 +765,7 @@ icalproperty* icalproperty_vanew_uid(char* v, ...) return (icalproperty*)impl; } -void icalproperty_set_uid(icalproperty* prop, char* v) +void icalproperty_set_uid(icalproperty* prop, const char* v) { icalvalue *value; @@ -733,7 +779,7 @@ void icalproperty_set_uid(icalproperty* prop, char* v) } -char* icalproperty_get_uid(icalproperty* prop) +const char* icalproperty_get_uid(icalproperty* prop) { icalvalue *value; icalerror_check_arg( (prop!=0),"prop"); @@ -745,7 +791,7 @@ char* icalproperty_get_uid(icalproperty* prop) /* PRODID */ -icalproperty* icalproperty_new_prodid(char* v) +icalproperty* icalproperty_new_prodid(const char* v) { struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_PRODID_PROPERTY); icalerror_check_arg_rz( (v!=0),"v"); @@ -756,7 +802,7 @@ icalproperty* icalproperty_new_prodid(char* v) return (icalproperty*)impl; } -icalproperty* icalproperty_vanew_prodid(char* v, ...) +icalproperty* icalproperty_vanew_prodid(const char* v, ...) { va_list args; struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_PRODID_PROPERTY); @@ -772,7 +818,7 @@ icalproperty* icalproperty_vanew_prodid(char* v, ...) return (icalproperty*)impl; } -void icalproperty_set_prodid(icalproperty* prop, char* v) +void icalproperty_set_prodid(icalproperty* prop, const char* v) { icalvalue *value; @@ -786,7 +832,7 @@ void icalproperty_set_prodid(icalproperty* prop, char* v) } -char* icalproperty_get_prodid(icalproperty* prop) +const char* icalproperty_get_prodid(icalproperty* prop) { icalvalue *value; icalerror_check_arg( (prop!=0),"prop"); @@ -798,23 +844,21 @@ char* icalproperty_get_prodid(icalproperty* prop) /* STATUS */ -icalproperty* icalproperty_new_status(char* v) +icalproperty* icalproperty_new_status(icalproperty_status v) { struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_STATUS_PROPERTY); - icalerror_check_arg_rz( (v!=0),"v"); - + icalproperty_set_status((icalproperty*)impl,v); return (icalproperty*)impl; } -icalproperty* icalproperty_vanew_status(char* v, ...) +icalproperty* icalproperty_vanew_status(icalproperty_status v, ...) { va_list args; struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_STATUS_PROPERTY); - icalerror_check_arg_rz( (v!=0),"v"); - + icalproperty_set_status((icalproperty*)impl,v); @@ -825,33 +869,32 @@ icalproperty* icalproperty_vanew_status(char* v, ...) return (icalproperty*)impl; } -void icalproperty_set_status(icalproperty* prop, char* v) +void icalproperty_set_status(icalproperty* prop, icalproperty_status v) { icalvalue *value; - icalerror_check_arg_rv( (v!=0),"v"); - + icalerror_check_arg_rv( (prop!=0),"prop"); - value = icalvalue_new_text(v); + value = icalvalue_new_status(v); icalproperty_set_value(prop,value); } -char* icalproperty_get_status(icalproperty* prop) +icalproperty_status icalproperty_get_status(icalproperty* prop) { icalvalue *value; icalerror_check_arg( (prop!=0),"prop"); value = icalproperty_get_value(prop); - return icalvalue_get_text(value); + return icalvalue_get_status(value); } /* DESCRIPTION */ -icalproperty* icalproperty_new_description(char* v) +icalproperty* icalproperty_new_description(const char* v) { struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_DESCRIPTION_PROPERTY); icalerror_check_arg_rz( (v!=0),"v"); @@ -862,7 +905,7 @@ icalproperty* icalproperty_new_description(char* v) return (icalproperty*)impl; } -icalproperty* icalproperty_vanew_description(char* v, ...) +icalproperty* icalproperty_vanew_description(const char* v, ...) { va_list args; struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_DESCRIPTION_PROPERTY); @@ -878,7 +921,7 @@ icalproperty* icalproperty_vanew_description(char* v, ...) return (icalproperty*)impl; } -void icalproperty_set_description(icalproperty* prop, char* v) +void icalproperty_set_description(icalproperty* prop, const char* v) { icalvalue *value; @@ -892,7 +935,7 @@ void icalproperty_set_description(icalproperty* prop, char* v) } -char* icalproperty_get_description(icalproperty* prop) +const char* icalproperty_get_description(icalproperty* prop) { icalvalue *value; icalerror_check_arg( (prop!=0),"prop"); @@ -954,7 +997,7 @@ struct icaldurationtype icalproperty_get_duration(icalproperty* prop) /* CATEGORIES */ -icalproperty* icalproperty_new_categories(char* v) +icalproperty* icalproperty_new_categories(const char* v) { struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_CATEGORIES_PROPERTY); icalerror_check_arg_rz( (v!=0),"v"); @@ -965,7 +1008,7 @@ icalproperty* icalproperty_new_categories(char* v) return (icalproperty*)impl; } -icalproperty* icalproperty_vanew_categories(char* v, ...) +icalproperty* icalproperty_vanew_categories(const char* v, ...) { va_list args; struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_CATEGORIES_PROPERTY); @@ -981,7 +1024,7 @@ icalproperty* icalproperty_vanew_categories(char* v, ...) return (icalproperty*)impl; } -void icalproperty_set_categories(icalproperty* prop, char* v) +void icalproperty_set_categories(icalproperty* prop, const char* v) { icalvalue *value; @@ -995,7 +1038,7 @@ void icalproperty_set_categories(icalproperty* prop, char* v) } -char* icalproperty_get_categories(icalproperty* prop) +const char* icalproperty_get_categories(icalproperty* prop) { icalvalue *value; icalerror_check_arg( (prop!=0),"prop"); @@ -1007,7 +1050,7 @@ char* icalproperty_get_categories(icalproperty* prop) /* VERSION */ -icalproperty* icalproperty_new_version(char* v) +icalproperty* icalproperty_new_version(const char* v) { struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_VERSION_PROPERTY); icalerror_check_arg_rz( (v!=0),"v"); @@ -1018,7 +1061,7 @@ icalproperty* icalproperty_new_version(char* v) return (icalproperty*)impl; } -icalproperty* icalproperty_vanew_version(char* v, ...) +icalproperty* icalproperty_vanew_version(const char* v, ...) { va_list args; struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_VERSION_PROPERTY); @@ -1034,7 +1077,7 @@ icalproperty* icalproperty_vanew_version(char* v, ...) return (icalproperty*)impl; } -void icalproperty_set_version(icalproperty* prop, char* v) +void icalproperty_set_version(icalproperty* prop, const char* v) { icalvalue *value; @@ -1048,7 +1091,7 @@ void icalproperty_set_version(icalproperty* prop, char* v) } -char* icalproperty_get_version(icalproperty* prop) +const char* icalproperty_get_version(icalproperty* prop) { icalvalue *value; icalerror_check_arg( (prop!=0),"prop"); @@ -1160,7 +1203,7 @@ struct icalrecurrencetype icalproperty_get_rrule(icalproperty* prop) /* ATTENDEE */ -icalproperty* icalproperty_new_attendee(char* v) +icalproperty* icalproperty_new_attendee(const char* v) { struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_ATTENDEE_PROPERTY); icalerror_check_arg_rz( (v!=0),"v"); @@ -1171,7 +1214,7 @@ icalproperty* icalproperty_new_attendee(char* v) return (icalproperty*)impl; } -icalproperty* icalproperty_vanew_attendee(char* v, ...) +icalproperty* icalproperty_vanew_attendee(const char* v, ...) { va_list args; struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_ATTENDEE_PROPERTY); @@ -1187,7 +1230,7 @@ icalproperty* icalproperty_vanew_attendee(char* v, ...) return (icalproperty*)impl; } -void icalproperty_set_attendee(icalproperty* prop, char* v) +void icalproperty_set_attendee(icalproperty* prop, const char* v) { icalvalue *value; @@ -1201,7 +1244,7 @@ void icalproperty_set_attendee(icalproperty* prop, char* v) } -char* icalproperty_get_attendee(icalproperty* prop) +const char* icalproperty_get_attendee(icalproperty* prop) { icalvalue *value; icalerror_check_arg( (prop!=0),"prop"); @@ -1213,7 +1256,7 @@ char* icalproperty_get_attendee(icalproperty* prop) /* CONTACT */ -icalproperty* icalproperty_new_contact(char* v) +icalproperty* icalproperty_new_contact(const char* v) { struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_CONTACT_PROPERTY); icalerror_check_arg_rz( (v!=0),"v"); @@ -1224,7 +1267,7 @@ icalproperty* icalproperty_new_contact(char* v) return (icalproperty*)impl; } -icalproperty* icalproperty_vanew_contact(char* v, ...) +icalproperty* icalproperty_vanew_contact(const char* v, ...) { va_list args; struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_CONTACT_PROPERTY); @@ -1240,7 +1283,7 @@ icalproperty* icalproperty_vanew_contact(char* v, ...) return (icalproperty*)impl; } -void icalproperty_set_contact(icalproperty* prop, char* v) +void icalproperty_set_contact(icalproperty* prop, const char* v) { icalvalue *value; @@ -1254,7 +1297,7 @@ void icalproperty_set_contact(icalproperty* prop, char* v) } -char* icalproperty_get_contact(icalproperty* prop) +const char* icalproperty_get_contact(icalproperty* prop) { icalvalue *value; icalerror_check_arg( (prop!=0),"prop"); @@ -1266,7 +1309,7 @@ char* icalproperty_get_contact(icalproperty* prop) /* X-LIC-MIMECONTENTTYPE */ -icalproperty* icalproperty_new_xlicmimecontenttype(char* v) +icalproperty* icalproperty_new_xlicmimecontenttype(const char* v) { struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICMIMECONTENTTYPE_PROPERTY); icalerror_check_arg_rz( (v!=0),"v"); @@ -1277,7 +1320,7 @@ icalproperty* icalproperty_new_xlicmimecontenttype(char* v) return (icalproperty*)impl; } -icalproperty* icalproperty_vanew_xlicmimecontenttype(char* v, ...) +icalproperty* icalproperty_vanew_xlicmimecontenttype(const char* v, ...) { va_list args; struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICMIMECONTENTTYPE_PROPERTY); @@ -1293,7 +1336,7 @@ icalproperty* icalproperty_vanew_xlicmimecontenttype(char* v, ...) return (icalproperty*)impl; } -void icalproperty_set_xlicmimecontenttype(icalproperty* prop, char* v) +void icalproperty_set_xlicmimecontenttype(icalproperty* prop, const char* v) { icalvalue *value; @@ -1307,7 +1350,7 @@ void icalproperty_set_xlicmimecontenttype(icalproperty* prop, char* v) } -char* icalproperty_get_xlicmimecontenttype(icalproperty* prop) +const char* icalproperty_get_xlicmimecontenttype(icalproperty* prop) { icalvalue *value; icalerror_check_arg( (prop!=0),"prop"); @@ -1319,7 +1362,7 @@ char* icalproperty_get_xlicmimecontenttype(icalproperty* prop) /* X-LIC-MIMEOPTINFO */ -icalproperty* icalproperty_new_xlicmimeoptinfo(char* v) +icalproperty* icalproperty_new_xlicmimeoptinfo(const char* v) { struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICMIMEOPTINFO_PROPERTY); icalerror_check_arg_rz( (v!=0),"v"); @@ -1330,7 +1373,7 @@ icalproperty* icalproperty_new_xlicmimeoptinfo(char* v) return (icalproperty*)impl; } -icalproperty* icalproperty_vanew_xlicmimeoptinfo(char* v, ...) +icalproperty* icalproperty_vanew_xlicmimeoptinfo(const char* v, ...) { va_list args; struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICMIMEOPTINFO_PROPERTY); @@ -1346,7 +1389,7 @@ icalproperty* icalproperty_vanew_xlicmimeoptinfo(char* v, ...) return (icalproperty*)impl; } -void icalproperty_set_xlicmimeoptinfo(icalproperty* prop, char* v) +void icalproperty_set_xlicmimeoptinfo(icalproperty* prop, const char* v) { icalvalue *value; @@ -1360,7 +1403,7 @@ void icalproperty_set_xlicmimeoptinfo(icalproperty* prop, char* v) } -char* icalproperty_get_xlicmimeoptinfo(icalproperty* prop) +const char* icalproperty_get_xlicmimeoptinfo(icalproperty* prop) { icalvalue *value; icalerror_check_arg( (prop!=0),"prop"); @@ -1372,7 +1415,7 @@ char* icalproperty_get_xlicmimeoptinfo(icalproperty* prop) /* RELATED-TO */ -icalproperty* icalproperty_new_relatedto(char* v) +icalproperty* icalproperty_new_relatedto(const char* v) { struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_RELATEDTO_PROPERTY); icalerror_check_arg_rz( (v!=0),"v"); @@ -1383,7 +1426,7 @@ icalproperty* icalproperty_new_relatedto(char* v) return (icalproperty*)impl; } -icalproperty* icalproperty_vanew_relatedto(char* v, ...) +icalproperty* icalproperty_vanew_relatedto(const char* v, ...) { va_list args; struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_RELATEDTO_PROPERTY); @@ -1399,7 +1442,7 @@ icalproperty* icalproperty_vanew_relatedto(char* v, ...) return (icalproperty*)impl; } -void icalproperty_set_relatedto(icalproperty* prop, char* v) +void icalproperty_set_relatedto(icalproperty* prop, const char* v) { icalvalue *value; @@ -1413,7 +1456,7 @@ void icalproperty_set_relatedto(icalproperty* prop, char* v) } -char* icalproperty_get_relatedto(icalproperty* prop) +const char* icalproperty_get_relatedto(icalproperty* prop) { icalvalue *value; icalerror_check_arg( (prop!=0),"prop"); @@ -1425,7 +1468,7 @@ char* icalproperty_get_relatedto(icalproperty* prop) /* ORGANIZER */ -icalproperty* icalproperty_new_organizer(char* v) +icalproperty* icalproperty_new_organizer(const char* v) { struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_ORGANIZER_PROPERTY); icalerror_check_arg_rz( (v!=0),"v"); @@ -1436,7 +1479,7 @@ icalproperty* icalproperty_new_organizer(char* v) return (icalproperty*)impl; } -icalproperty* icalproperty_vanew_organizer(char* v, ...) +icalproperty* icalproperty_vanew_organizer(const char* v, ...) { va_list args; struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_ORGANIZER_PROPERTY); @@ -1452,7 +1495,7 @@ icalproperty* icalproperty_vanew_organizer(char* v, ...) return (icalproperty*)impl; } -void icalproperty_set_organizer(icalproperty* prop, char* v) +void icalproperty_set_organizer(icalproperty* prop, const char* v) { icalvalue *value; @@ -1466,7 +1509,7 @@ void icalproperty_set_organizer(icalproperty* prop, char* v) } -char* icalproperty_get_organizer(icalproperty* prop) +const char* icalproperty_get_organizer(icalproperty* prop) { icalvalue *value; icalerror_check_arg( (prop!=0),"prop"); @@ -1478,7 +1521,7 @@ char* icalproperty_get_organizer(icalproperty* prop) /* COMMENT */ -icalproperty* icalproperty_new_comment(char* v) +icalproperty* icalproperty_new_comment(const char* v) { struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_COMMENT_PROPERTY); icalerror_check_arg_rz( (v!=0),"v"); @@ -1489,7 +1532,7 @@ icalproperty* icalproperty_new_comment(char* v) return (icalproperty*)impl; } -icalproperty* icalproperty_vanew_comment(char* v, ...) +icalproperty* icalproperty_vanew_comment(const char* v, ...) { va_list args; struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_COMMENT_PROPERTY); @@ -1505,7 +1548,7 @@ icalproperty* icalproperty_vanew_comment(char* v, ...) return (icalproperty*)impl; } -void icalproperty_set_comment(icalproperty* prop, char* v) +void icalproperty_set_comment(icalproperty* prop, const char* v) { icalvalue *value; @@ -1519,7 +1562,7 @@ void icalproperty_set_comment(icalproperty* prop, char* v) } -char* icalproperty_get_comment(icalproperty* prop) +const char* icalproperty_get_comment(icalproperty* prop) { icalvalue *value; icalerror_check_arg( (prop!=0),"prop"); @@ -1531,7 +1574,7 @@ char* icalproperty_get_comment(icalproperty* prop) /* X-LIC-ERROR */ -icalproperty* icalproperty_new_xlicerror(char* v) +icalproperty* icalproperty_new_xlicerror(const char* v) { struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICERROR_PROPERTY); icalerror_check_arg_rz( (v!=0),"v"); @@ -1542,7 +1585,7 @@ icalproperty* icalproperty_new_xlicerror(char* v) return (icalproperty*)impl; } -icalproperty* icalproperty_vanew_xlicerror(char* v, ...) +icalproperty* icalproperty_vanew_xlicerror(const char* v, ...) { va_list args; struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICERROR_PROPERTY); @@ -1558,7 +1601,7 @@ icalproperty* icalproperty_vanew_xlicerror(char* v, ...) return (icalproperty*)impl; } -void icalproperty_set_xlicerror(icalproperty* prop, char* v) +void icalproperty_set_xlicerror(icalproperty* prop, const char* v) { icalvalue *value; @@ -1572,7 +1615,7 @@ void icalproperty_set_xlicerror(icalproperty* prop, char* v) } -char* icalproperty_get_xlicerror(icalproperty* prop) +const char* icalproperty_get_xlicerror(icalproperty* prop) { icalvalue *value; icalerror_check_arg( (prop!=0),"prop"); @@ -1634,7 +1677,7 @@ union icaltriggertype icalproperty_get_trigger(icalproperty* prop) /* CLASS */ -icalproperty* icalproperty_new_class(char* v) +icalproperty* icalproperty_new_class(const char* v) { struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_CLASS_PROPERTY); icalerror_check_arg_rz( (v!=0),"v"); @@ -1645,7 +1688,7 @@ icalproperty* icalproperty_new_class(char* v) return (icalproperty*)impl; } -icalproperty* icalproperty_vanew_class(char* v, ...) +icalproperty* icalproperty_vanew_class(const char* v, ...) { va_list args; struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_CLASS_PROPERTY); @@ -1661,7 +1704,7 @@ icalproperty* icalproperty_vanew_class(char* v, ...) return (icalproperty*)impl; } -void icalproperty_set_class(icalproperty* prop, char* v) +void icalproperty_set_class(icalproperty* prop, const char* v) { icalvalue *value; @@ -1675,7 +1718,7 @@ void icalproperty_set_class(icalproperty* prop, char* v) } -char* icalproperty_get_class(icalproperty* prop) +const char* icalproperty_get_class(icalproperty* prop) { icalvalue *value; icalerror_check_arg( (prop!=0),"prop"); @@ -1687,7 +1730,7 @@ char* icalproperty_get_class(icalproperty* prop) /* X */ -icalproperty* icalproperty_new_x(char* v) +icalproperty* icalproperty_new_x(const char* v) { struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_X_PROPERTY); icalerror_check_arg_rz( (v!=0),"v"); @@ -1698,7 +1741,7 @@ icalproperty* icalproperty_new_x(char* v) return (icalproperty*)impl; } -icalproperty* icalproperty_vanew_x(char* v, ...) +icalproperty* icalproperty_vanew_x(const char* v, ...) { va_list args; struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_X_PROPERTY); @@ -1714,7 +1757,7 @@ icalproperty* icalproperty_vanew_x(char* v, ...) return (icalproperty*)impl; } -void icalproperty_set_x(icalproperty* prop, char* v) +void icalproperty_set_x(icalproperty* prop, const char* v) { icalvalue *value; @@ -1728,7 +1771,7 @@ void icalproperty_set_x(icalproperty* prop, char* v) } -char* icalproperty_get_x(icalproperty* prop) +const char* icalproperty_get_x(icalproperty* prop) { icalvalue *value; icalerror_check_arg( (prop!=0),"prop"); @@ -1790,7 +1833,7 @@ int icalproperty_get_tzoffsetto(icalproperty* prop) /* TRANSP */ -icalproperty* icalproperty_new_transp(char* v) +icalproperty* icalproperty_new_transp(const char* v) { struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TRANSP_PROPERTY); icalerror_check_arg_rz( (v!=0),"v"); @@ -1801,7 +1844,7 @@ icalproperty* icalproperty_new_transp(char* v) return (icalproperty*)impl; } -icalproperty* icalproperty_vanew_transp(char* v, ...) +icalproperty* icalproperty_vanew_transp(const char* v, ...) { va_list args; struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TRANSP_PROPERTY); @@ -1817,7 +1860,7 @@ icalproperty* icalproperty_vanew_transp(char* v, ...) return (icalproperty*)impl; } -void icalproperty_set_transp(icalproperty* prop, char* v) +void icalproperty_set_transp(icalproperty* prop, const char* v) { icalvalue *value; @@ -1831,7 +1874,7 @@ void icalproperty_set_transp(icalproperty* prop, char* v) } -char* icalproperty_get_transp(icalproperty* prop) +const char* icalproperty_get_transp(icalproperty* prop) { icalvalue *value; icalerror_check_arg( (prop!=0),"prop"); @@ -1843,7 +1886,7 @@ char* icalproperty_get_transp(icalproperty* prop) /* X-LIC-MIMEENCODING */ -icalproperty* icalproperty_new_xlicmimeencoding(char* v) +icalproperty* icalproperty_new_xlicmimeencoding(const char* v) { struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICMIMEENCODING_PROPERTY); icalerror_check_arg_rz( (v!=0),"v"); @@ -1854,7 +1897,7 @@ icalproperty* icalproperty_new_xlicmimeencoding(char* v) return (icalproperty*)impl; } -icalproperty* icalproperty_vanew_xlicmimeencoding(char* v, ...) +icalproperty* icalproperty_vanew_xlicmimeencoding(const char* v, ...) { va_list args; struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICMIMEENCODING_PROPERTY); @@ -1870,7 +1913,7 @@ icalproperty* icalproperty_vanew_xlicmimeencoding(char* v, ...) return (icalproperty*)impl; } -void icalproperty_set_xlicmimeencoding(icalproperty* prop, char* v) +void icalproperty_set_xlicmimeencoding(icalproperty* prop, const char* v) { icalvalue *value; @@ -1884,7 +1927,7 @@ void icalproperty_set_xlicmimeencoding(icalproperty* prop, char* v) } -char* icalproperty_get_xlicmimeencoding(icalproperty* prop) +const char* icalproperty_get_xlicmimeencoding(icalproperty* prop) { icalvalue *value; icalerror_check_arg( (prop!=0),"prop"); @@ -1946,7 +1989,7 @@ int icalproperty_get_sequence(icalproperty* prop) /* LOCATION */ -icalproperty* icalproperty_new_location(char* v) +icalproperty* icalproperty_new_location(const char* v) { struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_LOCATION_PROPERTY); icalerror_check_arg_rz( (v!=0),"v"); @@ -1957,7 +2000,7 @@ icalproperty* icalproperty_new_location(char* v) return (icalproperty*)impl; } -icalproperty* icalproperty_vanew_location(char* v, ...) +icalproperty* icalproperty_vanew_location(const char* v, ...) { va_list args; struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_LOCATION_PROPERTY); @@ -1973,7 +2016,7 @@ icalproperty* icalproperty_vanew_location(char* v, ...) return (icalproperty*)impl; } -void icalproperty_set_location(icalproperty* prop, char* v) +void icalproperty_set_location(icalproperty* prop, const char* v) { icalvalue *value; @@ -1987,7 +2030,7 @@ void icalproperty_set_location(icalproperty* prop, char* v) } -char* icalproperty_get_location(icalproperty* prop) +const char* icalproperty_get_location(icalproperty* prop) { icalvalue *value; icalerror_check_arg( (prop!=0),"prop"); @@ -1999,7 +2042,7 @@ char* icalproperty_get_location(icalproperty* prop) /* REQUEST-STATUS */ -icalproperty* icalproperty_new_requeststatus(char* v) +icalproperty* icalproperty_new_requeststatus(const char* v) { struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_REQUESTSTATUS_PROPERTY); icalerror_check_arg_rz( (v!=0),"v"); @@ -2010,7 +2053,7 @@ icalproperty* icalproperty_new_requeststatus(char* v) return (icalproperty*)impl; } -icalproperty* icalproperty_vanew_requeststatus(char* v, ...) +icalproperty* icalproperty_vanew_requeststatus(const char* v, ...) { va_list args; struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_REQUESTSTATUS_PROPERTY); @@ -2026,7 +2069,7 @@ icalproperty* icalproperty_vanew_requeststatus(char* v, ...) return (icalproperty*)impl; } -void icalproperty_set_requeststatus(icalproperty* prop, char* v) +void icalproperty_set_requeststatus(icalproperty* prop, const char* v) { icalvalue *value; @@ -2040,7 +2083,7 @@ void icalproperty_set_requeststatus(icalproperty* prop, char* v) } -char* icalproperty_get_requeststatus(icalproperty* prop) +const char* icalproperty_get_requeststatus(icalproperty* prop) { icalvalue *value; icalerror_check_arg( (prop!=0),"prop"); @@ -2102,7 +2145,7 @@ struct icaltimetype icalproperty_get_exdate(icalproperty* prop) /* TZID */ -icalproperty* icalproperty_new_tzid(char* v) +icalproperty* icalproperty_new_tzid(const char* v) { struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TZID_PROPERTY); icalerror_check_arg_rz( (v!=0),"v"); @@ -2113,7 +2156,7 @@ icalproperty* icalproperty_new_tzid(char* v) return (icalproperty*)impl; } -icalproperty* icalproperty_vanew_tzid(char* v, ...) +icalproperty* icalproperty_vanew_tzid(const char* v, ...) { va_list args; struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TZID_PROPERTY); @@ -2129,7 +2172,7 @@ icalproperty* icalproperty_vanew_tzid(char* v, ...) return (icalproperty*)impl; } -void icalproperty_set_tzid(icalproperty* prop, char* v) +void icalproperty_set_tzid(icalproperty* prop, const char* v) { icalvalue *value; @@ -2143,7 +2186,7 @@ void icalproperty_set_tzid(icalproperty* prop, char* v) } -char* icalproperty_get_tzid(icalproperty* prop) +const char* icalproperty_get_tzid(icalproperty* prop) { icalvalue *value; icalerror_check_arg( (prop!=0),"prop"); @@ -2155,7 +2198,7 @@ char* icalproperty_get_tzid(icalproperty* prop) /* RESOURCES */ -icalproperty* icalproperty_new_resources(char* v) +icalproperty* icalproperty_new_resources(const char* v) { struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_RESOURCES_PROPERTY); icalerror_check_arg_rz( (v!=0),"v"); @@ -2166,7 +2209,7 @@ icalproperty* icalproperty_new_resources(char* v) return (icalproperty*)impl; } -icalproperty* icalproperty_vanew_resources(char* v, ...) +icalproperty* icalproperty_vanew_resources(const char* v, ...) { va_list args; struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_RESOURCES_PROPERTY); @@ -2182,7 +2225,7 @@ icalproperty* icalproperty_vanew_resources(char* v, ...) return (icalproperty*)impl; } -void icalproperty_set_resources(icalproperty* prop, char* v) +void icalproperty_set_resources(icalproperty* prop, const char* v) { icalvalue *value; @@ -2196,7 +2239,7 @@ void icalproperty_set_resources(icalproperty* prop, char* v) } -char* icalproperty_get_resources(icalproperty* prop) +const char* icalproperty_get_resources(icalproperty* prop) { icalvalue *value; icalerror_check_arg( (prop!=0),"prop"); @@ -2208,7 +2251,7 @@ char* icalproperty_get_resources(icalproperty* prop) /* TZURL */ -icalproperty* icalproperty_new_tzurl(char* v) +icalproperty* icalproperty_new_tzurl(const char* v) { struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TZURL_PROPERTY); icalerror_check_arg_rz( (v!=0),"v"); @@ -2219,7 +2262,7 @@ icalproperty* icalproperty_new_tzurl(char* v) return (icalproperty*)impl; } -icalproperty* icalproperty_vanew_tzurl(char* v, ...) +icalproperty* icalproperty_vanew_tzurl(const char* v, ...) { va_list args; struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TZURL_PROPERTY); @@ -2235,7 +2278,7 @@ icalproperty* icalproperty_vanew_tzurl(char* v, ...) return (icalproperty*)impl; } -void icalproperty_set_tzurl(icalproperty* prop, char* v) +void icalproperty_set_tzurl(icalproperty* prop, const char* v) { icalvalue *value; @@ -2249,7 +2292,7 @@ void icalproperty_set_tzurl(icalproperty* prop, char* v) } -char* icalproperty_get_tzurl(icalproperty* prop) +const char* icalproperty_get_tzurl(icalproperty* prop) { icalvalue *value; icalerror_check_arg( (prop!=0),"prop"); @@ -2511,7 +2554,7 @@ struct icaltimetype icalproperty_get_recurrenceid(icalproperty* prop) /* SUMMARY */ -icalproperty* icalproperty_new_summary(char* v) +icalproperty* icalproperty_new_summary(const char* v) { struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_SUMMARY_PROPERTY); icalerror_check_arg_rz( (v!=0),"v"); @@ -2522,7 +2565,7 @@ icalproperty* icalproperty_new_summary(char* v) return (icalproperty*)impl; } -icalproperty* icalproperty_vanew_summary(char* v, ...) +icalproperty* icalproperty_vanew_summary(const char* v, ...) { va_list args; struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_SUMMARY_PROPERTY); @@ -2538,7 +2581,7 @@ icalproperty* icalproperty_vanew_summary(char* v, ...) return (icalproperty*)impl; } -void icalproperty_set_summary(icalproperty* prop, char* v) +void icalproperty_set_summary(icalproperty* prop, const char* v) { icalvalue *value; @@ -2552,7 +2595,7 @@ void icalproperty_set_summary(icalproperty* prop, char* v) } -char* icalproperty_get_summary(icalproperty* prop) +const char* icalproperty_get_summary(icalproperty* prop) { icalvalue *value; icalerror_check_arg( (prop!=0),"prop"); @@ -2614,7 +2657,7 @@ struct icaltimetype icalproperty_get_dtend(icalproperty* prop) /* TZNAME */ -icalproperty* icalproperty_new_tzname(char* v) +icalproperty* icalproperty_new_tzname(const char* v) { struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TZNAME_PROPERTY); icalerror_check_arg_rz( (v!=0),"v"); @@ -2625,7 +2668,7 @@ icalproperty* icalproperty_new_tzname(char* v) return (icalproperty*)impl; } -icalproperty* icalproperty_vanew_tzname(char* v, ...) +icalproperty* icalproperty_vanew_tzname(const char* v, ...) { va_list args; struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_TZNAME_PROPERTY); @@ -2641,7 +2684,7 @@ icalproperty* icalproperty_vanew_tzname(char* v, ...) return (icalproperty*)impl; } -void icalproperty_set_tzname(icalproperty* prop, char* v) +void icalproperty_set_tzname(icalproperty* prop, const char* v) { icalvalue *value; @@ -2655,7 +2698,7 @@ void icalproperty_set_tzname(icalproperty* prop, char* v) } -char* icalproperty_get_tzname(icalproperty* prop) +const char* icalproperty_get_tzname(icalproperty* prop) { icalvalue *value; icalerror_check_arg( (prop!=0),"prop"); @@ -2717,7 +2760,7 @@ struct icalperiodtype icalproperty_get_rdate(icalproperty* prop) /* X-LIC-MIMEFILENAME */ -icalproperty* icalproperty_new_xlicmimefilename(char* v) +icalproperty* icalproperty_new_xlicmimefilename(const char* v) { struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICMIMEFILENAME_PROPERTY); icalerror_check_arg_rz( (v!=0),"v"); @@ -2728,7 +2771,7 @@ icalproperty* icalproperty_new_xlicmimefilename(char* v) return (icalproperty*)impl; } -icalproperty* icalproperty_vanew_xlicmimefilename(char* v, ...) +icalproperty* icalproperty_vanew_xlicmimefilename(const char* v, ...) { va_list args; struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICMIMEFILENAME_PROPERTY); @@ -2744,7 +2787,7 @@ icalproperty* icalproperty_vanew_xlicmimefilename(char* v, ...) return (icalproperty*)impl; } -void icalproperty_set_xlicmimefilename(icalproperty* prop, char* v) +void icalproperty_set_xlicmimefilename(icalproperty* prop, const char* v) { icalvalue *value; @@ -2758,7 +2801,7 @@ void icalproperty_set_xlicmimefilename(icalproperty* prop, char* v) } -char* icalproperty_get_xlicmimefilename(icalproperty* prop) +const char* icalproperty_get_xlicmimefilename(icalproperty* prop) { icalvalue *value; icalerror_check_arg( (prop!=0),"prop"); @@ -2770,7 +2813,7 @@ char* icalproperty_get_xlicmimefilename(icalproperty* prop) /* URL */ -icalproperty* icalproperty_new_url(char* v) +icalproperty* icalproperty_new_url(const char* v) { struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_URL_PROPERTY); icalerror_check_arg_rz( (v!=0),"v"); @@ -2781,7 +2824,7 @@ icalproperty* icalproperty_new_url(char* v) return (icalproperty*)impl; } -icalproperty* icalproperty_vanew_url(char* v, ...) +icalproperty* icalproperty_vanew_url(const char* v, ...) { va_list args; struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_URL_PROPERTY); @@ -2797,7 +2840,7 @@ icalproperty* icalproperty_vanew_url(char* v, ...) return (icalproperty*)impl; } -void icalproperty_set_url(icalproperty* prop, char* v) +void icalproperty_set_url(icalproperty* prop, const char* v) { icalvalue *value; @@ -2811,7 +2854,7 @@ void icalproperty_set_url(icalproperty* prop, char* v) } -char* icalproperty_get_url(icalproperty* prop) +const char* icalproperty_get_url(icalproperty* prop) { icalvalue *value; icalerror_check_arg( (prop!=0),"prop"); @@ -2973,7 +3016,7 @@ struct icalrecurrencetype icalproperty_get_exrule(icalproperty* prop) /* QUERY */ -icalproperty* icalproperty_new_query(char* v) +icalproperty* icalproperty_new_query(const char* v) { struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_QUERY_PROPERTY); icalerror_check_arg_rz( (v!=0),"v"); @@ -2984,7 +3027,7 @@ icalproperty* icalproperty_new_query(char* v) return (icalproperty*)impl; } -icalproperty* icalproperty_vanew_query(char* v, ...) +icalproperty* icalproperty_vanew_query(const char* v, ...) { va_list args; struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_QUERY_PROPERTY); @@ -3000,7 +3043,7 @@ icalproperty* icalproperty_vanew_query(char* v, ...) return (icalproperty*)impl; } -void icalproperty_set_query(icalproperty* prop, char* v) +void icalproperty_set_query(icalproperty* prop, const char* v) { icalvalue *value; @@ -3014,7 +3057,7 @@ void icalproperty_set_query(icalproperty* prop, char* v) } -char* icalproperty_get_query(icalproperty* prop) +const char* icalproperty_get_query(icalproperty* prop) { icalvalue *value; icalerror_check_arg( (prop!=0),"prop"); @@ -3076,7 +3119,7 @@ int icalproperty_get_percentcomplete(icalproperty* prop) /* CALSCALE */ -icalproperty* icalproperty_new_calscale(char* v) +icalproperty* icalproperty_new_calscale(const char* v) { struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_CALSCALE_PROPERTY); icalerror_check_arg_rz( (v!=0),"v"); @@ -3087,7 +3130,7 @@ icalproperty* icalproperty_new_calscale(char* v) return (icalproperty*)impl; } -icalproperty* icalproperty_vanew_calscale(char* v, ...) +icalproperty* icalproperty_vanew_calscale(const char* v, ...) { va_list args; struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_CALSCALE_PROPERTY); @@ -3103,7 +3146,7 @@ icalproperty* icalproperty_vanew_calscale(char* v, ...) return (icalproperty*)impl; } -void icalproperty_set_calscale(icalproperty* prop, char* v) +void icalproperty_set_calscale(icalproperty* prop, const char* v) { icalvalue *value; @@ -3117,7 +3160,7 @@ void icalproperty_set_calscale(icalproperty* prop, char* v) } -char* icalproperty_get_calscale(icalproperty* prop) +const char* icalproperty_get_calscale(icalproperty* prop) { icalvalue *value; icalerror_check_arg( (prop!=0),"prop"); @@ -3229,7 +3272,7 @@ struct icalgeotype icalproperty_get_geo(icalproperty* prop) /* X-LIC-MIMECHARSET */ -icalproperty* icalproperty_new_xlicmimecharset(char* v) +icalproperty* icalproperty_new_xlicmimecharset(const char* v) { struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICMIMECHARSET_PROPERTY); icalerror_check_arg_rz( (v!=0),"v"); @@ -3240,7 +3283,7 @@ icalproperty* icalproperty_new_xlicmimecharset(char* v) return (icalproperty*)impl; } -icalproperty* icalproperty_vanew_xlicmimecharset(char* v, ...) +icalproperty* icalproperty_vanew_xlicmimecharset(const char* v, ...) { va_list args; struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_XLICMIMECHARSET_PROPERTY); @@ -3256,7 +3299,7 @@ icalproperty* icalproperty_vanew_xlicmimecharset(char* v, ...) return (icalproperty*)impl; } -void icalproperty_set_xlicmimecharset(icalproperty* prop, char* v) +void icalproperty_set_xlicmimecharset(icalproperty* prop, const char* v) { icalvalue *value; @@ -3270,7 +3313,7 @@ void icalproperty_set_xlicmimecharset(icalproperty* prop, char* v) } -char* icalproperty_get_xlicmimecharset(icalproperty* prop) +const char* icalproperty_get_xlicmimecharset(icalproperty* prop) { icalvalue *value; icalerror_check_arg( (prop!=0),"prop"); @@ -3432,7 +3475,7 @@ struct icaltimetype icalproperty_get_due(icalproperty* prop) /* ACTION */ -icalproperty* icalproperty_new_action(char* v) +icalproperty* icalproperty_new_action(const char* v) { struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_ACTION_PROPERTY); icalerror_check_arg_rz( (v!=0),"v"); @@ -3443,7 +3486,7 @@ icalproperty* icalproperty_new_action(char* v) return (icalproperty*)impl; } -icalproperty* icalproperty_vanew_action(char* v, ...) +icalproperty* icalproperty_vanew_action(const char* v, ...) { va_list args; struct icalproperty_impl *impl = icalproperty_new_impl(ICAL_ACTION_PROPERTY); @@ -3459,7 +3502,7 @@ icalproperty* icalproperty_vanew_action(char* v, ...) return (icalproperty*)impl; } -void icalproperty_set_action(icalproperty* prop, char* v) +void icalproperty_set_action(icalproperty* prop, const char* v) { icalvalue *value; @@ -3473,7 +3516,7 @@ void icalproperty_set_action(icalproperty* prop, char* v) } -char* icalproperty_get_action(icalproperty* prop) +const char* icalproperty_get_action(icalproperty* prop) { icalvalue *value; icalerror_check_arg( (prop!=0),"prop"); diff --git a/libical/src/libical/icalproperty.h b/libical/src/libical/icalproperty.h index 278c4d533f..633a48f148 100644 --- a/libical/src/libical/icalproperty.h +++ b/libical/src/libical/icalproperty.h @@ -13,6 +13,9 @@ #define ICALPROPERTY_H #include <time.h> +#include "icalparameter.h" +#include "icalvalue.h" +#include "icalrecur.h" typedef void icalproperty; @@ -30,6 +33,7 @@ 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_remove_parameter(icalproperty* prop, icalparameter_kind kind); @@ -59,10 +63,10 @@ void icalproperty_set_method(icalproperty* prop, icalproperty_method v); icalproperty_method icalproperty_get_method(icalproperty* prop); /* X-LIC-MIMECID */ -icalproperty* icalproperty_new_xlicmimecid(char* v); -icalproperty* icalproperty_vanew_xlicmimecid(char* v, ...); -void icalproperty_set_xlicmimecid(icalproperty* prop, char* v); -char* icalproperty_get_xlicmimecid(icalproperty* prop); +icalproperty* icalproperty_new_xlicmimecid(const char* v); +icalproperty* icalproperty_vanew_xlicmimecid(const char* v, ...); +void icalproperty_set_xlicmimecid(icalproperty* prop, const char* v); +const char* icalproperty_get_xlicmimecid(icalproperty* prop); /* LAST-MODIFIED */ icalproperty* icalproperty_new_lastmodified(struct icaltimetype v); @@ -71,28 +75,28 @@ void icalproperty_set_lastmodified(icalproperty* prop, struct icaltimetype v); struct icaltimetype icalproperty_get_lastmodified(icalproperty* prop); /* UID */ -icalproperty* icalproperty_new_uid(char* v); -icalproperty* icalproperty_vanew_uid(char* v, ...); -void icalproperty_set_uid(icalproperty* prop, char* v); -char* icalproperty_get_uid(icalproperty* prop); +icalproperty* icalproperty_new_uid(const char* v); +icalproperty* icalproperty_vanew_uid(const char* v, ...); +void icalproperty_set_uid(icalproperty* prop, const char* v); +const char* icalproperty_get_uid(icalproperty* prop); /* PRODID */ -icalproperty* icalproperty_new_prodid(char* v); -icalproperty* icalproperty_vanew_prodid(char* v, ...); -void icalproperty_set_prodid(icalproperty* prop, char* v); -char* icalproperty_get_prodid(icalproperty* prop); +icalproperty* icalproperty_new_prodid(const char* v); +icalproperty* icalproperty_vanew_prodid(const char* v, ...); +void icalproperty_set_prodid(icalproperty* prop, const char* v); +const char* icalproperty_get_prodid(icalproperty* prop); /* STATUS */ -icalproperty* icalproperty_new_status(char* v); -icalproperty* icalproperty_vanew_status(char* v, ...); -void icalproperty_set_status(icalproperty* prop, char* v); -char* icalproperty_get_status(icalproperty* prop); +icalproperty* icalproperty_new_status(icalproperty_status v); +icalproperty* icalproperty_vanew_status(icalproperty_status v, ...); +void icalproperty_set_status(icalproperty* prop, icalproperty_status v); +icalproperty_status icalproperty_get_status(icalproperty* prop); /* DESCRIPTION */ -icalproperty* icalproperty_new_description(char* v); -icalproperty* icalproperty_vanew_description(char* v, ...); -void icalproperty_set_description(icalproperty* prop, char* v); -char* icalproperty_get_description(icalproperty* prop); +icalproperty* icalproperty_new_description(const char* v); +icalproperty* icalproperty_vanew_description(const char* v, ...); +void icalproperty_set_description(icalproperty* prop, const char* v); +const char* icalproperty_get_description(icalproperty* prop); /* DURATION */ icalproperty* icalproperty_new_duration(struct icaldurationtype v); @@ -101,16 +105,16 @@ void icalproperty_set_duration(icalproperty* prop, struct icaldurationtype v); struct icaldurationtype icalproperty_get_duration(icalproperty* prop); /* CATEGORIES */ -icalproperty* icalproperty_new_categories(char* v); -icalproperty* icalproperty_vanew_categories(char* v, ...); -void icalproperty_set_categories(icalproperty* prop, char* v); -char* icalproperty_get_categories(icalproperty* prop); +icalproperty* icalproperty_new_categories(const char* v); +icalproperty* icalproperty_vanew_categories(const char* v, ...); +void icalproperty_set_categories(icalproperty* prop, const char* v); +const char* icalproperty_get_categories(icalproperty* prop); /* VERSION */ -icalproperty* icalproperty_new_version(char* v); -icalproperty* icalproperty_vanew_version(char* v, ...); -void icalproperty_set_version(icalproperty* prop, char* v); -char* icalproperty_get_version(icalproperty* prop); +icalproperty* icalproperty_new_version(const char* v); +icalproperty* icalproperty_vanew_version(const char* v, ...); +void icalproperty_set_version(icalproperty* prop, const char* v); +const char* icalproperty_get_version(icalproperty* prop); /* TZOFFSETFROM */ icalproperty* icalproperty_new_tzoffsetfrom(int v); @@ -125,52 +129,52 @@ void icalproperty_set_rrule(icalproperty* prop, struct icalrecurrencetype v); struct icalrecurrencetype icalproperty_get_rrule(icalproperty* prop); /* ATTENDEE */ -icalproperty* icalproperty_new_attendee(char* v); -icalproperty* icalproperty_vanew_attendee(char* v, ...); -void icalproperty_set_attendee(icalproperty* prop, char* v); -char* icalproperty_get_attendee(icalproperty* prop); +icalproperty* icalproperty_new_attendee(const char* v); +icalproperty* icalproperty_vanew_attendee(const char* v, ...); +void icalproperty_set_attendee(icalproperty* prop, const char* v); +const char* icalproperty_get_attendee(icalproperty* prop); /* CONTACT */ -icalproperty* icalproperty_new_contact(char* v); -icalproperty* icalproperty_vanew_contact(char* v, ...); -void icalproperty_set_contact(icalproperty* prop, char* v); -char* icalproperty_get_contact(icalproperty* prop); +icalproperty* icalproperty_new_contact(const char* v); +icalproperty* icalproperty_vanew_contact(const char* v, ...); +void icalproperty_set_contact(icalproperty* prop, const char* v); +const char* icalproperty_get_contact(icalproperty* prop); /* X-LIC-MIMECONTENTTYPE */ -icalproperty* icalproperty_new_xlicmimecontenttype(char* v); -icalproperty* icalproperty_vanew_xlicmimecontenttype(char* v, ...); -void icalproperty_set_xlicmimecontenttype(icalproperty* prop, char* v); -char* icalproperty_get_xlicmimecontenttype(icalproperty* prop); +icalproperty* icalproperty_new_xlicmimecontenttype(const char* v); +icalproperty* icalproperty_vanew_xlicmimecontenttype(const char* v, ...); +void icalproperty_set_xlicmimecontenttype(icalproperty* prop, const char* v); +const char* icalproperty_get_xlicmimecontenttype(icalproperty* prop); /* X-LIC-MIMEOPTINFO */ -icalproperty* icalproperty_new_xlicmimeoptinfo(char* v); -icalproperty* icalproperty_vanew_xlicmimeoptinfo(char* v, ...); -void icalproperty_set_xlicmimeoptinfo(icalproperty* prop, char* v); -char* icalproperty_get_xlicmimeoptinfo(icalproperty* prop); +icalproperty* icalproperty_new_xlicmimeoptinfo(const char* v); +icalproperty* icalproperty_vanew_xlicmimeoptinfo(const char* v, ...); +void icalproperty_set_xlicmimeoptinfo(icalproperty* prop, const char* v); +const char* icalproperty_get_xlicmimeoptinfo(icalproperty* prop); /* RELATED-TO */ -icalproperty* icalproperty_new_relatedto(char* v); -icalproperty* icalproperty_vanew_relatedto(char* v, ...); -void icalproperty_set_relatedto(icalproperty* prop, char* v); -char* icalproperty_get_relatedto(icalproperty* prop); +icalproperty* icalproperty_new_relatedto(const char* v); +icalproperty* icalproperty_vanew_relatedto(const char* v, ...); +void icalproperty_set_relatedto(icalproperty* prop, const char* v); +const char* icalproperty_get_relatedto(icalproperty* prop); /* ORGANIZER */ -icalproperty* icalproperty_new_organizer(char* v); -icalproperty* icalproperty_vanew_organizer(char* v, ...); -void icalproperty_set_organizer(icalproperty* prop, char* v); -char* icalproperty_get_organizer(icalproperty* prop); +icalproperty* icalproperty_new_organizer(const char* v); +icalproperty* icalproperty_vanew_organizer(const char* v, ...); +void icalproperty_set_organizer(icalproperty* prop, const char* v); +const char* icalproperty_get_organizer(icalproperty* prop); /* COMMENT */ -icalproperty* icalproperty_new_comment(char* v); -icalproperty* icalproperty_vanew_comment(char* v, ...); -void icalproperty_set_comment(icalproperty* prop, char* v); -char* icalproperty_get_comment(icalproperty* prop); +icalproperty* icalproperty_new_comment(const char* v); +icalproperty* icalproperty_vanew_comment(const char* v, ...); +void icalproperty_set_comment(icalproperty* prop, const char* v); +const char* icalproperty_get_comment(icalproperty* prop); /* X-LIC-ERROR */ -icalproperty* icalproperty_new_xlicerror(char* v); -icalproperty* icalproperty_vanew_xlicerror(char* v, ...); -void icalproperty_set_xlicerror(icalproperty* prop, char* v); -char* icalproperty_get_xlicerror(icalproperty* prop); +icalproperty* icalproperty_new_xlicerror(const char* v); +icalproperty* icalproperty_vanew_xlicerror(const char* v, ...); +void icalproperty_set_xlicerror(icalproperty* prop, const char* v); +const char* icalproperty_get_xlicerror(icalproperty* prop); /* TRIGGER */ icalproperty* icalproperty_new_trigger(union icaltriggertype v); @@ -179,16 +183,16 @@ void icalproperty_set_trigger(icalproperty* prop, union icaltriggertype v); union icaltriggertype icalproperty_get_trigger(icalproperty* prop); /* CLASS */ -icalproperty* icalproperty_new_class(char* v); -icalproperty* icalproperty_vanew_class(char* v, ...); -void icalproperty_set_class(icalproperty* prop, char* v); -char* icalproperty_get_class(icalproperty* prop); +icalproperty* icalproperty_new_class(const char* v); +icalproperty* icalproperty_vanew_class(const char* v, ...); +void icalproperty_set_class(icalproperty* prop, const char* v); +const char* icalproperty_get_class(icalproperty* prop); /* X */ -icalproperty* icalproperty_new_x(char* v); -icalproperty* icalproperty_vanew_x(char* v, ...); -void icalproperty_set_x(icalproperty* prop, char* v); -char* icalproperty_get_x(icalproperty* prop); +icalproperty* icalproperty_new_x(const char* v); +icalproperty* icalproperty_vanew_x(const char* v, ...); +void icalproperty_set_x(icalproperty* prop, const char* v); +const char* icalproperty_get_x(icalproperty* prop); /* TZOFFSETTO */ icalproperty* icalproperty_new_tzoffsetto(int v); @@ -197,16 +201,16 @@ void icalproperty_set_tzoffsetto(icalproperty* prop, int v); int icalproperty_get_tzoffsetto(icalproperty* prop); /* TRANSP */ -icalproperty* icalproperty_new_transp(char* v); -icalproperty* icalproperty_vanew_transp(char* v, ...); -void icalproperty_set_transp(icalproperty* prop, char* v); -char* icalproperty_get_transp(icalproperty* prop); +icalproperty* icalproperty_new_transp(const char* v); +icalproperty* icalproperty_vanew_transp(const char* v, ...); +void icalproperty_set_transp(icalproperty* prop, const char* v); +const char* icalproperty_get_transp(icalproperty* prop); /* X-LIC-MIMEENCODING */ -icalproperty* icalproperty_new_xlicmimeencoding(char* v); -icalproperty* icalproperty_vanew_xlicmimeencoding(char* v, ...); -void icalproperty_set_xlicmimeencoding(icalproperty* prop, char* v); -char* icalproperty_get_xlicmimeencoding(icalproperty* prop); +icalproperty* icalproperty_new_xlicmimeencoding(const char* v); +icalproperty* icalproperty_vanew_xlicmimeencoding(const char* v, ...); +void icalproperty_set_xlicmimeencoding(icalproperty* prop, const char* v); +const char* icalproperty_get_xlicmimeencoding(icalproperty* prop); /* SEQUENCE */ icalproperty* icalproperty_new_sequence(int v); @@ -215,16 +219,16 @@ void icalproperty_set_sequence(icalproperty* prop, int v); int icalproperty_get_sequence(icalproperty* prop); /* LOCATION */ -icalproperty* icalproperty_new_location(char* v); -icalproperty* icalproperty_vanew_location(char* v, ...); -void icalproperty_set_location(icalproperty* prop, char* v); -char* icalproperty_get_location(icalproperty* prop); +icalproperty* icalproperty_new_location(const char* v); +icalproperty* icalproperty_vanew_location(const char* v, ...); +void icalproperty_set_location(icalproperty* prop, const char* v); +const char* icalproperty_get_location(icalproperty* prop); /* REQUEST-STATUS */ -icalproperty* icalproperty_new_requeststatus(char* v); -icalproperty* icalproperty_vanew_requeststatus(char* v, ...); -void icalproperty_set_requeststatus(icalproperty* prop, char* v); -char* icalproperty_get_requeststatus(icalproperty* prop); +icalproperty* icalproperty_new_requeststatus(const char* v); +icalproperty* icalproperty_vanew_requeststatus(const char* v, ...); +void icalproperty_set_requeststatus(icalproperty* prop, const char* v); +const char* icalproperty_get_requeststatus(icalproperty* prop); /* EXDATE */ icalproperty* icalproperty_new_exdate(struct icaltimetype v); @@ -233,22 +237,22 @@ void icalproperty_set_exdate(icalproperty* prop, struct icaltimetype v); struct icaltimetype icalproperty_get_exdate(icalproperty* prop); /* TZID */ -icalproperty* icalproperty_new_tzid(char* v); -icalproperty* icalproperty_vanew_tzid(char* v, ...); -void icalproperty_set_tzid(icalproperty* prop, char* v); -char* icalproperty_get_tzid(icalproperty* prop); +icalproperty* icalproperty_new_tzid(const char* v); +icalproperty* icalproperty_vanew_tzid(const char* v, ...); +void icalproperty_set_tzid(icalproperty* prop, const char* v); +const char* icalproperty_get_tzid(icalproperty* prop); /* RESOURCES */ -icalproperty* icalproperty_new_resources(char* v); -icalproperty* icalproperty_vanew_resources(char* v, ...); -void icalproperty_set_resources(icalproperty* prop, char* v); -char* icalproperty_get_resources(icalproperty* prop); +icalproperty* icalproperty_new_resources(const char* v); +icalproperty* icalproperty_vanew_resources(const char* v, ...); +void icalproperty_set_resources(icalproperty* prop, const char* v); +const char* icalproperty_get_resources(icalproperty* prop); /* TZURL */ -icalproperty* icalproperty_new_tzurl(char* v); -icalproperty* icalproperty_vanew_tzurl(char* v, ...); -void icalproperty_set_tzurl(icalproperty* prop, char* v); -char* icalproperty_get_tzurl(icalproperty* prop); +icalproperty* icalproperty_new_tzurl(const char* v); +icalproperty* icalproperty_vanew_tzurl(const char* v, ...); +void icalproperty_set_tzurl(icalproperty* prop, const char* v); +const char* icalproperty_get_tzurl(icalproperty* prop); /* REPEAT */ icalproperty* icalproperty_new_repeat(int v); @@ -281,10 +285,10 @@ void icalproperty_set_recurrenceid(icalproperty* prop, struct icaltimetype v); struct icaltimetype icalproperty_get_recurrenceid(icalproperty* prop); /* SUMMARY */ -icalproperty* icalproperty_new_summary(char* v); -icalproperty* icalproperty_vanew_summary(char* v, ...); -void icalproperty_set_summary(icalproperty* prop, char* v); -char* icalproperty_get_summary(icalproperty* prop); +icalproperty* icalproperty_new_summary(const char* v); +icalproperty* icalproperty_vanew_summary(const char* v, ...); +void icalproperty_set_summary(icalproperty* prop, const char* v); +const char* icalproperty_get_summary(icalproperty* prop); /* DTEND */ icalproperty* icalproperty_new_dtend(struct icaltimetype v); @@ -293,10 +297,10 @@ void icalproperty_set_dtend(icalproperty* prop, struct icaltimetype v); struct icaltimetype icalproperty_get_dtend(icalproperty* prop); /* TZNAME */ -icalproperty* icalproperty_new_tzname(char* v); -icalproperty* icalproperty_vanew_tzname(char* v, ...); -void icalproperty_set_tzname(icalproperty* prop, char* v); -char* icalproperty_get_tzname(icalproperty* prop); +icalproperty* icalproperty_new_tzname(const char* v); +icalproperty* icalproperty_vanew_tzname(const char* v, ...); +void icalproperty_set_tzname(icalproperty* prop, const char* v); +const char* icalproperty_get_tzname(icalproperty* prop); /* RDATE */ icalproperty* icalproperty_new_rdate(struct icalperiodtype v); @@ -305,16 +309,16 @@ void icalproperty_set_rdate(icalproperty* prop, struct icalperiodtype v); struct icalperiodtype icalproperty_get_rdate(icalproperty* prop); /* X-LIC-MIMEFILENAME */ -icalproperty* icalproperty_new_xlicmimefilename(char* v); -icalproperty* icalproperty_vanew_xlicmimefilename(char* v, ...); -void icalproperty_set_xlicmimefilename(icalproperty* prop, char* v); -char* icalproperty_get_xlicmimefilename(icalproperty* prop); +icalproperty* icalproperty_new_xlicmimefilename(const char* v); +icalproperty* icalproperty_vanew_xlicmimefilename(const char* v, ...); +void icalproperty_set_xlicmimefilename(icalproperty* prop, const char* v); +const char* icalproperty_get_xlicmimefilename(icalproperty* prop); /* URL */ -icalproperty* icalproperty_new_url(char* v); -icalproperty* icalproperty_vanew_url(char* v, ...); -void icalproperty_set_url(icalproperty* prop, char* v); -char* icalproperty_get_url(icalproperty* prop); +icalproperty* icalproperty_new_url(const char* v); +icalproperty* icalproperty_vanew_url(const char* v, ...); +void icalproperty_set_url(icalproperty* prop, const char* v); +const char* icalproperty_get_url(icalproperty* prop); /* X-LIC-CLUSTERCOUNT */ icalproperty* icalproperty_new_xlicclustercount(int v); @@ -335,10 +339,10 @@ void icalproperty_set_exrule(icalproperty* prop, struct icalrecurrencetype v); struct icalrecurrencetype icalproperty_get_exrule(icalproperty* prop); /* QUERY */ -icalproperty* icalproperty_new_query(char* v); -icalproperty* icalproperty_vanew_query(char* v, ...); -void icalproperty_set_query(icalproperty* prop, char* v); -char* icalproperty_get_query(icalproperty* prop); +icalproperty* icalproperty_new_query(const char* v); +icalproperty* icalproperty_vanew_query(const char* v, ...); +void icalproperty_set_query(icalproperty* prop, const char* v); +const char* icalproperty_get_query(icalproperty* prop); /* PERCENT-COMPLETE */ icalproperty* icalproperty_new_percentcomplete(int v); @@ -347,10 +351,10 @@ void icalproperty_set_percentcomplete(icalproperty* prop, int v); int icalproperty_get_percentcomplete(icalproperty* prop); /* CALSCALE */ -icalproperty* icalproperty_new_calscale(char* v); -icalproperty* icalproperty_vanew_calscale(char* v, ...); -void icalproperty_set_calscale(icalproperty* prop, char* v); -char* icalproperty_get_calscale(icalproperty* prop); +icalproperty* icalproperty_new_calscale(const char* v); +icalproperty* icalproperty_vanew_calscale(const char* v, ...); +void icalproperty_set_calscale(icalproperty* prop, const char* v); +const char* icalproperty_get_calscale(icalproperty* prop); /* CREATED */ icalproperty* icalproperty_new_created(struct icaltimetype v); @@ -365,10 +369,10 @@ void icalproperty_set_geo(icalproperty* prop, struct icalgeotype v); struct icalgeotype icalproperty_get_geo(icalproperty* prop); /* X-LIC-MIMECHARSET */ -icalproperty* icalproperty_new_xlicmimecharset(char* v); -icalproperty* icalproperty_vanew_xlicmimecharset(char* v, ...); -void icalproperty_set_xlicmimecharset(icalproperty* prop, char* v); -char* icalproperty_get_xlicmimecharset(icalproperty* prop); +icalproperty* icalproperty_new_xlicmimecharset(const char* v); +icalproperty* icalproperty_vanew_xlicmimecharset(const char* v, ...); +void icalproperty_set_xlicmimecharset(icalproperty* prop, const char* v); +const char* icalproperty_get_xlicmimecharset(icalproperty* prop); /* COMPLETED */ icalproperty* icalproperty_new_completed(struct icaltimetype v); @@ -389,8 +393,8 @@ void icalproperty_set_due(icalproperty* prop, struct icaltimetype v); struct icaltimetype icalproperty_get_due(icalproperty* prop); /* ACTION */ -icalproperty* icalproperty_new_action(char* v); -icalproperty* icalproperty_vanew_action(char* v, ...); -void icalproperty_set_action(icalproperty* prop, char* v); -char* icalproperty_get_action(icalproperty* prop); -#endif ICALPROPERTY_H +icalproperty* icalproperty_new_action(const char* v); +icalproperty* icalproperty_vanew_action(const char* v, ...); +void icalproperty_set_action(icalproperty* prop, const char* v); +const char* icalproperty_get_action(icalproperty* prop); +#endif /*ICALPROPERTY_H*/ diff --git a/libical/src/libical/icalrestriction.c b/libical/src/libical/icalrestriction.c index be0e292d28..8607c3adab 100644 --- a/libical/src/libical/icalrestriction.c +++ b/libical/src/libical/icalrestriction.c @@ -4,20 +4,29 @@ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org ======================================================================*/ +/*#line 7 "icalrestriction.c.in"*/ #ifdef HAVE_CONFIG_H -#include "config.h" +#include <config.h> #endif -#include "icalenums.h" #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 */ -typedef int (*restriction_func)(icalcomponent* comp); +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; @@ -36,9 +45,22 @@ typedef struct icalrestriction_component_record { 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 @@ -86,22 +108,173 @@ icalrestriction_compare(icalrestriction_kind restr, int count){ } -int icalrestriction_check_mutual(icalcomponent *comp){ - /* HACK. This function does nothing */ - return 1; +/* 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; } -int icalrestriction_check_exclusive(icalcomponent *comp){ - /* HACK. This function does nothing */ - return 1; +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 DTEND 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; @@ -113,30 +286,30 @@ int icalrestriction_check_component(icalproperty_method method, for(kind = ICAL_ANY_PROPERTY+1; kind != ICAL_NO_PROPERTY; kind++){ count = icalcomponent_count_properties(comp, kind); - restr = icalrestriction_get_property_restriction(method, + prop_record = icalrestriction_get_property_restriction(method, comp_kind, kind); + restr = prop_record->restriction; - if(restr == ICAL_RESTRICTION_ONEEXCLUSIVE ) { - /* HACK. Treat this as a 0/1 restriction */ - restr = ICAL_RESTRICTION_ZEROORONE; - compare = icalrestriction_compare(restr,count); - } else if (restr == ICAL_RESTRICTION_ONEMUTUAL ) { - /* HACK. Treat this as a 0/1 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 property %s. Expected %s instances of the property and got %d", + 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); @@ -149,6 +322,25 @@ int icalrestriction_check_component(icalproperty_method method, } + 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; + funcr = 0; + } + valid = valid && compare; } @@ -210,7 +402,7 @@ int icalrestriction_check(icalcomponent* outer_comp) } -icalrestriction_kind +icalrestriction_property_record* icalrestriction_get_property_restriction(icalproperty_method method, icalcomponent_kind component, icalproperty_kind property) @@ -224,19 +416,20 @@ icalrestriction_get_property_restriction(icalproperty_method method, if (method == icalrestriction_property_records[i].method && component == icalrestriction_property_records[i].component && property == icalrestriction_property_records[i].property ){ - return icalrestriction_property_records[i].restriction; + return &icalrestriction_property_records[i]; } } - return ICAL_RESTRICTION_UNKNOWN; + return &null_prop_record; } -icalrestriction_kind + +icalrestriction_component_record* icalrestriction_get_component_restriction(icalproperty_method method, icalcomponent_kind component, icalcomponent_kind subcomponent) { - + int i; for(i = 0; @@ -246,11 +439,11 @@ icalrestriction_get_component_restriction(icalproperty_method method, if (method == icalrestriction_component_records[i].method && component == icalrestriction_component_records[i].component && subcomponent == icalrestriction_component_records[i].subcomponent ){ - return icalrestriction_component_records[i].restriction; + return &icalrestriction_component_records[i]; } } - return ICAL_RESTRICTION_UNKNOWN; + return &null_comp_record; } /* Everything below this line is machine generated. Do not edit. */ @@ -260,7 +453,7 @@ icalrestriction_property_record icalrestriction_property_records[] = { {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,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}, @@ -281,7 +474,7 @@ icalrestriction_property_record icalrestriction_property_records[] = { {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,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}, @@ -301,8 +494,8 @@ icalrestriction_property_record icalrestriction_property_records[] = { {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_check_exclusive}, - {ICAL_METHOD_REQUEST,ICAL_VEVENT_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ONEEXCLUSIVE,icalrestriction_check_exclusive}, + {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}, @@ -310,19 +503,19 @@ icalrestriction_property_record icalrestriction_property_records[] = { {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,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,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,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}, @@ -332,9 +525,9 @@ icalrestriction_property_record icalrestriction_property_records[] = { {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_check_exclusive}, + {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_check_exclusive}, + {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}, @@ -365,8 +558,8 @@ icalrestriction_property_record icalrestriction_property_records[] = { {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_check_exclusive}, - {ICAL_METHOD_ADD,ICAL_VEVENT_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ONEEXCLUSIVE, icalrestriction_check_exclusive}, + {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}, @@ -377,11 +570,11 @@ icalrestriction_property_record icalrestriction_property_records[] = { {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,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,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}, @@ -395,9 +588,9 @@ icalrestriction_property_record icalrestriction_property_records[] = { {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_check_exclusive}, + {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_check_exclusive}, + {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}, @@ -405,11 +598,11 @@ icalrestriction_property_record icalrestriction_property_records[] = { {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,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,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}, @@ -420,7 +613,7 @@ icalrestriction_property_record icalrestriction_property_records[] = { {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,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}, @@ -461,8 +654,8 @@ icalrestriction_property_record icalrestriction_property_records[] = { {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_check_exclusive}, - {ICAL_METHOD_COUNTER,ICAL_VEVENT_COMPONENT,ICAL_DURATION_PROPERTY,ICAL_RESTRICTION_ONEEXCLUSIVE, icalrestriction_check_exclusive}, + {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}, @@ -470,12 +663,12 @@ icalrestriction_property_record icalrestriction_property_records[] = { {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,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,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}, @@ -483,7 +676,7 @@ icalrestriction_property_record icalrestriction_property_records[] = { {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,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}, @@ -574,7 +767,7 @@ icalrestriction_property_record icalrestriction_property_records[] = { {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,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}, @@ -607,11 +800,11 @@ icalrestriction_property_record icalrestriction_property_records[] = { {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,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,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}, @@ -641,7 +834,7 @@ icalrestriction_property_record icalrestriction_property_records[] = { {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,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}, @@ -674,10 +867,10 @@ icalrestriction_property_record icalrestriction_property_records[] = { {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,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,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}, @@ -701,19 +894,19 @@ icalrestriction_property_record icalrestriction_property_records[] = { {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,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,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,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}, @@ -764,13 +957,13 @@ icalrestriction_property_record icalrestriction_property_records[] = { {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,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,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}, @@ -796,7 +989,7 @@ icalrestriction_property_record icalrestriction_property_records[] = { {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,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}, @@ -819,11 +1012,11 @@ icalrestriction_property_record icalrestriction_property_records[] = { {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,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,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}, @@ -869,10 +1062,10 @@ icalrestriction_property_record icalrestriction_property_records[] = { {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,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,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}, @@ -936,11 +1129,11 @@ icalrestriction_property_record icalrestriction_property_records[] = { {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_check_exclusive}, + {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_check_exclusive}, + {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}, @@ -953,7 +1146,7 @@ icalrestriction_property_record icalrestriction_property_records[] = { {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,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}, @@ -1001,7 +1194,7 @@ icalrestriction_property_record icalrestriction_property_records[] = { {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,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}, @@ -1049,7 +1242,7 @@ icalrestriction_property_record icalrestriction_property_records[] = { {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,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}, @@ -1276,8 +1469,8 @@ icalrestriction_property_record icalrestriction_property_records[] = { {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_check_mutual}, - {ICAL_METHOD_NONE,ICAL_XAUDIOALARM_COMPONENT,ICAL_REPEAT_PROPERTY,ICAL_RESTRICTION_ONEMUTUAL,icalrestriction_check_mutual}, + {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}, @@ -1324,8 +1517,8 @@ icalrestriction_property_record icalrestriction_property_records[] = { {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_check_mutual}, - {ICAL_METHOD_NONE,ICAL_XDISPLAYALARM_COMPONENT,ICAL_REPEAT_PROPERTY,ICAL_RESTRICTION_ONEMUTUAL,icalrestriction_check_mutual}, + {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}, @@ -1372,8 +1565,8 @@ icalrestriction_property_record icalrestriction_property_records[] = { {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_check_mutual}, - {ICAL_METHOD_NONE,ICAL_XEMAILALARM_COMPONENT,ICAL_REPEAT_PROPERTY,ICAL_RESTRICTION_ONEMUTUAL,icalrestriction_check_mutual}, + {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}, @@ -1420,8 +1613,8 @@ icalrestriction_property_record icalrestriction_property_records[] = { {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_check_mutual}, - {ICAL_METHOD_NONE,ICAL_XPROCEDUREALARM_COMPONENT,ICAL_REPEAT_PROPERTY,ICAL_RESTRICTION_ONEMUTUAL,icalrestriction_check_mutual}, + {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}, @@ -1453,34 +1646,34 @@ icalrestriction_property_record icalrestriction_property_records[] = { {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,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,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,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,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,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,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}, @@ -1490,10 +1683,10 @@ icalrestriction_component_record icalrestriction_component_records[] = { {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,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,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}, @@ -1502,13 +1695,13 @@ icalrestriction_component_record icalrestriction_component_records[] = { {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,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,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}, @@ -1583,5 +1776,5 @@ icalrestriction_component_record icalrestriction_component_records[] = { {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,0} + {ICAL_METHOD_NONE,ICAL_NO_COMPONENT,ICAL_NO_COMPONENT,ICAL_RESTRICTION_NONE} }; diff --git a/libical/src/libical/icalrestriction.h b/libical/src/libical/icalrestriction.h index 12421d0f32..409334cf28 100644 --- a/libical/src/libical/icalrestriction.h +++ b/libical/src/libical/icalrestriction.h @@ -27,7 +27,8 @@ ======================================================================*/ -#include "ical.h" +#include "icalproperty.h" +#include "icalcomponent.h" #ifndef ICALRESTRICTION_H #define ICALRESTRICTION_H @@ -48,15 +49,6 @@ typedef enum icalrestriction_kind { int icalrestriction_compare(icalrestriction_kind restr, int count); -icalrestriction_kind -icalrestriction_get_property_restriction(icalproperty_method method, - icalcomponent_kind component, - icalproperty_kind property); - -icalrestriction_kind -icalrestriction_get_component_restriction(icalproperty_method method, - icalcomponent_kind component, - icalcomponent_kind subcomponent); int icalrestriction_is_parameter_allowed(icalproperty_kind property, diff --git a/libical/src/libical/icaltime.c b/libical/src/libical/icaltime.c index 6d651922d5..2fc965e1a8 100644 --- a/libical/src/libical/icaltime.c +++ b/libical/src/libical/icaltime.c @@ -4,7 +4,6 @@ CREATOR: eric 02 June 2000 $Id$ - $Locker$ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org @@ -26,7 +25,12 @@ ======================================================================*/ #include "icaltime.h" +#include "icalvalue.h" #include <assert.h> +#include <string.h> +#include <stdlib.h> +#include <stdio.h> + struct icaltimetype icaltime_from_timet(time_t tm, int is_date, int is_utc) @@ -34,11 +38,12 @@ icaltime_from_timet(time_t tm, int is_date, int is_utc) struct icaltimetype tt; struct tm t; - if(is_utc == 1){ - t = *(gmtime(&tm)); - } else { - t = *(localtime(&tm)); + if(is_utc == 0){ + tm += icaltime_local_utc_offset(); } + + t = *(localtime(&tm)); + tt.second = t.tm_sec; tt.minute = t.tm_min; tt.hour = t.tm_hour; @@ -52,6 +57,7 @@ icaltime_from_timet(time_t tm, int is_date, int is_utc) return tt; } +/* Always returns time in UTC */ time_t icaltime_as_timet(struct icaltimetype tt) { struct tm stm; @@ -68,11 +74,47 @@ time_t icaltime_as_timet(struct icaltimetype tt) stm.tm_isdst = -1; /* prevents mktime from changing hour based on daylight savings */ + if(tt.is_utc == 0){ + stm.tm_sec -= icaltime_local_utc_offset(); + } + tut = mktime(&stm); return tut; } + + +struct icaltimetype icaltime_from_string(const char* str) +{ + struct icaltimetype tt; + icalvalue *v = icalvalue_new_from_string(ICAL_DATETIME_VALUE,str); + + if (v == 0){ + return icaltime_null_time(); + } + + tt = icalvalue_get_datetime(v); + + icalvalue_free(v); + + return tt; + +} + +char ctime_str[20]; +char* icaltime_as_ctime(struct icaltimetype t) +{ + time_t 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) @@ -180,20 +222,187 @@ int icaltime_compare(struct icaltimetype a,struct icaltimetype b) } } - -int icaltime_compare_date_only(struct icaltimetype a, struct icaltimetype b) +int +icaltime_compare_date_only (struct icaltimetype a, struct icaltimetype b) { - time_t t1 = icaltime_as_timet(a); - time_t t2 = icaltime_as_timet(b); + time_t t1; + time_t t2; - if (a.year == b.year && a.month == b.month && a.day == b.day) { + if (a.year == b.year && a.month == b.month && a.day == b.day) return 0; - } - if (t1 > t2) { + t1 = icaltime_as_timet (a); + t2 = icaltime_as_timet (b); + + if (t1 > t2) return 1; - } else if (t1 < t2) { + else if (t1 < t2) return -1; + else { + /* not reached */ + assert (0); + return 0; + } +} + +/* convert tt, of timezone tzid, into a utc time */ +struct icaltimetype icaltime_as_utc(struct icaltimetype tt,const char* tzid) +{ + time_t offset, tm; + struct icaltimetype utc; + + offset = icaltime_utc_offset(tt,tzid); + tm = icaltime_as_timet(tt); + + tm += offset; + + utc = icaltime_from_timet(tm,0,0); + + return utc; +} + +/* convert tt, a time in UTC, into a time in timezone tzid */ +struct icaltimetype icaltime_as_zone(struct icaltimetype tt,const char* tzid) +{ + time_t offset, tm; + struct icaltimetype zone; + + offset = icaltime_utc_offset(tt,tzid); + tm = icaltime_as_timet(tt); + + tm -= offset; + + zone = icaltime_from_timet(tm,0,0); + + return zone; + +} + +/* Return the offset of the named zone as seconds. tt is a time + indicating the date for which you want the offset */ +time_t icaltime_utc_offset(struct icaltimetype tt, const char* tzid) +{ + extern long int timezone; + time_t now; + struct tm *stm; + + char *tzstr = 0; + char *tmp; + + /* Put the new time zone into the environment */ + if(getenv("TZ") != 0){ + tzstr = (char*)strdup(getenv("TZ")); + } + + tmp = (char*)malloc(1024); + snprintf(tmp,1024,"TZ=%s",tzid); + + putenv(tmp); + + /* Get the offset */ + + now = icaltime_as_timet(tt); + + stm = localtime(&now); /* This sets 'timezone'*/ + + /* restore the original environment */ + + if(tzstr!=0){ + putenv(tzstr); + } else { + putenv("TZ"); /* Delete from environment */ + } + + return timezone; +} + +time_t icaltime_local_utc_offset() +{ + time_t now; + struct tm *stm; + + stm = localtime(&now); /* This sets 'timezone'*/ + + return timezone; + +} + + + + + + +time_t +icalperiodtype_duration (struct icalperiodtype period); + + +time_t +icalperiodtype_end (struct icalperiodtype period); + + +/* From Russel Steinthal */ +time_t icaldurationtype_as_timet(struct icaldurationtype dur) +{ + return (time_t) (dur.seconds + + (60 * dur.minutes) + + (60 * 60 * dur.hours) + + (60 * 60 * 24 * dur.days) + + (60 * 60 * 24 * 7 * dur.weeks)); +} + +/* From Seth Alves, <alves@hungry.com> */ +struct icaldurationtype icaldurationtype_from_timet(time_t t) +{ + struct icaldurationtype dur; + time_t used = 0; + + dur.weeks = (t - used) / (60 * 60 * 24 * 7); + 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; +} + +struct icaldurationtype icaldurationtype_from_string(const char* str) +{ + + icalvalue *v = icalvalue_new_from_string(ICAL_DURATION_VALUE,str); + + if( v !=0){ + return icalvalue_get_duration(v); + } else { + struct icaldurationtype dur; + memset(&dur,0,sizeof(struct icaldurationtype)); + return dur; } + } + +struct icaltimetype icaltime_add(struct icaltimetype t, + struct icaldurationtype d) +{ + time_t tt = icaltime_as_timet(t); + time_t dt = icaldurationtype_as_timet(d); + + return icaltime_from_timet(tt + dt, t.is_date, t.is_utc); + +} + +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_timet(t1t-t2t); + + +} diff --git a/libical/src/libical/icaltime.h b/libical/src/libical/icaltime.h index 6c5b653c23..1402f65d4e 100644 --- a/libical/src/libical/icaltime.h +++ b/libical/src/libical/icaltime.h @@ -1,11 +1,9 @@ -// -*- Mode: C -*- +/* -*- Mode: C -*- */ /*====================================================================== FILE: icaltime.h CREATOR: eric 02 June 2000 - $Id$ - $Locker$ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org @@ -31,6 +29,13 @@ #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; @@ -45,7 +50,7 @@ struct icaltimetype int is_date; /* 1 -> interpret this as date. */ }; -struct icaltimetype icaltime_null_time(); +struct icaltimetype icaltime_null_time(void); int icaltime_is_null_time(struct icaltimetype t); @@ -58,17 +63,71 @@ short icaltime_day_of_week(struct icaltimetype t); short icaltime_start_doy_of_week(struct icaltimetype t); struct icaltimetype icaltime_from_timet(time_t v, int is_date, int is_utc); +struct icaltimetype icaltime_from_string(const char* str); time_t icaltime_as_timet(struct icaltimetype); +char* icaltime_as_ctime(struct icaltimetype); short icaltime_week_number(short day_of_month, short month, short year); struct icaltimetype icaltime_from_week_number(short week_number, short year); int icaltime_compare(struct icaltimetype a,struct icaltimetype b); + int icaltime_compare_date_only(struct icaltimetype a, struct icaltimetype b); short icaltime_days_in_month(short month,short year); +/* 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 */ +time_t icaltime_utc_offset(struct icaltimetype tt, const char* tzid); + +time_t icaltime_local_utc_offset(); + + +/* convert tt, of timezone tzid, into a utc time */ +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); + + + +struct icaldurationtype +{ + int is_neg; + unsigned int days; + unsigned int weeks; + unsigned int hours; + unsigned int minutes; + unsigned int seconds; +}; + +struct icaldurationtype icaldurationtype_from_timet(time_t t); +struct icaldurationtype icaldurationtype_from_string(const char*); +time_t icaldurationtype_as_timet(struct icaldurationtype duration); + + +struct icalperiodtype +{ + struct icaltimetype start; /* Must be absolute */ + struct icaltimetype end; /* Must be absolute */ + struct icaldurationtype duration; +}; + +time_t icalperiodtype_duration(struct icalperiodtype period); +time_t icalperiodtype_end(struct icalperiodtype period); + + + +struct icaltimetype icaltime_add(struct icaltimetype t, + struct icaldurationtype d); + +struct icaldurationtype icaltime_subtract(struct icaltimetype t1, + struct icaltimetype t2); + + #endif /* !ICALTIME_H */ diff --git a/libical/src/libical/icaltypes.c b/libical/src/libical/icaltypes.c index c7017eb2af..dedde8d866 100644 --- a/libical/src/libical/icaltypes.c +++ b/libical/src/libical/icaltypes.c @@ -4,7 +4,6 @@ CREATOR: eric 16 May 1999 $Id$ - $Locker$ (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org @@ -34,7 +33,6 @@ #include <errno.h> /* for errno */ #include <string.h> /* for icalmemory_strdup */ #include <assert.h> -#include <limits.h> /* for SHRT_MAX */ #define TEMP_MAX 1024 @@ -151,75 +149,6 @@ void* icalattachtype_get_binary(struct icalattachtype* v) -time_t -icalperiodtype_duration (struct icalperiodtype period); - - -time_t -icalperiodtype_end (struct icalperiodtype period); - - -/* From Russel Steinthal */ -time_t icaldurationtype_as_timet(struct icaldurationtype dur) -{ - return (time_t) (dur.seconds + - (60 * dur.minutes) + - (60 * 60 * dur.hours) + - (60 * 60 * 24 * dur.days) + - (60 * 60 * 24 * 7 * dur.weeks)); -} - -/* From Seth Alves, <alves@hungry.com> */ -struct icaldurationtype icaldurationtype_from_timet(time_t t) -{ - struct icaldurationtype dur; - time_t used = 0; - - dur.weeks = (t - used) / (60 * 60 * 24 * 7); - 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; -} - -void icalrecurrencetype_clear(struct icalrecurrencetype *recur) -{ - memset(recur,ICAL_RECURRENCE_ARRAY_MAX_BYTE, - sizeof(struct icalrecurrencetype)); - - recur->week_start = ICAL_NO_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 - */ - -enum icalrecurrencetype_weekday icalrecurrencetype_day_day_of_week(short day) -{ - return abs(day)%8; -} - -short icalrecurrencetype_day_position(short day) -{ - return (day-icalrecurrencetype_day_day_of_week(day))/8; -} - - struct icalreqstattype icalreqstattype_from_string(char* str) { char *p1,*p2; diff --git a/libical/src/libical/icaltypes.h b/libical/src/libical/icaltypes.h index 1130ab2457..d2a106883b 100644 --- a/libical/src/libical/icaltypes.h +++ b/libical/src/libical/icaltypes.h @@ -46,7 +46,7 @@ struct icalattachtype /* converts base64 to binary, fetches url and stores as binary, or just returns data */ -struct icalattachtype* icalattachtype_new(); +struct icalattachtype* icalattachtype_new(void); void icalattachtype_add_reference(struct icalattachtype* v); void icalattachtype_free(struct icalattachtype* v); @@ -69,84 +69,6 @@ struct icalgeotype -/* See RFC 2445 Section 4.3.10, RECUR Value, for an explaination of - the values and fields in struct icalrecurrencetype */ - - -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 SHRT_MAX - * unless the the list is full. */ - - short by_second[61]; - short by_minute[61]; - short by_hour[25]; - short by_day[8]; /* Encoded value, see below */ - short by_month_day[32]; - short by_year_day[367]; - short by_week_no[54]; - short by_month[13]; - short by_set_pos[367]; -}; - - -void icalrecurrencetype_clear(struct icalrecurrencetype *r); - -/* 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 */ - -/* 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); - -struct icaldurationtype -{ - unsigned int days; - unsigned int weeks; - unsigned int hours; - unsigned int minutes; - unsigned int seconds; -}; - -struct icaldurationtype icaldurationtype_from_timet(time_t t); -time_t icaldurationtype_as_timet(struct icaldurationtype duration); - -/* Return the next occurance of 'r' after the time specified by 'after' */ -struct icaltimetype icalrecurrencetype_next_occurance( - struct icalrecurrencetype *r, - struct icaltimetype *after); - - -struct icalperiodtype -{ - struct icaltimetype start; /* Must be absolute */ - struct icaltimetype end; /* Must be absolute */ - struct icaldurationtype duration; -}; - -time_t icalperiodtype_duration(struct icalperiodtype period); -time_t icalperiodtype_end(struct icalperiodtype period); - union icaltriggertype { struct icaltimetype time; @@ -154,6 +76,7 @@ union icaltriggertype }; + /* 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 @@ -168,8 +91,8 @@ operating on a the value of a request_status property. */ struct icalreqstattype { icalrequeststatus code; - char* desc; - char* debug; + const char* desc; + const char* debug; }; struct icalreqstattype icalreqstattype_from_string(char* str); diff --git a/libical/src/libical/icalvalue.c b/libical/src/libical/icalvalue.c index 7c988a4d16..a1ebb64e30 100644 --- a/libical/src/libical/icalvalue.c +++ b/libical/src/libical/icalvalue.c @@ -27,11 +27,9 @@ ======================================================================*/ #ifdef HAVE_CONFIG_H -#include "config.h" +#include <config.h> #endif - -#include "ical.h" #include "icalerror.h" #include "icalmemory.h" #include "icalparser.h" @@ -44,7 +42,6 @@ #include <errno.h> #include <time.h> /* for mktime */ #include <stdlib.h> /* for atoi and atof */ -#include <limits.h> /* for SHRT_MAX */ #if _MAC_OS_ #include "icalmemory_strdup.h" @@ -66,7 +63,7 @@ struct icalvalue_impl { union data { struct icalattachtype v_attach; /* void *v_binary; */ /* use v_attach */ - char *v_string; + const char *v_string; /*char *v_text;*/ /*char *v_caladdress;*/ /*char *v_uri;*/ @@ -94,6 +91,7 @@ struct icalvalue_impl { struct icalrecurrencetype *v_recur; union icaltriggertype v_trigger; icalproperty_method v_method; + icalproperty_status v_status; } data; }; @@ -195,7 +193,7 @@ icalvalue* icalvalue_new_clone(icalvalue* value){ return new; } -char* icalmemory_strdup_and_dequote(char* str) +char* icalmemory_strdup_and_dequote(const char* str) { char* p; char* out = (char*)malloc(sizeof(char) * strlen(str) +1); @@ -253,7 +251,7 @@ char* icalmemory_strdup_and_dequote(char* str) return out; } -icalvalue* icalvalue_new_from_string_with_error(icalvalue_kind kind,char* str,icalproperty** error) +icalvalue* icalvalue_new_from_string_with_error(icalvalue_kind kind,const char* str,icalproperty** error) { icalvalue *value = 0; @@ -381,6 +379,21 @@ icalvalue* icalvalue_new_from_string_with_error(icalvalue_kind kind,char* str,ic break; } + + + case ICAL_STATUS_VALUE: + { + icalproperty_status status = icalenum_string_to_status(str); + + if(status == ICAL_STATUS_NONE){ + value = 0; + } else { + value = icalvalue_new_status(status); + } + + break; + + } case ICAL_GEO_VALUE: { value = 0; @@ -453,7 +466,7 @@ icalvalue* icalvalue_new_from_string_with_error(icalvalue_kind kind,char* str,ic } -icalvalue* icalvalue_new_from_string(icalvalue_kind kind,char* str) +icalvalue* icalvalue_new_from_string(icalvalue_kind kind,const char* str) { return icalvalue_new_from_string_with_error(kind,str,(icalproperty*)0); } @@ -487,7 +500,7 @@ icalvalue_free (icalvalue* value) case ICAL_URI_VALUE: { if (v->data.v_string != 0) { - free(v->data.v_string); + free((void*)v->data.v_string); v->data.v_string = 0; } break; @@ -495,7 +508,7 @@ icalvalue_free (icalvalue* value) case ICAL_RECUR_VALUE: { if(v->data.v_recur != 0){ - free(v->data.v_recur); + free((void*)v->data.v_recur); v->data.v_recur = 0; } break; @@ -529,7 +542,7 @@ icalvalue_is_valid (icalvalue* value) char* icalvalue_binary_as_ical_string(icalvalue* value) { - char* data; + const char* data; char* str; icalerror_check_arg_rz( (value!=0),"value"); data = icalvalue_get_binary(value); @@ -578,7 +591,7 @@ char* icalvalue_utcoffset_as_ical_string(icalvalue* value) char* icalvalue_string_as_ical_string(icalvalue* value) { - char* data; + const char* data; char* str = 0; icalerror_check_arg_rz( (value!=0),"value"); data = ((struct icalvalue_impl*)value)->data.v_string; @@ -628,7 +641,7 @@ char* icalvalue_recur_as_ical_string(icalvalue* value) icalmemory_append_string(&str,&str_p,&buf_sz,"FREQ="); icalmemory_append_string(&str,&str_p,&buf_sz, - icalenum_recurrence_to_string(recur->freq)); + icalrecur_recurrence_to_string(recur->freq)); if(recur->until.year != 0){ @@ -665,14 +678,14 @@ char* icalvalue_recur_as_ical_string(icalvalue* value) if (j == 3) { /* BYDAY */ short pos = icalrecurrencetype_day_position(array[i]); short dow = icalrecurrencetype_day_day_of_week(array[i]); - char *daystr = icalenum_weekday_to_string(dow); - + const char *daystr = icalrecur_weekday_to_string(dow); + 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); @@ -694,7 +707,7 @@ char* icalvalue_text_as_ical_string(icalvalue* value) { char *str; char *str_p; char *rtrn; - char *p; + const char *p; size_t buf_sz; int line_length; @@ -1078,7 +1091,7 @@ char* icalvalue_trigger_as_ical_string(icalvalue* value) { return str; } -char* +const char* icalvalue_as_ical_string (icalvalue* value) { struct icalvalue_impl* v = (struct icalvalue_impl*)value; @@ -1143,6 +1156,10 @@ icalvalue_as_ical_string (icalvalue* value) case ICAL_METHOD_VALUE: return icalenum_method_to_string(v->data.v_method); + case ICAL_STATUS_VALUE: + return icalenum_status_to_string(v->data.v_status); + + case ICAL_NO_VALUE: default: { @@ -1267,6 +1284,17 @@ icalvalue_compare(icalvalue* a, icalvalue *b) } } + + 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: @@ -1392,7 +1420,7 @@ icalvalue_get_attach(icalvalue* value) icalvalue* -icalvalue_new_binary (char* v) +icalvalue_new_binary (const char* v) { struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_BINARY_VALUE); @@ -1404,7 +1432,7 @@ icalvalue_new_binary (char* v) } void -icalvalue_set_binary(icalvalue* value, char* v) +icalvalue_set_binary(icalvalue* value, const char* v) { struct icalvalue_impl* impl; @@ -1414,7 +1442,7 @@ icalvalue_set_binary(icalvalue* value, char* v) icalerror_check_value_type(value, ICAL_BINARY_VALUE); impl = (struct icalvalue_impl*)value; - if(impl->data.v_string!=0) {free(impl->data.v_string);} + if(impl->data.v_string!=0) {free((void*)impl->data.v_string);} impl->data.v_string = strdup(v); @@ -1424,7 +1452,7 @@ icalvalue_set_binary(icalvalue* value, char* v) } -char* +const char* icalvalue_get_binary(icalvalue* value) { icalerror_check_arg( (value!=0),"value"); @@ -1470,7 +1498,7 @@ icalvalue_get_boolean(icalvalue* value) icalvalue* -icalvalue_new_caladdress (char* v) +icalvalue_new_caladdress (const char* v) { struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_CALADDRESS_VALUE); @@ -1482,7 +1510,7 @@ icalvalue_new_caladdress (char* v) } void -icalvalue_set_caladdress(icalvalue* value, char* v) +icalvalue_set_caladdress(icalvalue* value, const char* v) { struct icalvalue_impl* impl; @@ -1492,7 +1520,7 @@ icalvalue_set_caladdress(icalvalue* value, char* v) icalerror_check_value_type(value, ICAL_CALADDRESS_VALUE); impl = (struct icalvalue_impl*)value; - if(impl->data.v_string!=0) {free(impl->data.v_string);} + if(impl->data.v_string!=0) {free((void*)impl->data.v_string);} impl->data.v_string = strdup(v); @@ -1502,7 +1530,7 @@ icalvalue_set_caladdress(icalvalue* value, char* v) } -char* +const char* icalvalue_get_caladdress(icalvalue* value) { icalerror_check_arg( (value!=0),"value"); @@ -1861,8 +1889,9 @@ icalvalue_get_period(icalvalue* value) return ((struct icalvalue_impl*)value)->data.v_period; } + icalvalue* -icalvalue_new_string (char* v) +icalvalue_new_string (const char* v) { struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_STRING_VALUE); @@ -1874,7 +1903,7 @@ icalvalue_new_string (char* v) } void -icalvalue_set_string(icalvalue* value, char* v) +icalvalue_set_string(icalvalue* value, const char* v) { struct icalvalue_impl* impl; @@ -1884,7 +1913,7 @@ icalvalue_set_string(icalvalue* value, char* v) icalerror_check_value_type(value, ICAL_STRING_VALUE); impl = (struct icalvalue_impl*)value; - if(impl->data.v_string!=0) {free(impl->data.v_string);} + if(impl->data.v_string!=0) {free((void*)impl->data.v_string);} impl->data.v_string = strdup(v); @@ -1894,7 +1923,7 @@ icalvalue_set_string(icalvalue* value, char* v) } -char* +const char* icalvalue_get_string(icalvalue* value) { icalerror_check_arg( (value!=0),"value"); @@ -1905,7 +1934,7 @@ icalvalue_get_string(icalvalue* value) icalvalue* -icalvalue_new_text (char* v) +icalvalue_new_text (const char* v) { struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_TEXT_VALUE); @@ -1917,7 +1946,7 @@ icalvalue_new_text (char* v) } void -icalvalue_set_text(icalvalue* value, char* v) +icalvalue_set_text(icalvalue* value, const char* v) { struct icalvalue_impl* impl; @@ -1927,7 +1956,7 @@ icalvalue_set_text(icalvalue* value, char* v) icalerror_check_value_type(value, ICAL_TEXT_VALUE); impl = (struct icalvalue_impl*)value; - if(impl->data.v_string!=0) {free(impl->data.v_string);} + if(impl->data.v_string!=0) {free((void*)impl->data.v_string);} impl->data.v_string = strdup(v); @@ -1937,7 +1966,7 @@ icalvalue_set_text(icalvalue* value, char* v) } -char* +const char* icalvalue_get_text(icalvalue* value) { icalerror_check_arg( (value!=0),"value"); @@ -2018,7 +2047,7 @@ icalvalue_get_trigger(icalvalue* value) icalvalue* -icalvalue_new_uri (char* v) +icalvalue_new_uri (const char* v) { struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_URI_VALUE); @@ -2030,7 +2059,7 @@ icalvalue_new_uri (char* v) } void -icalvalue_set_uri(icalvalue* value, char* v) +icalvalue_set_uri(icalvalue* value, const char* v) { struct icalvalue_impl* impl; @@ -2040,7 +2069,7 @@ icalvalue_set_uri(icalvalue* value, char* v) icalerror_check_value_type(value, ICAL_URI_VALUE); impl = (struct icalvalue_impl*)value; - if(impl->data.v_string!=0) {free(impl->data.v_string);} + if(impl->data.v_string!=0) {free((void*)impl->data.v_string);} impl->data.v_string = strdup(v); @@ -2050,7 +2079,7 @@ icalvalue_set_uri(icalvalue* value, char* v) } -char* +const char* icalvalue_get_uri(icalvalue* value) { icalerror_check_arg( (value!=0),"value"); @@ -2096,7 +2125,7 @@ icalvalue_get_utcoffset(icalvalue* value) icalvalue* -icalvalue_new_query (char* v) +icalvalue_new_query (const char* v) { struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_QUERY_VALUE); @@ -2108,7 +2137,7 @@ icalvalue_new_query (char* v) } void -icalvalue_set_query(icalvalue* value, char* v) +icalvalue_set_query(icalvalue* value, const char* v) { struct icalvalue_impl* impl; @@ -2118,7 +2147,7 @@ icalvalue_set_query(icalvalue* value, char* v) icalerror_check_value_type(value, ICAL_QUERY_VALUE); impl = (struct icalvalue_impl*)value; - if(impl->data.v_string!=0) {free(impl->data.v_string);} + if(impl->data.v_string!=0) {free((void*)impl->data.v_string);} impl->data.v_string = strdup(v); @@ -2128,7 +2157,7 @@ icalvalue_set_query(icalvalue* value, char* v) } -char* +const char* icalvalue_get_query(icalvalue* value) { icalerror_check_arg( (value!=0),"value"); @@ -2137,3 +2166,38 @@ icalvalue_get_query(icalvalue* value) return ((struct icalvalue_impl*)value)->data.v_string; } + +icalvalue* +icalvalue_new_status (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, 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_status = v; +} + +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_status; +} + diff --git a/libical/src/libical/icalvalue.h b/libical/src/libical/icalvalue.h index 18c15abaf4..828e0c7ff5 100644 --- a/libical/src/libical/icalvalue.h +++ b/libical/src/libical/icalvalue.h @@ -5,8 +5,6 @@ $Id$ - $Locker$ - (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org @@ -32,20 +30,21 @@ #include <time.h> #include "icalenums.h" #include "icaltypes.h" - +#include "icalrecur.h" + typedef void icalvalue; icalvalue* icalvalue_new(icalvalue_kind kind); icalvalue* icalvalue_new_clone(icalvalue* value); -icalvalue* icalvalue_new_from_string(icalvalue_kind kind, char* str); +icalvalue* icalvalue_new_from_string(icalvalue_kind kind, const char* str); void icalvalue_free(icalvalue* value); int icalvalue_is_valid(icalvalue* value); -char* icalvalue_as_ical_string(icalvalue* value); +const char* icalvalue_as_ical_string(icalvalue* value); icalvalue_kind icalvalue_isa(icalvalue* value); @@ -61,9 +60,9 @@ struct icalattachtype icalvalue_get_attach(icalvalue* value); void icalvalue_set_attach(icalvalue* value, struct icalattachtype v); /* BINARY */ -icalvalue* icalvalue_new_binary(char* v); -char* icalvalue_get_binary(icalvalue* value); -void icalvalue_set_binary(icalvalue* value, char* v); +icalvalue* icalvalue_new_binary(const char* v); +const char* icalvalue_get_binary(icalvalue* value); +void icalvalue_set_binary(icalvalue* value, const char* v); /* BOOLEAN */ icalvalue* icalvalue_new_boolean(int v); @@ -71,9 +70,9 @@ int icalvalue_get_boolean(icalvalue* value); void icalvalue_set_boolean(icalvalue* value, int v); /* CAL-ADDRESS */ -icalvalue* icalvalue_new_caladdress(char* v); -char* icalvalue_get_caladdress(icalvalue* value); -void icalvalue_set_caladdress(icalvalue* value, char* v); +icalvalue* icalvalue_new_caladdress(const char* v); +const char* icalvalue_get_caladdress(icalvalue* value); +void icalvalue_set_caladdress(icalvalue* value, const char* v); /* DATE */ icalvalue* icalvalue_new_date(struct icaltimetype v); @@ -131,14 +130,14 @@ struct icalrecurrencetype icalvalue_get_recur(icalvalue* value); void icalvalue_set_recur(icalvalue* value, struct icalrecurrencetype v); /* STRING # Non-std */ -icalvalue* icalvalue_new_string(char* v); -char* icalvalue_get_string(icalvalue* value); -void icalvalue_set_string(icalvalue* value, char* v); +icalvalue* icalvalue_new_string(const char* v); +const char* icalvalue_get_string(icalvalue* value); +void icalvalue_set_string(icalvalue* value, const char* v); /* TEXT */ -icalvalue* icalvalue_new_text(char* v); -char* icalvalue_get_text(icalvalue* value); -void icalvalue_set_text(icalvalue* value, char* v); +icalvalue* icalvalue_new_text(const char* v); +const char* icalvalue_get_text(icalvalue* value); +void icalvalue_set_text(icalvalue* value, const char* v); /* TIME */ icalvalue* icalvalue_new_time(struct icaltimetype v); @@ -151,9 +150,9 @@ union icaltriggertype icalvalue_get_trigger(icalvalue* value); void icalvalue_set_trigger(icalvalue* value, union icaltriggertype v); /* URI */ -icalvalue* icalvalue_new_uri(char* v); -char* icalvalue_get_uri(icalvalue* value); -void icalvalue_set_uri(icalvalue* value, char* v); +icalvalue* icalvalue_new_uri(const char* v); +const char* icalvalue_get_uri(icalvalue* value); +void icalvalue_set_uri(icalvalue* value, const char* v); /* UTC-OFFSET */ icalvalue* icalvalue_new_utcoffset(int v); @@ -161,8 +160,13 @@ int icalvalue_get_utcoffset(icalvalue* value); void icalvalue_set_utcoffset(icalvalue* value, int v); /* QUERY */ -icalvalue* icalvalue_new_query(char* v); -char* icalvalue_get_query(icalvalue* value); -void icalvalue_set_query(icalvalue* value, char* v); +icalvalue* icalvalue_new_query(const char* v); +const char* icalvalue_get_query(icalvalue* value); +void icalvalue_set_query(icalvalue* value, const char* v); + +/* STATUS #Non-st */ +icalvalue* icalvalue_new_status(icalproperty_status v); +icalproperty_status icalvalue_get_status(icalvalue* value); +void icalvalue_set_status(icalvalue* value, icalproperty_status v); -#endif ICALVALUE_H +#endif /*ICALVALUE_H*/ diff --git a/libical/src/libical/icalversion.h.in b/libical/src/libical/icalversion.h.in index aaeeed6666..5d213693e5 100644 --- a/libical/src/libical/icalversion.h.in +++ b/libical/src/libical/icalversion.h.in @@ -1,3 +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 index c93fcc3df1..8cfd94693f 100644 --- a/libical/src/libical/icalyacc.c +++ b/libical/src/libical/icalyacc.c @@ -4,6 +4,13 @@ #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 @@ -164,20 +171,19 @@ - ================================b======================================*/ + =======================================================================*/ #include <stdlib.h> #include <string.h> /* for strdup() */ -#include <limits.h> /* for SHRT_MAX*/ #include "icalparser.h" -#include "ical.h" #include "pvl.h" -#define YYERROR_VERBOSE -#define YYDEBUG 1 - 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; @@ -201,7 +207,7 @@ 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. */ +int yylex(void); /* Or this. */ @@ -209,58 +215,11 @@ void ical_yy_error(char *s); /* Don't know why I need this.... */ VALUEs, that is, ) correctly. */ -#line 76 "icalyacc.y" +#line 75 "icalyacc.y" typedef union { float v_float; int v_int; char* v_string; - - /* Renaming hack */ -#define yymaxdepth ical_yy_maxdepth -#define yyparse ical_yy_parse -#define yylex ical_yy_lex -#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 - - - } YYSTYPE; #ifndef YYDEBUG #define YYDEBUG 1 @@ -372,15 +331,15 @@ static const short yyrhs[] = { 143, #if YYDEBUG != 0 static const short yyrline[] = { 0, - 159, 161, 162, 163, 164, 165, 166, 167, 168, 174, - 176, 179, 182, 197, 199, 202, 204, 206, 222, 223, - 225, 230, 233, 236, 240, 244, 249, 253, 258, 263, - 268, 271, 274, 278, 283, 288, 297, 318, 350, 352, - 353, 354, 355, 356, 357, 361, 363, 364, 365, 366, - 367, 368, 373, 375, 377, 379, 380, 382, 387, 389, - 392, 394, 395, 396, 397, 398, 399, 400, 401, 402, - 403, 404, 405, 406, 407, 408, 409, 410, 413, 416, - 420, 422, 424, 432, 433, 435, 441 + 181, 183, 184, 185, 186, 187, 188, 189, 190, 196, + 198, 201, 204, 219, 221, 224, 226, 228, 244, 245, + 247, 252, 255, 258, 262, 266, 271, 275, 280, 285, + 290, 294, 298, 303, 308, 313, 322, 343, 375, 377, + 378, 379, 380, 381, 382, 386, 388, 389, 390, 391, + 392, 393, 398, 400, 402, 404, 405, 407, 411, 413, + 416, 418, 419, 420, 421, 422, 423, 424, 425, 426, + 427, 428, 429, 430, 431, 432, 433, 434, 437, 440, + 444, 446, 448, 456, 457, 459, 465 }; #endif @@ -1067,7 +1026,7 @@ yyreduce: switch (yyn) { case 9: -#line 168 "icalyacc.y" +#line 190 "icalyacc.y" { icalparser_yy_value = 0; icalparser_clear_flex_input(); @@ -1075,15 +1034,15 @@ case 9: ; break;} case 11: -#line 178 "icalyacc.y" +#line 200 "icalyacc.y" { icalparser_yy_value = icalvalue_new_boolean(1); ; break;} case 12: -#line 180 "icalyacc.y" +#line 202 "icalyacc.y" { icalparser_yy_value = icalvalue_new_boolean(0); ; break;} case 13: -#line 183 "icalyacc.y" +#line 205 "icalyacc.y" { struct icaltimetype stm; @@ -1099,23 +1058,23 @@ case 13: ; break;} case 14: -#line 198 "icalyacc.y" +#line 220 "icalyacc.y" {utc = 0;; break;} case 15: -#line 199 "icalyacc.y" +#line 221 "icalyacc.y" {utc = 1;; break;} case 16: -#line 203 "icalyacc.y" +#line 225 "icalyacc.y" {utc_b = 0;; break;} case 17: -#line 204 "icalyacc.y" +#line 226 "icalyacc.y" {utc_b = 1;; break;} case 18: -#line 208 "icalyacc.y" +#line 230 "icalyacc.y" { struct icaltimetype stm; stm = fill_datetime(yyvsp[-3].v_string, yyvsp[-1].v_string); @@ -1127,100 +1086,103 @@ case 18: ; break;} case 21: -#line 226 "icalyacc.y" +#line 248 "icalyacc.y" { duration.weeks = atoi(yyvsp[-1].v_string); ; break;} case 22: -#line 231 "icalyacc.y" +#line 253 "icalyacc.y" { ; break;} case 23: -#line 234 "icalyacc.y" +#line 256 "icalyacc.y" { ; break;} case 24: -#line 237 "icalyacc.y" +#line 259 "icalyacc.y" { ; break;} case 25: -#line 241 "icalyacc.y" +#line 263 "icalyacc.y" { duration.hours = atoi(yyvsp[-1].v_string); ; break;} case 26: -#line 245 "icalyacc.y" +#line 267 "icalyacc.y" { duration.hours = atoi(yyvsp[-2].v_string); ; break;} case 27: -#line 250 "icalyacc.y" +#line 272 "icalyacc.y" { duration.minutes = atoi(yyvsp[-1].v_string); ; break;} case 28: -#line 254 "icalyacc.y" +#line 276 "icalyacc.y" { duration.minutes = atoi(yyvsp[-2].v_string); ; break;} case 29: -#line 259 "icalyacc.y" +#line 281 "icalyacc.y" { duration.seconds = atoi(yyvsp[-1].v_string); ; break;} case 30: -#line 264 "icalyacc.y" +#line 286 "icalyacc.y" { duration.days = atoi(yyvsp[-1].v_string); ; break;} case 31: -#line 269 "icalyacc.y" +#line 291 "icalyacc.y" { + duration.is_neg = 0; ; break;} case 32: -#line 272 "icalyacc.y" +#line 295 "icalyacc.y" { + duration.is_neg = 0; ; break;} case 33: -#line 275 "icalyacc.y" -{ +#line 299 "icalyacc.y" +{ + duration.is_neg = 1; ; break;} case 34: -#line 279 "icalyacc.y" +#line 304 "icalyacc.y" { icalparser_yy_value = icalvalue_new_duration(duration); memset(&duration,0, sizeof(duration)); ; break;} case 35: -#line 284 "icalyacc.y" +#line 309 "icalyacc.y" { icalparser_yy_value = icalvalue_new_duration(duration); memset(&duration,0, sizeof(duration)); ; break;} case 36: -#line 289 "icalyacc.y" +#line 314 "icalyacc.y" { icalparser_yy_value = icalvalue_new_duration(duration); memset(&duration,0, sizeof(duration)); ; break;} case 37: -#line 298 "icalyacc.y" +#line 323 "icalyacc.y" { struct icalperiodtype p; @@ -1243,7 +1205,7 @@ case 37: ; break;} case 38: -#line 319 "icalyacc.y" +#line 344 "icalyacc.y" { struct icalperiodtype p; @@ -1272,199 +1234,199 @@ case 38: ; break;} case 39: -#line 351 "icalyacc.y" +#line 376 "icalyacc.y" {clear_recur();recur.freq = ICAL_SECONDLY_RECURRENCE;; break;} case 40: -#line 352 "icalyacc.y" +#line 377 "icalyacc.y" {clear_recur();recur.freq = ICAL_MINUTELY_RECURRENCE;; break;} case 41: -#line 353 "icalyacc.y" +#line 378 "icalyacc.y" {clear_recur();recur.freq = ICAL_HOURLY_RECURRENCE;; break;} case 42: -#line 354 "icalyacc.y" +#line 379 "icalyacc.y" {clear_recur();recur.freq = ICAL_DAILY_RECURRENCE;; break;} case 43: -#line 355 "icalyacc.y" +#line 380 "icalyacc.y" {clear_recur();recur.freq = ICAL_WEEKLY_RECURRENCE;; break;} case 44: -#line 356 "icalyacc.y" +#line 381 "icalyacc.y" {clear_recur();recur.freq = ICAL_MONTHLY_RECURRENCE;; break;} case 45: -#line 357 "icalyacc.y" +#line 382 "icalyacc.y" {clear_recur();recur.freq = ICAL_YEARLY_RECURRENCE;; break;} case 46: -#line 362 "icalyacc.y" +#line 387 "icalyacc.y" { skiplist[skippos]=ICAL_SUNDAY_WEEKDAY; ; break;} case 47: -#line 363 "icalyacc.y" +#line 388 "icalyacc.y" { skiplist[skippos]=ICAL_MONDAY_WEEKDAY; ; break;} case 48: -#line 364 "icalyacc.y" +#line 389 "icalyacc.y" { skiplist[skippos]=ICAL_TUESDAY_WEEKDAY; ; break;} case 49: -#line 365 "icalyacc.y" +#line 390 "icalyacc.y" { skiplist[skippos]=ICAL_WEDNESDAY_WEEKDAY; ; break;} case 50: -#line 366 "icalyacc.y" +#line 391 "icalyacc.y" { skiplist[skippos]=ICAL_THURSDAY_WEEKDAY; ; break;} case 51: -#line 367 "icalyacc.y" +#line 392 "icalyacc.y" { skiplist[skippos]=ICAL_FRIDAY_WEEKDAY; ; break;} case 52: -#line 368 "icalyacc.y" +#line 393 "icalyacc.y" { skiplist[skippos]=ICAL_SATURDAY_WEEKDAY; ; break;} case 53: -#line 374 "icalyacc.y" +#line 399 "icalyacc.y" {if( skippos<8) skippos++;; break;} case 54: -#line 375 "icalyacc.y" +#line 400 "icalyacc.y" { dow_pos = atoi(yyvsp[-1].v_string); skiplist[skippos] += 8*dow_pos; if( skippos<8) skippos++; ; break;} case 55: -#line 377 "icalyacc.y" +#line 402 "icalyacc.y" { dow_pos = atoi(yyvsp[-1].v_string); skiplist[skippos] -= 8*dow_pos; if( skippos<8) skippos++; ; break;} case 56: -#line 379 "icalyacc.y" +#line 404 "icalyacc.y" {if( skippos<8) skippos++;; break;} case 57: -#line 380 "icalyacc.y" +#line 405 "icalyacc.y" { dow_pos = atoi(yyvsp[-1].v_string); skiplist[skippos] += 8*dow_pos;if( skippos<8) skippos++;; break;} case 58: -#line 382 "icalyacc.y" +#line 407 "icalyacc.y" { dow_pos = atoi(yyvsp[-1].v_string); skiplist[skippos] -= 8*dow_pos;if( skippos<8) skippos++;; break;} case 59: -#line 388 "icalyacc.y" +#line 412 "icalyacc.y" { skiplist[skippos] = atoi(yyvsp[0].v_string); skippos++;; break;} case 60: -#line 389 "icalyacc.y" +#line 413 "icalyacc.y" { skiplist[skippos] = atoi(yyvsp[0].v_string); if (skippos<367) skippos++;; break;} case 61: -#line 393 "icalyacc.y" +#line 417 "icalyacc.y" {recur.interval = atoi(yyvsp[0].v_string);; break;} case 62: -#line 394 "icalyacc.y" +#line 418 "icalyacc.y" {recur.week_start = ICAL_SUNDAY_WEEKDAY;; break;} case 63: -#line 395 "icalyacc.y" +#line 419 "icalyacc.y" {recur.week_start = ICAL_MONDAY_WEEKDAY;; break;} case 64: -#line 396 "icalyacc.y" +#line 420 "icalyacc.y" {recur.week_start = ICAL_TUESDAY_WEEKDAY;; break;} case 65: -#line 397 "icalyacc.y" +#line 421 "icalyacc.y" {recur.week_start = ICAL_WEDNESDAY_WEEKDAY;; break;} case 66: -#line 398 "icalyacc.y" +#line 422 "icalyacc.y" {recur.week_start = ICAL_THURSDAY_WEEKDAY;; break;} case 67: -#line 399 "icalyacc.y" +#line 423 "icalyacc.y" {recur.week_start = ICAL_FRIDAY_WEEKDAY;; break;} case 68: -#line 400 "icalyacc.y" +#line 424 "icalyacc.y" {recur.week_start = ICAL_SATURDAY_WEEKDAY;; break;} case 69: -#line 401 "icalyacc.y" +#line 425 "icalyacc.y" {copy_list(recur.by_second,60);; break;} case 70: -#line 402 "icalyacc.y" +#line 426 "icalyacc.y" {copy_list(recur.by_minute,60);; break;} case 71: -#line 403 "icalyacc.y" +#line 427 "icalyacc.y" {copy_list(recur.by_hour,24);; break;} case 72: -#line 404 "icalyacc.y" +#line 428 "icalyacc.y" {copy_list(recur.by_day,7);; break;} case 73: -#line 405 "icalyacc.y" +#line 429 "icalyacc.y" {copy_list(recur.by_month,12);; break;} case 74: -#line 406 "icalyacc.y" +#line 430 "icalyacc.y" {copy_list(recur.by_month_day,31);; break;} case 75: -#line 407 "icalyacc.y" +#line 431 "icalyacc.y" {copy_list(recur.by_year_day,366);; break;} case 76: -#line 408 "icalyacc.y" +#line 432 "icalyacc.y" {copy_list(recur.by_week_no,53);; break;} case 77: -#line 409 "icalyacc.y" +#line 433 "icalyacc.y" {copy_list(recur.by_set_pos,366);; break;} case 78: -#line 411 "icalyacc.y" +#line 435 "icalyacc.y" { recur.until = icalvalue_get_datetime(icalparser_yy_value); icalvalue_free(icalparser_yy_value); icalparser_yy_value=0;; break;} case 79: -#line 414 "icalyacc.y" +#line 438 "icalyacc.y" { recur.until = icalvalue_get_date(icalparser_yy_value); icalvalue_free(icalparser_yy_value); icalparser_yy_value=0;; break;} case 80: -#line 417 "icalyacc.y" +#line 441 "icalyacc.y" { recur.count = atoi(yyvsp[0].v_string); ; break;} case 83: -#line 426 "icalyacc.y" +#line 450 "icalyacc.y" { icalparser_yy_value = icalvalue_new_recur(recur); ; break;} case 84: -#line 432 "icalyacc.y" +#line 456 "icalyacc.y" { utcsign = 1; ; break;} case 85: -#line 433 "icalyacc.y" +#line 457 "icalyacc.y" { utcsign = -1; ; break;} case 86: -#line 437 "icalyacc.y" +#line 461 "icalyacc.y" { icalparser_yy_value = icalvalue_new_utcoffset( utcsign * (yyvsp[-1].v_int*3600) + (yyvsp[0].v_int*60) ); ; break;} case 87: -#line 442 "icalyacc.y" +#line 466 "icalyacc.y" { icalparser_yy_value = icalvalue_new_utcoffset(utcsign * (yyvsp[-2].v_int*3600) + (yyvsp[-1].v_int*60) +(yyvsp[0].v_int)); ; @@ -1691,7 +1653,7 @@ yyerrhandle: } return 1; } -#line 448 "icalyacc.y" +#line 472 "icalyacc.y" @@ -1701,7 +1663,6 @@ void clear_recur() skippos = 0; icalrecurrencetype_clear(&recur); - recur.week_start = ICAL_MONDAY_WEEKDAY; } void copy_list(short* array, size_t size) @@ -1731,7 +1692,7 @@ struct icaltimetype fill_datetime(char* datestr, char* timestr) } -void yyerror(char* s) +void ical_yyerror(char* s) { /*fprintf(stderr,"Parse error \'%s\'\n", s);*/ } diff --git a/libical/src/libical/icalyacc.y b/libical/src/libical/icalyacc.y index ac1705bc52..d4d7c94b51 100644 --- a/libical/src/libical/icalyacc.y +++ b/libical/src/libical/icalyacc.y @@ -6,7 +6,7 @@ DESCRIPTION: - $Id: icalyacc.y,v 1.8 2000/11/22 05:11:26 federico Exp $ + $Id: icalyacc.y,v 1.9 2000/12/11 23:01:22 federico Exp $ $Locker: $ (C) COPYRIGHT 1999 Eric Busboom @@ -27,20 +27,19 @@ - ================================b======================================*/ + =======================================================================*/ #include <stdlib.h> #include <string.h> /* for strdup() */ -#include <limits.h> /* for SHRT_MAX*/ #include "icalparser.h" -#include "ical.h" #include "pvl.h" -#define YYERROR_VERBOSE -#define YYDEBUG 1 - 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; @@ -64,7 +63,7 @@ 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. */ +int yylex(void); /* Or this. */ @@ -77,11 +76,14 @@ void ical_yy_error(char *s); /* Don't know why I need this.... */ float v_float; int v_int; char* v_string; +} + /* Renaming hack */ + +/* #define yymaxdepth ical_yy_maxdepth #define yyparse ical_yy_parse -#define yylex ical_yy_lex #define yyerror ical_yy_error #define yylval ical_yy_lval #define yychar ical_yy_char @@ -121,11 +123,31 @@ void ical_yy_error(char *s); /* Don't know why I need this.... */ #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 @@ -267,12 +289,15 @@ dur_day: DIGITS 'D' dur_prefix: /* empty */ { + duration.is_neg = 0; } | '+' { + duration.is_neg = 0; } | '-' - { + { + duration.is_neg = 1; } duration_value: dur_prefix 'P' dur_date @@ -366,7 +391,7 @@ weekday: | TH { skiplist[skippos]=ICAL_THURSDAY_WEEKDAY; } | FR { skiplist[skippos]=ICAL_FRIDAY_WEEKDAY; } | SA { skiplist[skippos]=ICAL_SATURDAY_WEEKDAY; } - ; + ; /* HACK. The skippos has only 8 positions, but the spec permits any number */ @@ -381,7 +406,6 @@ weekday_list: skiplist[skippos] += 8*dow_pos;if( skippos<8) skippos++;} | weekday_list COMMA MINUS DIGITS weekday { dow_pos = atoi($4); skiplist[skippos] -= 8*dow_pos;if( skippos<8) skippos++;} - ; recur_list: @@ -454,7 +478,6 @@ void clear_recur() skippos = 0; icalrecurrencetype_clear(&recur); - recur.week_start = ICAL_MONDAY_WEEKDAY; } void copy_list(short* array, size_t size) @@ -484,7 +507,7 @@ struct icaltimetype fill_datetime(char* datestr, char* timestr) } -void yyerror(char* s) +void ical_yyerror(char* s) { /*fprintf(stderr,"Parse error \'%s\'\n", s);*/ } diff --git a/libical/src/libical/pvl.c b/libical/src/libical/pvl.c index 94eaeac874..2a733e8aa9 100644 --- a/libical/src/libical/pvl.c +++ b/libical/src/libical/pvl.c @@ -309,14 +309,14 @@ pvl_insert_ordered(pvl_list l,pvl_comparef f,void *d) /* smaller than head, add to head */ - if ( ((*f)(d,L->head->d)) < 0) + 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) + if ( (*f)(d,L->tail->d) >= 0) { pvl_push(l,d); return; @@ -324,10 +324,10 @@ pvl_insert_ordered(pvl_list l,pvl_comparef f,void *d) /* 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) + if ( (*f)(P->d,d) >= 0) { pvl_insert_before(l,P,d); return; diff --git a/libical/src/libical/pvl.h b/libical/src/libical/pvl.h index 40ca516e9f..14a15a15eb 100644 --- a/libical/src/libical/pvl.h +++ b/libical/src/libical/pvl.h @@ -39,7 +39,7 @@ 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(); +pvl_list pvl_newlist(void); void pvl_free(pvl_list); /* Add, remove, or get the head of the list */ diff --git a/libical/src/libicalss/Makefile.am b/libical/src/libicalss/Makefile.am index e4431cb492..0cbecbedea 100644 --- a/libical/src/libicalss/Makefile.am +++ b/libical/src/libicalss/Makefile.am @@ -1,36 +1,59 @@ +lib_LTLIBRARIES = libicalss.la +YFLAGS =-d -v -p ss +LFLAGS = -Pss +LEX_OUTPUT_ROOT = lex.ss -#noinst_LTLIBRARIES = libicalss.la -lib_LIBRARIES = libicalss.a - -libicalss_a_SOURCES =\ - icalcalendar.c \ - icalcalendar.h \ - icalset.h \ - icalset.c \ - icalfileset.c \ - icalfileset.h \ - icalfilesetimpl.h \ - icaldirset.c \ - icaldirset.h \ - icalcsdb.h \ - icalcstp.h \ - icalgauge.h \ - icalgauge.c - -include_HEADERS =\ - icalcalendar.h \ - icalset.h - icalfileset.h \ - icalfilesetimpl.h \ - icaldirset.h \ - icalcsdb.h \ - icalcstp.h \ - icalgauge.h - -INCLUDES = \ - -I ../libical/ \ - -I $(srcdir)/../libical/ \ - -I .. \ - -I$(srcdir)/.. +all: icalss.h +INCLUDES = \ + -I$(top_builddir) \ + -I$(top_srcdir)/src \ + -I$(top_builddir)/src \ + -I$(top_srcdir)/src/libical \ + -I$(srcdir)/libical + +libicalss_la_LDFLAGS = -version-info 0:0:0 + +libicalss_la_SOURCES = \ + icalclassify.c \ + icaldirset.c \ + icaldirsetimpl.h \ + icalfileset.c \ + icalfilesetimpl.h \ + icalgauge.c \ + icalgaugeimpl.h \ + icalset.c \ + icalsslexer.l \ + icalssutil.c \ + icalssyacc.h \ + icalssyacc.y \ + icalspanlist.c \ + icalmessage.c \ + icalcstp.c + +libicalssincludedir = $(includedir) + +COMBINEDHEADERS = \ + icalset.h \ + icalfileset.h \ + icaldirset.h \ + icalcalendar.h \ + icalgauge.h \ + icalssutil.h \ + icalclassify.h \ + icalspanlist.h \ + icalmessage.h \ + icalcstp.h + +icalss.h: $(COMBINEDHEADERS) + cat $(COMBINEDHEADERS) | egrep -v "#include.*\"ical" \ + | egrep -v "#include.*\"pvl\.h\"" > icalss.h + + +libicalssinclude_HEADERS = icalss.h + +CONFIG_CLEAN_FILES = y.output + +EXTRA_DIST = \ + $(COMBINEDHEADERS) \ diff --git a/libical/src/libicalss/icalcstp.h b/libical/src/libicalss/icalcstp.h index fea6c89616..63f5af913f 100644 --- a/libical/src/libicalss/icalcstp.h +++ b/libical/src/libicalss/icalcstp.h @@ -29,43 +29,15 @@ #include "ical.h" -typedef void* icalcstp; - -typedef struct icalcstp_stubs; - -icalcstp* icalcstp_new(icalcstp_stubs* stubs, - int incoming, int outgoing); - -void* icalcstp_free(icalcstp* cstp); - -/* Send or recieve data directly to/from the network. These calls are - needed for the AUTHENTICATE command and possibly others */ -ssize_t icalcstp_send(icalcstp* cstp, char* msg); -ssize_t icalcstp_recieve(icalcstp* cstp, char* msg); - -int icalcstp_set_timeout(icalcstp* cstp, int sec); - -typedef struct icalcstp_response { - icalrequeststatus code - char *arg; /* These strings are owned by libical */ - char *debug_text; - char *more_text; - void* result; -} icalcstp_response; - /********************** Server (Reciever) Interfaces *************************/ /* On the server side, the caller will recieve data from the incoming - socket and pass it to icalcstp_process_incoming. The caller then - takes the return from _process_incoming 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. - - However, some commands will use the sockets directly, though the - _send and _recieve routines. Example is Authenticate and Starttls, - which need several exchanges of data + 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 abd client command routines will generate response codes. On the server side, these responses will be turned @@ -73,63 +45,117 @@ typedef struct icalcstp_response { is the one sent from the server. Since each command can return multiple responses, the responses are - stored in the icalcstp object and are accesses by - icalcstp_first_response() and icalcstp_next_response() + 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) Call icalcstps_next_output. Send string to client. */ - -/* Process a single line of incomming data */ -char* icalcstp_process_incoming(icalcstp* cstp, char* string); + +typedef void icalcstps; /* Er, they aren't really stubs, but pointers to the rountines that - icalcstp_process_incoming will call when it recognizes a CSTP + 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 icalcstp_server_stubs { - icalerrorenum (*abort)(icalcstp* cstp); - icalerrorenum (*authenticate)(icalcstp* cstp, char* mechanism, +struct icalcstps_stubs { + icalerrorenum (*abort)(icalcstps* cstp); + icalerrorenum (*authenticate)(icalcstps* cstp, char* mechanism, char* data); - icalerrorenum (*calidexpand)(icalcstp* cstp, char* calid); - icalerrorenum (*capability)(icalcstp* cstp); - icalerrorenum (*cont)(icalcstp* cstp, unsigned int time); - icalerrorenum (*identify)(icalcstp* cstp, char* id); - icalerrorenum (*disconnect)(icalcstp* cstp); - icalerrorenum (*sendata)(icalcstp* cstp, unsigned int time, + 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)(icalcstp* cstp, char* command, + icalerrorenum (*starttls)(icalcstps* cstp, char* command, char* data); - icalerrorenum (*upnexpand)(icalcstp* cstp, char* upn); - icalerrorenum (*unknown)(icalcstp* cstp, char* command, char* data); -} + icalerrorenum (*upnexpand)(icalcstps* cstp, char* upn); + icalerrorenum (*unknown)(icalcstps* cstp, char* command, char* data); +}; + + +icalcstps* icalcstps_new(struct icalcstps_stubs 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); + /********************** Client (Sender) Interfaces **************************/ -/* On the client side, the cstp code is connected directly to the - socket, because the callers point of control is at the interfaces - below. */ - -icalerrorenum icalcstp_abort(icalcstp* cstp); -icalerrorenum icalcstp_authenticate(icalcstp* cstp, char* mechanism, - char* data); -icalerrorenum icalcstp_capability(icalcstp* cstp); -icalerrorenum icalcstp_calidexpand(icalcstp* cstp,char* calid); -icalerrorenum icalcstp_continue(icalcstp* cstp, unsigned int time); -icalerrorenum icalcstp_disconnect(icalcstp* cstp); -icalerrorenum icalcstp_identify(icalcstp* cstp, char* id); -icalerrorenum icalcstp_starttls(icalcstp* cstp, char* command, - char* data); -icalerrorenum icalcstp_senddata(icalcstp* cstp, unsigned int time, - icalcomponent *comp); -icalerrorenum icalcstp_upnexpand(icalcstp* cstp,char* calid); -icalerrorenum icalcstp_sendata(icalcstp* cstp, unsigned int time, - icalcomponent *comp); +/* How to use: + + 1) Construct a new icalcstpc + 2) Issue a command + 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 +*/ -icalcstp_response icalcstp_first_response(icalcstp* cstp); -icalcstp_response icalcstp_next_response(icalcstp* cstp); +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; + +icalcstps* 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); + +/* process the next string from the server */ +int icalcstpc_next_input(icalcstpc* cstp); + +/* 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 /* !ICALCSTP_H */ diff --git a/libical/src/libicalvcal/Makefile.am b/libical/src/libicalvcal/Makefile.am index 862d77bcea..a4e9bba887 100644 --- a/libical/src/libicalvcal/Makefile.am +++ b/libical/src/libicalvcal/Makefile.am @@ -1,17 +1,29 @@ +lib_LTLIBRARIES = libicalvcal.la -lib_LIBRARIES = libicalvcal.a +INCLUDES = \ + -I$(top_builddir) \ + -I$(top_srcdir)/src/libical \ + -I$(top_srcdir)/src/libicalss \ + -I$(srcdir) -libicalvcal_a_SOURCES = \ - vcc.y \ - vcc.h \ - vobject.c \ - vobject.h \ - port.h \ - vcaltmp.c \ - vcaltmp.h \ - icalvcal.c \ - icalvcal.h +libicalvcal_la_LDFLAGS = -version-info 0:0:0 -EXTRA_DIST = README.TXT vcaltest.c vctest.c +libicalvcal_la_SOURCES = \ + icalvcal.c \ + vcc.y \ + vobject.c \ + vcaltmp.c -INCLUDES = -I ../libical -I $(srcdir)/../libical
\ No newline at end of file +libicalvcalincludedir = $(includedir)/libicalvcal + +libicalvcalinclude_HEADERS = \ + icalvcal.h \ + port.h \ + vcc.h \ + vobject.h \ + vcaltmp.h + +EXTRA_DIST = \ + README.TXT \ + vcaltest.c \ + vctest.c diff --git a/libical/src/libicalvcal/vcc.c b/libical/src/libicalvcal/vcc.c index cb57b6ed58..5c34395b83 100644 --- a/libical/src/libicalvcal/vcc.c +++ b/libical/src/libicalvcal/vcc.c @@ -187,7 +187,6 @@ enum LexMode { /**** Private Forward Declarations ****/ static int pushVObject(const char *prop); static VObject* popVObject(); -static char* lexDataFromBase64(); static void lexPopMode(int top); static int lexWithinMode(enum LexMode mode); static void lexPushMode(enum LexMode mode); @@ -197,7 +196,7 @@ static void enterValues(const char *value); static void mime_error_(char *s); -#line 179 "vcc.y" +#line 178 "vcc.y" typedef union { char *str; VObject *vobj; @@ -277,11 +276,11 @@ static const short yyrhs[] = { 22, #if YYDEBUG != 0 static const short yyrline[] = { 0, - 207, 210, 213, 213, 217, 218, 221, 227, 232, 238, - 244, 245, 248, 252, 258, 261, 266, 266, 272, 273, - 276, 279, 283, 290, 293, 294, 294, 298, 299, 302, - 306, 308, 311, 314, 315, 318, 320, 321, 324, 331, - 336, 342, 348, 355, 360, 366 + 206, 209, 212, 212, 216, 217, 220, 226, 231, 237, + 243, 244, 247, 251, 257, 260, 265, 265, 271, 272, + 275, 278, 282, 289, 292, 293, 293, 297, 298, 301, + 305, 307, 310, 313, 314, 317, 319, 320, 323, 330, + 335, 341, 347, 354, 359, 365 }; #endif @@ -368,7 +367,7 @@ static const short yycheck[] = { 7, 41, 11, 57, 23 }; /* -*-C-*- Note some compilers choke on comments on `#line' lines. */ -#line 3 "/usr/pkg/share/bison.simple" +#line 3 "/usr/lib/bison.simple" /* This file comes from bison-1.28. */ /* Skeleton output parser for bison, @@ -582,7 +581,7 @@ __yy_memcpy (char *to, char *from, unsigned int count) #endif #endif -#line 217 "/usr/pkg/share/bison.simple" +#line 217 "/usr/lib/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 *. @@ -911,49 +910,49 @@ yyreduce: switch (yyn) { case 2: -#line 211 "vcc.y" +#line 210 "vcc.y" { addList(&vObjList, yyvsp[0].vobj); curObj = 0; ; break;} case 4: -#line 214 "vcc.y" +#line 213 "vcc.y" { addList(&vObjList, yyvsp[0].vobj); curObj = 0; ; break;} case 7: -#line 223 "vcc.y" +#line 222 "vcc.y" { lexPushMode(L_VCARD); if (!pushVObject(VCCardProp)) YYERROR; ; break;} case 8: -#line 228 "vcc.y" +#line 227 "vcc.y" { lexPopMode(0); yyval.vobj = popVObject(); ; break;} case 9: -#line 233 "vcc.y" +#line 232 "vcc.y" { lexPushMode(L_VCARD); if (!pushVObject(VCCardProp)) YYERROR; ; break;} case 10: -#line 238 "vcc.y" +#line 237 "vcc.y" { lexPopMode(0); yyval.vobj = popVObject(); ; break;} case 13: -#line 249 "vcc.y" +#line 248 "vcc.y" { lexPushMode(L_VALUES); ; break;} case 14: -#line 253 "vcc.y" +#line 252 "vcc.y" { if (lexWithinMode(L_BASE64) || lexWithinMode(L_QUOTED_PRINTABLE)) lexPopMode(0); @@ -961,109 +960,109 @@ case 14: ; break;} case 16: -#line 262 "vcc.y" +#line 261 "vcc.y" { enterProps(yyvsp[0].str); ; break;} case 18: -#line 267 "vcc.y" +#line 266 "vcc.y" { enterProps(yyvsp[0].str); ; break;} case 22: -#line 280 "vcc.y" +#line 279 "vcc.y" { enterAttr(yyvsp[0].str,0); ; break;} case 23: -#line 284 "vcc.y" +#line 283 "vcc.y" { enterAttr(yyvsp[-2].str,yyvsp[0].str); ; break;} case 25: -#line 293 "vcc.y" +#line 292 "vcc.y" { enterValues(yyvsp[-1].str); ; break;} case 27: -#line 295 "vcc.y" +#line 294 "vcc.y" { enterValues(yyvsp[0].str); ; break;} case 29: -#line 299 "vcc.y" +#line 298 "vcc.y" { yyval.str = 0; ; break;} case 30: -#line 304 "vcc.y" +#line 303 "vcc.y" { if (!pushVObject(VCCalProp)) YYERROR; ; break;} case 31: -#line 307 "vcc.y" +#line 306 "vcc.y" { yyval.vobj = popVObject(); ; break;} case 32: -#line 309 "vcc.y" +#line 308 "vcc.y" { if (!pushVObject(VCCalProp)) YYERROR; ; break;} case 33: -#line 311 "vcc.y" +#line 310 "vcc.y" { yyval.vobj = popVObject(); ; break;} case 39: -#line 326 "vcc.y" +#line 325 "vcc.y" { lexPushMode(L_VEVENT); if (!pushVObject(VCEventProp)) YYERROR; ; break;} case 40: -#line 332 "vcc.y" +#line 331 "vcc.y" { lexPopMode(0); popVObject(); ; break;} case 41: -#line 337 "vcc.y" +#line 336 "vcc.y" { lexPushMode(L_VEVENT); if (!pushVObject(VCEventProp)) YYERROR; ; break;} case 42: -#line 342 "vcc.y" +#line 341 "vcc.y" { lexPopMode(0); popVObject(); ; break;} case 43: -#line 350 "vcc.y" +#line 349 "vcc.y" { lexPushMode(L_VTODO); if (!pushVObject(VCTodoProp)) YYERROR; ; break;} case 44: -#line 356 "vcc.y" +#line 355 "vcc.y" { lexPopMode(0); popVObject(); ; break;} case 45: -#line 361 "vcc.y" +#line 360 "vcc.y" { lexPushMode(L_VTODO); if (!pushVObject(VCTodoProp)) YYERROR; ; break;} case 46: -#line 366 "vcc.y" +#line 365 "vcc.y" { lexPopMode(0); popVObject(); @@ -1071,7 +1070,7 @@ case 46: break;} } /* the action file gets copied in in place of this dollarsign */ -#line 543 "/usr/pkg/share/bison.simple" +#line 543 "/usr/lib/bison.simple" yyvsp -= yylen; yyssp -= yylen; @@ -1291,9 +1290,8 @@ yyerrhandle: } return 1; } -#line 372 "vcc.y" +#line 371 "vcc.y" -/*/////////////////////////////////////////////////////////////////////////*/ static int pushVObject(const char *prop) { VObject *newObj; @@ -1313,7 +1311,6 @@ static int pushVObject(const char *prop) } -/*/////////////////////////////////////////////////////////////////////////*/ /* This pops the recently built vCard off the stack and returns it. */ static VObject* popVObject() { @@ -1554,22 +1551,6 @@ static char* lexGetWord() { return lexStr(); } -static void lexPushLookahead(char *s, int len) { - int putptr; - if (len == 0) len = strlen(s); - putptr = (int)lexBuf.getPtr - len; - /* this function assumes that length of word to push back - / is not greater than MAX_LEX_LOOKAHEAD. - */ - if (putptr < 0) putptr += MAX_LEX_LOOKAHEAD; - lexBuf.getPtr = putptr; - while (*s) { - lexBuf.buf[putptr] = *s++; - putptr = (putptr + 1) % MAX_LEX_LOOKAHEAD; - } - lexBuf.len += len; - } - static void lexPushLookaheadc(int c) { int putptr; /* can't putback EOF, because it never leaves lookahead buffer */ @@ -1648,7 +1629,6 @@ static void handleMoreRFC822LineBreak(int c) { } static char* lexGet1Value() { - int size = 0; int c; lexSkipWhite(); c = lexLookahead(); @@ -1679,18 +1659,6 @@ static char* lexGet1Value() { } #endif -static char* lexGetStrUntil(char *termset) { - int size = 0; - int c = lexLookahead(); - lexClearToken(); - while (c != EOF && !strchr(termset,c)) { - lexAppendc(c); - lexSkipLookahead(); - c = lexLookahead(); - } - lexAppendc(0); - return c==EOF?0:lexStr(); - } static int match_begin_name(int end) { char *n = lexLookaheadWord(); @@ -1736,7 +1704,6 @@ static void finiLex() { } -/*/////////////////////////////////////////////////////////////////////////*/ /* This parses and converts the base64 format for binary encoding into * a decoded buffer (allocated with new). See RFC 1521. */ @@ -1865,7 +1832,6 @@ static int match_begin_end_name(int end) { static char* lexGetQuotedPrintable() { char cur; - unsigned long len = 0; lexClearToken(); do { @@ -1921,7 +1887,6 @@ EndString: } /* LexQuotedPrintable */ int yylex() { - int token = 0; int lexmode = LEXMODE(); if (lexmode == L_VALUES) { @@ -2054,7 +2019,6 @@ static VObject* Parse_MIMEHelper() return vObjList; } -/*/////////////////////////////////////////////////////////////////////////*/ DLLEXPORT(VObject*) Parse_MIME(const char *input, unsigned long len) { initLex(input, len, 0); @@ -2109,12 +2073,6 @@ DLLEXPORT(VObject*) Parse_MIME_FromFileName(char *fname) #endif -/*/////////////////////////////////////////////////////////////////////////*/ -static void YYDebug(const char *s) -{ -/* Parse_Debug(s); */ -} - static MimeErrorHandler mimeErrorHandler; diff --git a/libical/src/libicalvcal/vcc.y b/libical/src/libicalvcal/vcc.y index 1c800990c4..70feefab57 100644 --- a/libical/src/libicalvcal/vcc.y +++ b/libical/src/libicalvcal/vcc.y @@ -161,7 +161,6 @@ enum LexMode { /**** Private Forward Declarations ****/ static int pushVObject(const char *prop); static VObject* popVObject(); -static char* lexDataFromBase64(); static void lexPopMode(int top); static int lexWithinMode(enum LexMode mode); static void lexPushMode(enum LexMode mode); @@ -370,7 +369,6 @@ todoitem: ; %% -/*/////////////////////////////////////////////////////////////////////////*/ static int pushVObject(const char *prop) { VObject *newObj; @@ -390,7 +388,6 @@ static int pushVObject(const char *prop) } -/*/////////////////////////////////////////////////////////////////////////*/ /* This pops the recently built vCard off the stack and returns it. */ static VObject* popVObject() { @@ -631,22 +628,6 @@ static char* lexGetWord() { return lexStr(); } -static void lexPushLookahead(char *s, int len) { - int putptr; - if (len == 0) len = strlen(s); - putptr = (int)lexBuf.getPtr - len; - /* this function assumes that length of word to push back - / is not greater than MAX_LEX_LOOKAHEAD. - */ - if (putptr < 0) putptr += MAX_LEX_LOOKAHEAD; - lexBuf.getPtr = putptr; - while (*s) { - lexBuf.buf[putptr] = *s++; - putptr = (putptr + 1) % MAX_LEX_LOOKAHEAD; - } - lexBuf.len += len; - } - static void lexPushLookaheadc(int c) { int putptr; /* can't putback EOF, because it never leaves lookahead buffer */ @@ -725,7 +706,6 @@ static void handleMoreRFC822LineBreak(int c) { } static char* lexGet1Value() { - int size = 0; int c; lexSkipWhite(); c = lexLookahead(); @@ -756,18 +736,6 @@ static char* lexGet1Value() { } #endif -static char* lexGetStrUntil(char *termset) { - int size = 0; - int c = lexLookahead(); - lexClearToken(); - while (c != EOF && !strchr(termset,c)) { - lexAppendc(c); - lexSkipLookahead(); - c = lexLookahead(); - } - lexAppendc(0); - return c==EOF?0:lexStr(); - } static int match_begin_name(int end) { char *n = lexLookaheadWord(); @@ -813,7 +781,6 @@ static void finiLex() { } -/*/////////////////////////////////////////////////////////////////////////*/ /* This parses and converts the base64 format for binary encoding into * a decoded buffer (allocated with new). See RFC 1521. */ @@ -942,7 +909,6 @@ static int match_begin_end_name(int end) { static char* lexGetQuotedPrintable() { char cur; - unsigned long len = 0; lexClearToken(); do { @@ -998,7 +964,6 @@ EndString: } /* LexQuotedPrintable */ int yylex() { - int token = 0; int lexmode = LEXMODE(); if (lexmode == L_VALUES) { @@ -1131,7 +1096,6 @@ static VObject* Parse_MIMEHelper() return vObjList; } -/*/////////////////////////////////////////////////////////////////////////*/ DLLEXPORT(VObject*) Parse_MIME(const char *input, unsigned long len) { initLex(input, len, 0); @@ -1186,12 +1150,6 @@ DLLEXPORT(VObject*) Parse_MIME_FromFileName(char *fname) #endif -/*/////////////////////////////////////////////////////////////////////////*/ -static void YYDebug(const char *s) -{ -/* Parse_Debug(s); */ -} - static MimeErrorHandler mimeErrorHandler; diff --git a/libical/src/test/Makefile.am b/libical/src/test/Makefile.am index 7fc594ee84..a2ebea7610 100644 --- a/libical/src/test/Makefile.am +++ b/libical/src/test/Makefile.am @@ -1,18 +1,18 @@ -noinst_PROGRAMS = copycluster regression parser findobj storage stow recur testmime testvcal +noinst_PROGRAMS = copycluster regression parser storage stow recur testmime testvcal process testclassify + +LDADD = ../libicalss/libicalss.la ../libicalvcal/libicalvcal.la ../libical/libical.la -LDADD = ../libical/libical.a ../libicalss/libicalss.a ../libicalvcal/libicalvcal.a INCLUDES = \ - -I . \ - -I../libicalvcal \ - -I $(srcdir)/../libicalvcal \ - -I $(srcdir) \ - -I../libical \ - -I $(srcdir)/../libical \ - -I../libicalss \ - -I $(srcdir)/../libicalss + -I . \ + -I../libicalvcal \ + -I $(srcdir)/../libicalvcal \ + -I $(srcdir) \ + -I../libical \ + -I $(srcdir)/../libical \ + -I../libicalss \ + -I $(srcdir)/../libicalss -findobj_SOURCES = findobj.c copycluster_SOURCES = copycluster.c regression_SOURCES = regression.c parser_SOURCES = icaltestparser.c @@ -20,4 +20,6 @@ storage_SOURCES = storage.c stow_SOURCES = stow.c testvcal_SOURCES = testvcal.c recur_SOURCES = recur.c -test_mime = testmime.c +testmime_SOURCES = testmime.c +process_SOURCES = process.c +testclassify_SOURCES = testclassify.c diff --git a/libical/src/test/copycluster.c b/libical/src/test/copycluster.c index 11bd94c62d..0d6722fc94 100644 --- a/libical/src/test/copycluster.c +++ b/libical/src/test/copycluster.c @@ -4,7 +4,6 @@ CREATOR: eric 15 January 2000 $Id$ - $Locker$ (C) COPYRIGHT 2000 Eric Busboom http://www.softwarestudio.org @@ -27,6 +26,7 @@ #include <stdio.h> /* for printf */ #include "ical.h" +#include "icalss.h" #include "icalfileset.h" #include <errno.h> #include <string.h> /* For strerror */ @@ -72,11 +72,9 @@ int main(int c, char *argv[]){ } - for (itr = icalfileset_get_first_component(clusterin, - ICAL_ANY_COMPONENT); + for (itr = icalset_get_first_component(clusterin); itr != 0; - itr = icalfileset_get_next_component(clusterin, - ICAL_ANY_COMPONENT)){ + itr = icalset_get_next_component(clusterin)){ icalrestriction_check(itr); @@ -108,6 +106,7 @@ int main(int c, char *argv[]){ icalfileset_free(clusterout); } - return 0; + return 0; } + diff --git a/libical/src/test/regression.c b/libical/src/test/regression.c index dc6a5301f1..1d66ee4fc5 100644 --- a/libical/src/test/regression.c +++ b/libical/src/test/regression.c @@ -1,12 +1,11 @@ /* -*- Mode: C -*- ====================================================================== - FILE: usecases.c + FILE: regression.c CREATOR: eric 03 April 1999 DESCRIPTION: $Id$ - $Locker$ (C) COPYRIGHT 1999 Eric Busboom http://www.softwarestudio.org @@ -22,24 +21,20 @@ limitations under the License. The original author is Eric Busboom - The original code is usecases.c + The original code is regression.c ======================================================================*/ #include "ical.h" +#include "icalss.h" + #include <assert.h> #include <string.h> /* for strdup */ #include <stdlib.h> /* for malloc */ #include <stdio.h> /* for printf */ #include <time.h> /* for time() */ -#include "icalmemory.h" -#include "icalerror.h" -#include "icalrestriction.h" -#include "icalcalendar.h" -#include "icalgauge.h" -#include "icaldirset.h" -#include "icalfileset.h" + /* This example creates and minipulates the ical object that appears * in rfc 2445, page 137 */ @@ -829,11 +824,9 @@ int test_store() rtime.end = rtime.start; rtime.end.hour++; - for (itr = icalfileset_get_first_component(cluster, - ICAL_ANY_COMPONENT); + for (itr = icalfileset_get_first_component(cluster); itr != 0; - itr = icalfileset_get_next_component(cluster, - ICAL_ANY_COMPONENT)){ + itr = icalfileset_get_next_component(cluster)){ icalcomponent *clone; icalproperty *p; @@ -929,11 +922,11 @@ int test_store() #endif - for(c = icaldirset_get_first_component(s,ICAL_ANY_COMPONENT); + for(c = icaldirset_get_first_component(s); c != 0; c = next){ - next = icaldirset_get_next_component(s,ICAL_ANY_COMPONENT); + next = icaldirset_get_next_component(s); if (c != 0){ /*icaldirset_remove_component(s,c);*/ @@ -1023,34 +1016,6 @@ void test_restriction() rtime.end = icaltime_from_timet( time(0),0,0); rtime.end.hour++; - - - /* Property restrictions */ - assert(icalrestriction_get_property_restriction( - ICAL_METHOD_PUBLISH, - ICAL_VEVENT_COMPONENT, - ICAL_SEQUENCE_PROPERTY) == 5); /* ZEROORONE -> 5 */ - - assert(icalrestriction_get_property_restriction( - ICAL_METHOD_PUBLISH, - ICAL_VEVENT_COMPONENT, - ICAL_ATTACH_PROPERTY)==3); /* ZEROPLUS -> 3 */ - - assert(icalrestriction_get_property_restriction( - ICAL_METHOD_DECLINECOUNTER, - ICAL_VEVENT_COMPONENT, - ICAL_SEQUENCE_PROPERTY)==1); /* ZERO -> 1 */ - - /* Component restrictions */ - assert(icalrestriction_get_component_restriction( - ICAL_METHOD_PUBLISH, - ICAL_VJOURNAL_COMPONENT, - ICAL_X_COMPONENT) == 3); /* ZEROPLUS */ - - assert(icalrestriction_get_component_restriction( - ICAL_METHOD_CANCEL, - ICAL_VJOURNAL_COMPONENT, - ICAL_VEVENT_COMPONENT) == 1); /* ZERO */ comp = icalcomponent_vanew( @@ -1124,6 +1089,7 @@ void test_restriction() } +#if 0 void test_calendar() { icalcomponent *comp; @@ -1168,6 +1134,9 @@ void test_calendar() icalcalendar_free(calendar); } +#endif + +void test_increment(void); void test_recur() { @@ -1198,6 +1167,64 @@ void test_recur() printf("%s\n",icalvalue_as_ical_string(v)); + test_increment(); + +} + + +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; + struct icaltimetype last; /* last time return from _iterator_next*/ + int occurrence_no; /* number of step made on this iterator */ + struct icalrecurrencetype rule; + + short days[366]; + short days_index; + + enum byrule byrule; + short by_indices[9]; + + + short *by_ptrs[9]; /* Pointers into the by_* array elements of the rule */ +}; + +void icalrecurrencetype_test() +{ + icalvalue *v = icalvalue_new_from_string( + ICAL_RECUR_VALUE, + "FREQ=YEARLY;UNTIL=20060101T000000;INTERVAL=2;BYDAY=SU,WE;BYSECOND=15,30; BYMONTH=1,6,11"); + + struct icalrecurrencetype r = icalvalue_get_recur(v); + struct icaltimetype t = icaltime_from_timet( time(0), 0, 0); + struct icaltimetype next; + time_t tt; + + struct icalrecur_iterator_impl* itr + = (struct icalrecur_iterator_impl*) icalrecur_iterator_new(r,t); + + do { + + next = icalrecur_iterator_next(itr); + tt = icaltime_as_timet(next); + + printf("%s",ctime(&tt )); + + } while( ! icaltime_is_null_time(next)); + } void test_recur_expansion() @@ -1213,6 +1240,83 @@ void test_recur_expansion() icalrecurrencetype_test(); } +static const char test_icalcomp_str[] = +"BEGIN:VEVENT\r\n" +"UID\r\n" +" :20001121T203327-22955-2183-22933-0@guanabana.helixcode.com\r\n" +"DTSTAMP\r\n" +" :20001121T203327\r\n" +"DTSTART\r\n" +" :20001121T170000\r\n" +"DTEND\r\n" +" :20001121T180000\r\n" +"SUMMARY\r\n" +" :recur on the second Friday every month\\, forever\r\n" +"SEQUENCE\r\n" +" :3\r\n" +"CLASS\r\n" +" :PRIVATE\r\n" +"RRULE\r\n" +" :FREQ=MONTHLY;INTERVAL=1;BYDAY=-2WE,2FR,3SA,-2WE\n" +"END:VEVENT\r\n"; + +void test_recur_bug() +{ + icalcomponent *icalcomp; + char *str; + icalproperty *prop; + struct icalrecurrencetype r; + + /* Print the original stuff */ + + puts ("The original component is:\n\n"); + puts (test_icalcomp_str); + + /* Parse the component */ + + icalcomp = icalparser_parse_string ((char *) test_icalcomp_str); + + if (!icalcomp) { + fprintf (stderr, "main(): Could not parse the stuff\n"); + exit (EXIT_FAILURE); + } + + if (icalcomponent_isa (icalcomp) != ICAL_VEVENT_COMPONENT) { + fprintf (stderr, "main(): This is not the test data I want\n"); + exit (EXIT_FAILURE); + } + + /* Watch the property */ + + prop = icalcomponent_get_first_property (icalcomp, ICAL_RRULE_PROPERTY); + if (!prop) { + fprintf (stderr, "main(): This is not the test data I want\n"); + exit (EXIT_FAILURE); + } + + r = icalproperty_get_rrule (prop); + printf ("\nThe first BYDAY element is %d\n", r.by_day[0]); + + printf ("Position is %d, weekday is %d\n", + icalrecurrencetype_day_position (r.by_day[0]), + (int) icalrecurrencetype_day_day_of_week (r.by_day[0])); + + /* Re-stringify */ + + puts ("\nThe component looks like this after re-stringification:\n\n"); + + str = icalcomponent_as_ical_string (icalcomp); + if (!str) { + fprintf (stderr, "main(): Could not stringify the component\n"); + exit (EXIT_FAILURE); + } + + puts (str); + puts ("\n"); + +} + + void test_duration() { @@ -1223,6 +1327,12 @@ void test_duration() printf("%s\n",icalvalue_as_ical_string(v)); + + v = icalvalue_new_from_string(ICAL_DURATION_VALUE, + "-PT8H30M"); + + printf("%s\n",icalvalue_as_ical_string(v)); + icalvalue_free(v); v = icalvalue_new_from_string(ICAL_PERIOD_VALUE, "19971015T050000Z/PT8H30M"); @@ -1320,18 +1430,29 @@ void test_requeststat() } +char ictt_str[1024]; +char* ictt_as_string(struct icaltimetype t) +{ + + sprintf(ictt_str,"%02d-%02d-%02d %02d:%02d:%02d %c",t.year,t.month,t.day, + t.hour,t.minute,t.second,t.is_utc?'Z':' '); + + return ictt_str; +} void test_time() { - struct icaltimetype ictt; + struct icaltimetype ictt, icttutc, icttny,icttphoenix; time_t tt,tt2; icalvalue *v; short day_of_week,start_day_of_week, day_of_year; - tt = time(0); + tt = 973276230; /* Fri Nov 3 10:30:30 PST 2000 in UTC */ + + printf("\n Convert to and from lib c \n"); - printf("System time is: %s\n",ctime(&tt)); + printf("System time is: %s",ctime(&tt)); ictt = icaltime_from_timet(tt,0,0); @@ -1340,8 +1461,9 @@ void test_time() printf("System time from libical: %s\n",icalvalue_as_ical_string(v)); tt2 = icaltime_as_timet(ictt); - printf("Converted back to libc: %s\n",ctime(&tt2)); + printf("Converted back to libc: %s",ctime(&tt2)); + printf("\n Incrementing time \n"); ictt.year++; tt2 = icaltime_as_timet(ictt); @@ -1349,14 +1471,15 @@ void test_time() ictt.month+=13; tt2 = icaltime_as_timet(ictt); - printf("Add 13 months: %s\n",ctime(&tt2)); + printf("Add 13 months: %s",ctime(&tt2)); ictt.second+=90; tt2 = icaltime_as_timet(ictt); - printf("Add 90 seconds: %s\n",ctime(&tt2)); + printf("Add 90 seconds: %s",ctime(&tt2)); ictt = icaltime_from_timet(tt,0,0); + printf("\n Day Of week \n"); day_of_week = icaltime_day_of_week(ictt); start_day_of_week = icaltime_start_doy_of_week(ictt); @@ -1365,6 +1488,30 @@ void test_time() printf("Today is day of week %d, day of year %d\n",day_of_week,day_of_year); printf("Week started n doy of %d\n",start_day_of_week); + printf("\n To and From UTC\n"); + + ictt = icaltime_from_timet(tt,0,1); + printf("As utc : %s\n", ictt_as_string(ictt)); + ictt = icaltime_from_timet(tt,0,0); + printf("As local : %s\n", ictt_as_string(ictt)); + + + + printf("\n TimeZone Conversions \n"); + + ictt = icaltime_from_timet(tt,0,1); + + icttutc = icaltime_as_utc(ictt,"America/Los_Angeles"); + + icttny = icaltime_as_zone(icttutc,"America/New_York"); + + icttphoenix = icaltime_as_zone(icttutc,"America/Phoenix"); + + printf("Orig : %s", ctime(&tt) ); + printf("UTC : %s\n", ictt_as_string(icttutc)); + printf("Los Angeles: %s\n", ictt_as_string(ictt)); + printf("Phoenix : %s\n", ictt_as_string(icttphoenix)); + printf("New York : %s\n", ictt_as_string(icttny)); } @@ -1408,7 +1555,7 @@ void test_iterators() icalproperty *p = icalcomponent_get_first_property(this, ICAL_VERSION_PROPERTY); - char* s = icalproperty_get_version(p); + const char* s = icalproperty_get_version(p); printf("%s ",s); @@ -1452,7 +1599,7 @@ void test_iterators() icalproperty *p = icalcomponent_get_first_property(inner,ICAL_VERSION_PROPERTY); - char* s = icalproperty_get_version(p); + const char* s = icalproperty_get_version(p); printf("%s ",s); } @@ -1467,7 +1614,7 @@ void test_iterators() icalcomponent *this; icalproperty *p; - char* s; + const char* s; next = icalcomponent_get_next_component(c,ICAL_ANY_COMPONENT); p=icalcomponent_get_first_property(inner,ICAL_VERSION_PROPERTY); @@ -1498,7 +1645,7 @@ void test_iterators() icalproperty *p = icalcomponent_get_first_property(inner,ICAL_VERSION_PROPERTY); - char* s = icalproperty_get_version(p); + const char* s = icalproperty_get_version(p); printf("%s ",s); } @@ -1506,22 +1653,450 @@ void test_iterators() printf("\n"); } -int main(int argc, char *argv[]) + +void test_icalset() { + icalcomponent *c; - printf("\n------------Test Memory---------------\n"); - test_memory(); + icalset* f = icalset_new_file("2446.ics"); + icalset* d = icalset_new_dir("outdir"); -exit(0); + assert(f!=0); + assert(d!=0); + for(c = icalset_get_first_component(f); + c != 0; + c = icalset_get_next_component(f)){ - printf("\n------------Test Iterators-----------\n"); - test_iterators(); + icalcomponent *clone; + + clone = icalcomponent_new_clone(c); + + icalset_add_component(d,clone); + + printf(" class %d\n",icalclassify(c,0,"user")); + + } +} + +void test_classify() +{ + icalcomponent *c,*match; + + icalset* f = icalset_new_file("../../test-data/classify.ics"); + + assert(f!=0); + + c = icalset_get_first_component(f); + match = icalset_get_next_component(f); + + printf("Class %d\n",icalclassify(c,match,"A@example.com")); + + +} + +void print_span(int c, struct icaltime_span span ){ + + printf("#%02d start: %s",c,ctime(&span.start)); + printf(" end : %s",ctime(&span.end)); + +} + +void test_span() +{ + time_t tm1 = 973378800; /*Sat Nov 4 23:00:00 UTC 2000, + Sat Nov 4 15:00:00 PST 2000 */ + time_t tm2 = 973382400; /*Sat Nov 5 00:00:00 UTC 2000 + Sat Nov 4 16:00:00 PST 2000 */ + struct icaldurationtype dur; + struct icaltime_span span; + icalcomponent *c; + + memset(&dur,0,sizeof(dur)); + dur.minutes = 30; + + span.start = tm1; + span.end = tm2; + print_span(0,span); + + /* Specify save timezone as in commend above */ + c = + icalcomponent_vanew( + ICAL_VEVENT_COMPONENT, + icalproperty_vanew_dtstart(icaltime_from_timet(tm1,0,0), + icalparameter_new_tzid("US/Pacific"),0), + icalproperty_vanew_dtend(icaltime_from_timet(tm2,0,0), + icalparameter_new_tzid("US/Pacific"),0), + 0 + ); + + printf("%s\n",icalcomponent_as_ical_string(c)); + + span = icalcomponent_get_span(c); + + print_span(1,span); + + /* Use machine's local timezone. Same as above if run in US/Pacific */ + c = + icalcomponent_vanew( + ICAL_VEVENT_COMPONENT, + icalproperty_vanew_dtstart(icaltime_from_timet(tm1,0,0),0), + icalproperty_vanew_dtend(icaltime_from_timet(tm2,0,0),0), + 0 + ); + + span = icalcomponent_get_span(c); + + print_span(2,span); + + /* Specify different timezone */ + c = + icalcomponent_vanew( + ICAL_VEVENT_COMPONENT, + icalproperty_vanew_dtstart(icaltime_from_timet(tm1,0,0), + icalparameter_new_tzid("US/Eastern"),0), + icalproperty_vanew_dtend(icaltime_from_timet(tm2,0,0), + icalparameter_new_tzid("US/Eastern"),0), + 0 + ); + span = icalcomponent_get_span(c); + print_span(3,span); + + /* Specify different timezone for start and end*/ + c = + icalcomponent_vanew( + ICAL_VEVENT_COMPONENT, + icalproperty_vanew_dtstart(icaltime_from_timet(tm1,0,0), + icalparameter_new_tzid("US/Eastern"),0), + icalproperty_vanew_dtend(icaltime_from_timet(tm2,0,0), + icalparameter_new_tzid("US/Pacific"),0), + 0 + ); + span = icalcomponent_get_span(c); + print_span(4,span); + + + /* Use Duration */ + c = + icalcomponent_vanew( + ICAL_VEVENT_COMPONENT, + icalproperty_vanew_dtstart(icaltime_from_timet(tm1,0,0), + icalparameter_new_tzid("US/Pacific"),0), + icalproperty_new_duration(dur), + + 0 + ); + span = icalcomponent_get_span(c); + print_span(5,span); + +#ifndef ICAL_ERRORS_ARE_FATAL + /* Both UTC and Timezone -- an error */ + icalerror_clear_errno(); + c = + icalcomponent_vanew( + ICAL_VEVENT_COMPONENT, + icalproperty_vanew_dtstart(icaltime_from_timet(tm1,0,1), + icalparameter_new_tzid("US/Eastern"),0), + icalproperty_vanew_dtend(icaltime_from_timet(tm2,0,1), + icalparameter_new_tzid("US/Eastern"),0), + 0 + ); + + span = icalcomponent_get_span(c); + assert(icalerrno != ICAL_NO_ERROR); +#endif /*ICAL_ERRORS_ARE_FATAL*/ + +} + +icalcomponent* icalclassify_find_overlaps(icalset* set, icalcomponent* comp); + +void test_overlaps() +{ + icalcomponent *cset,*c; + icalset *set; + time_t tm1 = 973378800; /*Sat Nov 4 23:00:00 UTC 2000, + Sat Nov 4 15:00:00 PST 2000 */ + time_t tm2 = 973382400; /*Sat Nov 5 00:00:00 UTC 2000 + Sat Nov 4 16:00:00 PST 2000 */ + + time_t hh = 1800; /* one half hour */ + + set = icalset_new_file("../../test-data/overlaps.ics"); + + printf("-- 1 -- \n"); + c = icalcomponent_vanew( + ICAL_VEVENT_COMPONENT, + icalproperty_vanew_dtstart(icaltime_from_timet(tm1-hh,0,1),0), + icalproperty_vanew_dtend(icaltime_from_timet(tm2-hh,0,1),0), + 0 + ); + + cset = icalclassify_find_overlaps(set,c); + + printf("%s\n",icalcomponent_as_ical_string(cset)); + + printf("-- 2 -- \n"); + c = icalcomponent_vanew( + ICAL_VEVENT_COMPONENT, + icalproperty_vanew_dtstart(icaltime_from_timet(tm1-hh,0,1),0), + icalproperty_vanew_dtend(icaltime_from_timet(tm2,0,1),0), + 0 + ); + + cset = icalclassify_find_overlaps(set,c); + printf("%s\n",icalcomponent_as_ical_string(cset)); + + printf("-- 3 -- \n"); + c = icalcomponent_vanew( + ICAL_VEVENT_COMPONENT, + icalproperty_vanew_dtstart(icaltime_from_timet(tm1+5*hh,0,1),0), + icalproperty_vanew_dtend(icaltime_from_timet(tm2+5*hh,0,1),0), + 0 + ); + + cset = icalclassify_find_overlaps(set,c); + + printf("%s\n",icalcomponent_as_ical_string(cset)); + +} + +void test_fblist() +{ + icalspanlist *sl; + icalset* set = icalset_new_file("../../test-data/spanlist.ics"); + struct icalperiodtype period; + + sl = icalspanlist_new(set, + icaltime_from_string("19970324T1200Z"), + icaltime_from_string("19990424T020000Z")); + + printf("Restricted spanlist\n"); + icalspanlist_dump(sl); + + period= icalspanlist_next_free_time(sl, + icaltime_from_string("19970801T1200Z")); + + + printf("Next Free time: %s\n",icaltime_as_ctime(period.start)); + printf(" %s\n",icaltime_as_ctime(period.end)); + + + icalspanlist_free(sl); + + printf("Unrestricted spanlist\n"); + + sl = icalspanlist_new(set, + icaltime_from_string("19970324T1200Z"), + icaltime_null_time()); + + printf("Restricted spanlist\n"); + + icalspanlist_dump(sl); + + period= icalspanlist_next_free_time(sl, + icaltime_from_string("19970801T1200Z")); + + + printf("Next Free time: %s\n",icaltime_as_ctime(period.start)); + printf(" %s\n",icaltime_as_ctime(period.end)); + + + icalspanlist_free(sl); + + +} + +void test_convenience(){ + + icalcomponent *c; + int duration; + + c = icalcomponent_vanew( + ICAL_VCALENDAR_COMPONENT, + icalcomponent_vanew( + ICAL_VEVENT_COMPONENT, + icalproperty_new_dtstart(icaltime_from_string("19970801T1200")), + icalproperty_new_dtend(icaltime_from_string("19970801T1300")), + 0 + ), + 0); + + printf("** 1 DTSTART and DTEND **\n%s\n\n", + icalcomponent_as_ical_string(c)); + + duration = icaldurationtype_as_timet(icalcomponent_get_duration(c))/60; + + printf("Start: %s\n",ictt_as_string(icalcomponent_get_dtstart(c))); + printf("End: %s\n",ictt_as_string(icalcomponent_get_dtend(c))); + printf("Dur: %d m\n",duration); + + icalcomponent_free(c); + + c = icalcomponent_vanew( + ICAL_VCALENDAR_COMPONENT, + icalcomponent_vanew( + ICAL_VEVENT_COMPONENT, + icalproperty_new_dtstart(icaltime_from_string("19970801T1200Z")), + icalproperty_new_duration(icaldurationtype_from_string("PT1H30M")), + 0 + ), + 0); + + printf("\n** 2 DTSTART and DURATION **\n%s\n\n", + icalcomponent_as_ical_string(c)); + + duration = icaldurationtype_as_timet(icalcomponent_get_duration(c))/60; + + printf("Start: %s\n",ictt_as_string(icalcomponent_get_dtstart(c))); + printf("End: %s\n",ictt_as_string(icalcomponent_get_dtend(c))); + printf("Dur: %d m\n",duration); + + icalcomponent_free(c); + + c = icalcomponent_vanew( + ICAL_VCALENDAR_COMPONENT, + icalcomponent_vanew( + ICAL_VEVENT_COMPONENT, + icalproperty_new_dtstart(icaltime_from_string("19970801T1200")), + icalproperty_new_dtend(icaltime_from_string("19970801T1300")), + 0 + ), + 0); + + icalcomponent_set_duration(c,icaldurationtype_from_string("PT1H30M")); + + printf("** 3 DTSTART and DTEND, Set DURATION **\n%s\n\n", + icalcomponent_as_ical_string(c)); + + duration = icaldurationtype_as_timet(icalcomponent_get_duration(c))/60; + + printf("Start: %s\n",ictt_as_string(icalcomponent_get_dtstart(c))); + printf("End: %s\n",ictt_as_string(icalcomponent_get_dtend(c))); + printf("Dur: %d m\n",duration); + + icalcomponent_free(c); + + c = icalcomponent_vanew( + ICAL_VCALENDAR_COMPONENT, + icalcomponent_vanew( + ICAL_VEVENT_COMPONENT, + icalproperty_new_dtstart(icaltime_from_string("19970801T1200Z")), + icalproperty_new_duration(icaldurationtype_from_string("PT1H30M")), + 0 + ), + 0); + + icalcomponent_set_dtend(c,icaltime_from_string("19970801T1330Z")); + + printf("\n** 4 DTSTART and DURATION, set DTEND **\n%s\n\n", + icalcomponent_as_ical_string(c)); + + duration = icaldurationtype_as_timet(icalcomponent_get_duration(c))/60; + + printf("Start: %s\n",ictt_as_string(icalcomponent_get_dtstart(c))); + printf("End: %s\n",ictt_as_string(icalcomponent_get_dtend(c))); + printf("Dur: %d m\n",duration); + + icalcomponent_free(c); + + c = icalcomponent_vanew( + ICAL_VCALENDAR_COMPONENT, + icalcomponent_vanew( + ICAL_VEVENT_COMPONENT, + 0 + ), + 0); + + icalcomponent_set_dtstart(c,icaltime_from_string("19970801T1200Z")); + icalcomponent_set_dtend(c,icaltime_from_string("19970801T1330Z")); + + printf("\n** 5 Set DTSTART and DTEND **\n%s\n\n", + icalcomponent_as_ical_string(c)); + + + duration = icaldurationtype_as_timet(icalcomponent_get_duration(c))/60; + + printf("Start: %s\n",ictt_as_string(icalcomponent_get_dtstart(c))); + printf("End: %s\n",ictt_as_string(icalcomponent_get_dtend(c))); + printf("Dur: %d m\n",duration); + + icalcomponent_free(c); + + c = icalcomponent_vanew( + ICAL_VCALENDAR_COMPONENT, + icalcomponent_vanew( + ICAL_VEVENT_COMPONENT, + 0 + ), + 0); + + + icalcomponent_set_dtstart(c,icaltime_from_string("19970801T1200Z")); + icalcomponent_set_duration(c,icaldurationtype_from_string("PT1H30M")); + + printf("\n** 6 Set DTSTART and DURATION **\n%s\n\n", + icalcomponent_as_ical_string(c)); + + + duration = icaldurationtype_as_timet(icalcomponent_get_duration(c))/60; + + printf("Start: %s\n",ictt_as_string(icalcomponent_get_dtstart(c))); + printf("End: %s\n",ictt_as_string(icalcomponent_get_dtend(c))); + printf("Dur: %d m\n",duration); + + icalcomponent_free(c); + +} + +int main(int argc, char *argv[]) +{ + + printf("\n------------Test recur bug ----------\n"); + test_recur_bug(); + + exit(0); + + printf("\n------------Test recur---------------\n"); + test_recur(); + + printf("\n------------Test FBlist------------\n"); + test_fblist(); printf("\n------------Test time----------------\n"); test_time(); + + printf("\n------------Test Overlaps------------\n"); + test_overlaps(); + + + printf("\n------------Test Span----------------\n"); + test_span(); + + + printf("\n------------Test duration---------------\n"); + test_duration(); + + exit(0); + + + + printf("\n------------Test Convenience ------------\n"); + test_convenience(); + + + + printf("\n------------Test classify ---------------\n"); + test_classify(); + + printf("\n------------Test Memory---------------\n"); + test_memory(); + + + printf("\n------------Test Iterators-----------\n"); + test_iterators(); + printf("\n------------Test Restriction---------------\n"); test_restriction(); @@ -1531,12 +2106,6 @@ exit(0); printf("\n------------Test strings---------------\n"); test_strings(); - printf("\n------------Test recur---------------\n"); - test_recur(); - - printf("\n------------Test duration---------------\n"); - test_duration(); - printf("\n------------Test Compare---------------\n"); test_compare(); @@ -1559,9 +2128,13 @@ exit(0); create_new_component_with_va_args(); + return 0; + + printf("\n------------Test icalset ---------------\n"); + test_icalset(); + - return 0; } diff --git a/libical/src/test/storage.c b/libical/src/test/storage.c index d53001b574..b8eb48c30f 100644 --- a/libical/src/test/storage.c +++ b/libical/src/test/storage.c @@ -6,7 +6,6 @@ DESCRIPTION: $Id$ - $Locker$ (C) COPYRIGHT 1999 Eric Busboom http://www.softwarestudio.org @@ -162,11 +161,9 @@ void test_fileset() cout = icalfileset_new(OUTPUT_FILE); assert(cout != 0); - for (itr = icalfileset_get_first_component(cout, - ICAL_ANY_COMPONENT); + for (itr = icalfileset_get_first_component(cout); itr != 0; - itr = icalfileset_get_next_component(cout, - ICAL_ANY_COMPONENT)){ + itr = icalfileset_get_next_component(cout)){ icalcomponent *event; icalproperty *dtstart, *dtend; @@ -190,11 +187,9 @@ void test_fileset() cout = icalfileset_new(OUTPUT_FILE); assert(cout != 0); - for (itr = icalfileset_get_first_component(cout, - ICAL_ANY_COMPONENT); + for (itr = icalfileset_get_first_component(cout); itr != 0; - itr = icalfileset_get_next_component(cout, - ICAL_ANY_COMPONENT)){ + itr = icalfileset_get_next_component(cout)){ icalfileset_remove_component(cout, itr); @@ -209,11 +204,9 @@ void test_fileset() assert(cout != 0); count =0; - for (itr = icalfileset_get_first_component(cout, - ICAL_ANY_COMPONENT); + for (itr = icalfileset_get_first_component(cout); itr != 0; - itr = icalfileset_get_next_component(cout, - ICAL_ANY_COMPONENT)){ + itr = icalfileset_get_next_component(cout)){ icalcomponent *event; icalproperty *dtstart, *dtend; @@ -269,11 +262,9 @@ int test_dirset() rtime.end = rtime.start; rtime.end.hour++; - for (itr = icalfileset_get_first_component(cluster, - ICAL_ANY_COMPONENT); + for (itr = icalfileset_get_first_component(cluster); itr != 0; - itr = icalfileset_get_next_component(cluster, - ICAL_ANY_COMPONENT)){ + itr = icalfileset_get_next_component(cluster)){ icalcomponent *clone, *inner; icalproperty *p; @@ -370,9 +361,9 @@ int test_dirset() #endif - for(c = icaldirset_get_first_component(s,ICAL_ANY_COMPONENT); + for(c = icaldirset_get_first_component(s); c != 0; - c = icaldirset_get_next_component(s,ICAL_ANY_COMPONENT)){ + c = icaldirset_get_next_component(s)){ if (c != 0){ printf("%s", icalcomponent_as_ical_string(c));; @@ -395,6 +386,7 @@ int test_dirset() return 0; } +#if 0 void test_calendar() { icalcomponent *comp; @@ -439,6 +431,7 @@ void test_calendar() icalcalendar_free(calendar); } +#endif int main(int argc, char *argv[]) diff --git a/libical/src/test/stow.c b/libical/src/test/stow.c index f742b417a5..6c285afc77 100644 --- a/libical/src/test/stow.c +++ b/libical/src/test/stow.c @@ -4,7 +4,6 @@ CREATOR: eric 29 April 2000 $Id$ - $Locker$ (C) COPYRIGHT 2000 Eric Busboom http://www.softwarestudio.org @@ -47,6 +46,9 @@ char* program_name; #define TMPSIZE 2048 #define SENDMAIL "/usr/lib/sendmail -t" +void usage(char *message); + + enum options { STORE_IN_FILE, STORE_IN_DB, @@ -113,7 +115,7 @@ enum file_type test_file(char *path) return type; } -char* lowercase(char* str) +char* lowercase(const char* str) { char* p = 0; char* new = strdup(str); @@ -152,11 +154,6 @@ char* get_local_attendee(struct options_struct *opt) } #endif -void usage(char *message) -{ - fprintf(stderr,"Usage: %s [-emdcn] [-i inputfile] [-o outputfile] [-u calid]\n",program_name); - -} icalcomponent* get_first_real_component(icalcomponent *comp) { @@ -178,8 +175,9 @@ icalcomponent* get_first_real_component(icalcomponent *comp) -char* make_mime(char* to, char* from, char* subject, - char* text_message, char* method, char* ical_message) +char* make_mime(char* to, const char* from, const char* subject, + const char* text_message, const char* method, + const char* ical_message) { size_t size = strlen(to)+strlen(from)+strlen(subject)+ strlen(text_message)+ strlen(ical_message)+TMPSIZE; @@ -226,8 +224,8 @@ Content-Type: multipart/mixed; boundary=\"%s\"\n\ \n\ This is a multimedia message in MIME format\n\ \n\ ---%s -%s +--%s\n\ +%s\n\ ", to,from,subject,content_id,boundary,boundary, mime_part_1); @@ -251,7 +249,7 @@ void return_failure(icalcomponent* comp, char* message, icalcomponent *inner = get_first_real_component(comp); icalproperty *organizer_prop = icalcomponent_get_first_property(inner,ICAL_ORGANIZER_PROPERTY); - char *organizer = icalproperty_get_organizer(organizer_prop); + const char *organizer = icalproperty_get_organizer(organizer_prop); organizer += 7; @@ -347,7 +345,7 @@ icalcomponent* make_reply(icalcomponent *comp, icalproperty *return_status, } int check_attendee(icalproperty *p, struct options_struct *opt){ - char* s = icalproperty_get_attendee(p); + const char* s = icalproperty_get_attendee(p); char* lower_attendee = lowercase(s); char* local_attendee = opt->calid; @@ -481,6 +479,21 @@ char* check_component(icalcomponent* comp, icalproperty **return_status, } +void usage(char *message) +{ + fprintf(stderr,"Usage: %s [-emdcn] [-i inputfile] [-o outputfile] [-u calid]\n",program_name); + fprintf(stderr,"-e\tInput data is encapsulated in a MIME Message \n\ +-m\tInput is raw iCal \n\ +-i\tSpecify input file. Otherwise, input comed from stdin\n\ +-o\tSpecify file to save incoming message to\n\ +-d\tSpecify database to send data to\n\ +-u\tSet the calid to store the data to\n\ +-n\tSend errors to stdout instead of organizer\n\ +"); + +} + + void get_options(int argc, char* argv[], struct options_struct *opt) { int c; |