aboutsummaryrefslogtreecommitdiffstats
path: root/libical/src
diff options
context:
space:
mode:
Diffstat (limited to 'libical/src')
-rw-r--r--libical/src/libical/Makefile.am281
-rw-r--r--libical/src/libical/ical.h2432
-rw-r--r--libical/src/libical/icalcomponent.c517
-rw-r--r--libical/src/libical/icalcomponent.h77
-rw-r--r--libical/src/libical/icalenums.c155
-rw-r--r--libical/src/libical/icalenums.h66
-rw-r--r--libical/src/libical/icalerror.c12
-rw-r--r--libical/src/libical/icalerror.h17
-rw-r--r--libical/src/libical/icallexer.l39
-rw-r--r--libical/src/libical/icalmemory.c25
-rw-r--r--libical/src/libical/icalmemory.h33
-rw-r--r--libical/src/libical/icalparameter.c251
-rw-r--r--libical/src/libical/icalparameter.h80
-rw-r--r--libical/src/libical/icalparser.c26
-rw-r--r--libical/src/libical/icalparser.h11
-rw-r--r--libical/src/libical/icalproperty.c375
-rw-r--r--libical/src/libical/icalproperty.h262
-rw-r--r--libical/src/libical/icalrestriction.c369
-rw-r--r--libical/src/libical/icalrestriction.h12
-rw-r--r--libical/src/libical/icaltime.c235
-rw-r--r--libical/src/libical/icaltime.h67
-rw-r--r--libical/src/libical/icaltypes.c71
-rw-r--r--libical/src/libical/icaltypes.h85
-rw-r--r--libical/src/libical/icalvalue.c148
-rw-r--r--libical/src/libical/icalvalue.h52
-rw-r--r--libical/src/libical/icalversion.h.in4
-rw-r--r--libical/src/libical/icalyacc.c245
-rw-r--r--libical/src/libical/icalyacc.y57
-rw-r--r--libical/src/libical/pvl.c8
-rw-r--r--libical/src/libical/pvl.h2
-rw-r--r--libical/src/libicalss/Makefile.am89
-rw-r--r--libical/src/libicalss/icalcstp.h174
-rw-r--r--libical/src/libicalvcal/Makefile.am38
-rw-r--r--libical/src/libicalvcal/vcc.c116
-rw-r--r--libical/src/libicalvcal/vcc.y42
-rw-r--r--libical/src/test/Makefile.am26
-rw-r--r--libical/src/test/copycluster.c11
-rw-r--r--libical/src/test/regression.c707
-rw-r--r--libical/src/test/storage.c31
-rw-r--r--libical/src/test/stow.c39
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;