aboutsummaryrefslogtreecommitdiffstats
path: root/libical/src
diff options
context:
space:
mode:
Diffstat (limited to 'libical/src')
-rw-r--r--libical/src/Makefile.am9
-rw-r--r--libical/src/libical/Makefile.am143
-rw-r--r--libical/src/libical/icalcomponent.c96
-rw-r--r--libical/src/libical/icalcomponent.h61
-rw-r--r--libical/src/libical/icalenums.c496
-rw-r--r--libical/src/libical/icalenums.h349
-rw-r--r--libical/src/libical/icalerror.c115
-rw-r--r--libical/src/libical/icalerror.h131
-rw-r--r--libical/src/libical/icallangbind.c279
-rw-r--r--libical/src/libical/icalmemory.h4
-rw-r--r--libical/src/libical/icalparser.c169
-rw-r--r--libical/src/libical/icalparser.h2
-rw-r--r--libical/src/libical/icalrecur.c910
-rw-r--r--libical/src/libical/icaltime.c501
-rw-r--r--libical/src/libical/icaltime.h80
-rw-r--r--libical/src/libical/icaltypes.h31
-rw-r--r--libical/src/libicalss/Makefile.am14
-rw-r--r--libical/src/libicalss/icalcstp.h164
-rw-r--r--libical/src/libicalvcal/Makefile.am3
-rw-r--r--libical/src/test/Makefile.am18
-rw-r--r--libical/src/test/copycluster.c15
-rw-r--r--libical/src/test/regression.c410
-rw-r--r--libical/src/test/stow.c6
23 files changed, 1886 insertions, 2120 deletions
diff --git a/libical/src/Makefile.am b/libical/src/Makefile.am
index bff5609c92..108581258d 100644
--- a/libical/src/Makefile.am
+++ b/libical/src/Makefile.am
@@ -1,4 +1,7 @@
-SUBDIRS = libical libicalvcal
+if WITH_PYTHON
+PYTHON_DIR = python
+else
+PYTHON_DIR =
+endif
-# disabled libicalss and test until they build
-#SUBDIRS = libical libicalss libicalvcal test
+SUBDIRS = libical libicalss libicalvcal $(PYTHON_DIR) test
diff --git a/libical/src/libical/Makefile.am b/libical/src/libical/Makefile.am
index 186e705060..e66f805201 100644
--- a/libical/src/libical/Makefile.am
+++ b/libical/src/libical/Makefile.am
@@ -1,3 +1,28 @@
+#======================================================================
+# FILE: Makefile.am
+# CREATOR: eric
+#
+# $Id: Makefile.am,v 1.27 2001/04/17 17:54:44 jpr Exp $
+#
+#
+# (C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of either:
+#
+# The LGPL as published by the Free Software Foundation, version
+# 2.1, available at: http://www.fsf.org/copyleft/lesser.html
+#
+# Or:
+#
+# The Mozilla Public License Version 1.0. You may obtain a copy of
+# the License at http://www.mozilla.org/MPL/
+#
+# The original code is icalcomponent.c
+#
+#======================================================================
+
+
DESIGNDATA = $(top_srcdir)/design-data
ICALSCRIPTS = $(top_srcdir)/scripts
@@ -20,6 +45,8 @@ INCLUDES = \
libical_la_LDFLAGS = -version-info 0:0:0
libical_la_SOURCES = \
+ icalattendee.h \
+ icalattendee.c \
icalcomponent.c \
icalcomponent.h \
icalenums.c \
@@ -33,8 +60,13 @@ libical_la_SOURCES = \
icalmime.h \
icalparameter.c \
icalparameter.h \
+ icalparameterimpl.h \
+ icalderivedparameter.c \
+ icalderivedparameter.h \
icalparser.c \
icalparser.h \
+ icalderivedproperty.c \
+ icalderivedproperty.h \
icalproperty.c \
icalproperty.h \
icalrecur.c \
@@ -43,10 +75,17 @@ libical_la_SOURCES = \
icalrestriction.h \
icaltime.c \
icaltime.h \
+ icalduration.h \
+ icalduration.c \
+ icalperiod.h \
+ icalperiod.c \
icaltypes.c \
icaltypes.h \
icalvalue.c \
icalvalue.h \
+ icalvalueimpl.h \
+ icalderivedvalue.c \
+ icalderivedvalue.h \
icalyacc.h \
icalyacc.y \
pvl.c \
@@ -66,31 +105,37 @@ libicalinclude_HEADERS = ical.h
COMBINEDHEADERS = \
$(top_builddir)/src/libical/icalversion.h \
$(top_srcdir)/src/libical/icaltime.h \
+ $(top_srcdir)/src/libical/icalduration.h \
+ $(top_srcdir)/src/libical/icalperiod.h \
$(top_srcdir)/src/libical/icalenums.h \
$(top_srcdir)/src/libical/icaltypes.h \
$(top_srcdir)/src/libical/icalrecur.h \
- icalvalue.h \
- icalparameter.h \
- icalproperty.h \
+ $(top_builddir)/src/libical/icalderivedvalue.h \
+ $(top_builddir)/src/libical/icalderivedparameter.h\
+ $(top_srcdir)/src/libical/icalvalue.h \
+ $(top_srcdir)/src/libical/icalparameter.h \
+ $(top_builddir)/src/libical/icalderivedproperty.h\
+ $(top_srcdir)/src/libical/icalproperty.h \
+ $(top_srcdir)/src/libical/icalattendee.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 \
- icalrestriction.h \
+ $(top_srcdir)/src/libical/icalrestriction.h \
$(top_srcdir)/src/libical/sspm.h \
$(top_srcdir)/src/libical/icalmime.h \
- $(top_srcdir)/src/libical/icallangbind.h
+ $(top_srcdir)/src/libical/icallangbind.h
BUILT_SOURCES = \
ical.h \
- icalparameter.c \
- icalparameter.h \
- icalproperty.c \
- icalproperty.h \
+ icalderivedparameter.c \
+ icalderivedparameter.h \
+ icalderivedproperty.c \
+ icalderivedproperty.h \
icalrestriction.c \
- icalvalue.c \
- icalvalue.h
+ icalderivedvalue.c \
+ icalderivedvalue.h
ical.h: $(BUILT_SOURCES)
cat $(COMBINEDHEADERS) \
@@ -104,37 +149,35 @@ icallexer.c : icalyacc.h
PARAMETERDEPS = \
$(ICALSCRIPTS)/mkderivedparameters.pl \
- $(DESIGNDATA)/param-c-types.txt \
- icalparameter.c.in \
- icalparameter.h.in
+ $(DESIGNDATA)/parameters.csv \
+ icalderivedparameter.c.in \
+ icalderivedparameter.h.in
-icalparameter.h: $(PARAMETERDEPS)
- $(PERL) $(ICALSCRIPTS)/mkderivedparameters.pl -i $(srcdir)/icalparameter.h.in -h $(DESIGNDATA)/param-c-types.txt > icalparameter.newh \
- && mv icalparameter.newh icalparameter.h
+icalderivedparameter.h: $(PARAMETERDEPS)
+ $(PERL) -I $(ICALSCRIPTS) $(ICALSCRIPTS)/mkderivedparameters.pl -i $(srcdir)/icalderivedparameter.h.in -h $(DESIGNDATA)/parameters.csv > icalderivedparameter.h
-icalparameter.c: $(PARAMETERDEPS) icalparameter.h
- $(PERL) $(ICALSCRIPTS)/mkderivedparameters.pl -i $(srcdir)/icalparameter.c.in -c $(DESIGNDATA)/param-c-types.txt > icalparameter.newc \
- && mv icalparameter.newc icalparameter.c
+icalderivedparameter.c: $(PARAMETERDEPS) icalparameter.h
+ $(PERL) -I $(ICALSCRIPTS) $(ICALSCRIPTS)/mkderivedparameters.pl -i $(srcdir)/icalderivedparameter.c.in -c $(DESIGNDATA)/parameters.csv > icalderivedparameter.c
# properties
PROPERTYDEPS = \
$(ICALSCRIPTS)/mkderivedproperties.pl \
- $(DESIGNDATA)/prop-to-value.txt \
- $(DESIGNDATA)/value-c-types.txt \
- icalproperty.c.in \
- icalproperty.h.in
+ $(DESIGNDATA)/properties.csv \
+ $(DESIGNDATA)/value-types.csv \
+ icalderivedproperty.c.in \
+ icalderivedproperty.h.in
-icalproperty.h: $(PROPERTYDEPS)
- $(PERL) $(ICALSCRIPTS)/mkderivedproperties.pl -i $(srcdir)/icalproperty.h.in -h \
- $(DESIGNDATA)/prop-to-value.txt \
- ${DESIGNDATA}/value-c-types.txt > icalproperty.h
+icalderivedproperty.h: $(PROPERTYDEPS)
+ $(PERL) -I$(ICALSCRIPTS) $(ICALSCRIPTS)/mkderivedproperties.pl \
+ -i $(srcdir)/icalderivedproperty.h.in -h $(DESIGNDATA)/properties.csv\
+ ${DESIGNDATA}/value-types.csv > icalderivedproperty.h
-icalproperty.c: $(PROPERTYDEPS) icalproperty.h
- $(PERL) $(ICALSCRIPTS)/mkderivedproperties.pl -i $(srcdir)/icalproperty.c.in -c \
- $(DESIGNDATA)/prop-to-value.txt \
- ${DESIGNDATA}/value-c-types.txt > icalproperty.c
+icalderivedproperty.c: $(PROPERTYDEPS) icalproperty.h
+ $(PERL) -I$(ICALSCRIPTS) $(ICALSCRIPTS)/mkderivedproperties.pl \
+ -i $(srcdir)/icalderivedproperty.c.in -c $(DESIGNDATA)/properties.csv \
+ ${DESIGNDATA}/value-types.csv > icalderivedproperty.c
# restrictions
@@ -151,33 +194,37 @@ icalrestriction.c: $(RESTRICTIONDEPS)
VALUEDEPS = \
$(ICALSCRIPTS)/mkderivedvalues.pl \
- $(DESIGNDATA)/value-c-types.txt \
- icalvalue.c.in \
- icalvalue.h.in
+ $(DESIGNDATA)/value-types.csv \
+ icalderivedvalue.c.in \
+ icalderivedvalue.h.in
-icalvalue.h: $(VALUEDEPS)
- $(PERL) $(ICALSCRIPTS)/mkderivedvalues.pl -i $(srcdir)/icalvalue.h.in -h \
- $(DESIGNDATA)/value-c-types.txt > icalvalue.h
+icalderivedvalue.h: $(VALUEDEPS)
+ $(PERL) -I$(ICALSCRIPTS) $(ICALSCRIPTS)/mkderivedvalues.pl \
+ -i $(srcdir)/icalderivedvalue.h.in -h $(DESIGNDATA)/value-types.csv > icalderivedvalue.h
-icalvalue.c: $(VALUEDEPS) icalvalue.h
- $(PERL) $(ICALSCRIPTS)/mkderivedvalues.pl -i $(srcdir)/icalvalue.c.in -c \
- $(DESIGNDATA)/value-c-types.txt > icalvalue.c
+icalderivedvalue.c: $(VALUEDEPS) icalderivedvalue.h
+ $(PERL) -I$(ICALSCRIPTS) $(ICALSCRIPTS)/mkderivedvalues.pl \
+ -i $(srcdir)/icalderivedvalue.c.in -c $(DESIGNDATA)/value-types.csv > icalderivedvalue.c
# housekeeping
CONFIG_CLEAN_FILES = y.output
+CLEANFILES += $(BUILT_SOURCES)
+
+dist-hook:
+ cd $(distdir); rm -f $(BUILT_SOURCES)
+
EXTRA_DIST = \
- icalparameter.c.in \
- icalparameter.h.in \
- icalproperty.c.in \
- icalproperty.h.in \
+ icalderivedparameter.c.in \
+ icalderivedparameter.h.in \
+ icalderivedproperty.c.in \
+ icalderivedproperty.h.in \
icalrestriction.c.in \
- icalvalue.c.in \
- icalvalue.h.in \
+ icalderivedvalue.c.in \
+ icalderivedvalue.h.in \
icalversion.h.in \
- $(BUILT_SOURCES) \
icallexer.c \
icalyacc.c
diff --git a/libical/src/libical/icalcomponent.c b/libical/src/libical/icalcomponent.c
index 3ac0ee0663..c28c972007 100644
--- a/libical/src/libical/icalcomponent.c
+++ b/libical/src/libical/icalcomponent.c
@@ -33,6 +33,9 @@
#include "icalmemory.h"
#include "icalenums.h"
#include "icaltime.h"
+#include "icalduration.h"
+#include "icalperiod.h"
+#include "icalparser.h"
#include <stdlib.h> /* for malloc */
#include <stdarg.h> /* for va_list, etc */
@@ -135,17 +138,7 @@ icalcomponent_vanew (icalcomponent_kind kind, ...)
icalcomponent* icalcomponent_new_from_string(char* str)
{
- icalcomponent_kind kind;
-
- icalerror_check_arg_rz( (str!=0), "str");
-
- kind = icalenum_string_to_component_kind(str);
-
- if (kind == ICAL_NO_COMPONENT){
- return 0;
- }
-
- return icalcomponent_new(kind);
+ return icalparser_parse_string(str);
}
icalcomponent* icalcomponent_new_clone(icalcomponent* component)
@@ -156,7 +149,7 @@ icalcomponent* icalcomponent_new_clone(icalcomponent* component)
icalcomponent *c;
pvl_elem itr;
- icalerror_check_arg_rv( (component!=0), "component");
+ icalerror_check_arg_rz( (component!=0), "component");
new = icalcomponent_new_impl(old->kind);
@@ -996,6 +989,78 @@ void icalcomponent_set_parent(icalcomponent* component, icalcomponent* parent)
icalcompiter icalcompiter_null = {ICAL_NO_COMPONENT,0};
+
+struct icalcomponent_kind_map {
+ icalcomponent_kind kind;
+ char name[20];
+};
+
+
+
+static struct icalcomponent_kind_map component_map[] =
+{
+ { ICAL_VEVENT_COMPONENT, "VEVENT" },
+ { ICAL_VTODO_COMPONENT, "VTODO" },
+ { ICAL_VJOURNAL_COMPONENT, "VJOURNAL" },
+ { ICAL_VCALENDAR_COMPONENT, "VCALENDAR" },
+ { ICAL_VFREEBUSY_COMPONENT, "VFREEBUSY" },
+ { ICAL_VTIMEZONE_COMPONENT, "VTIMEZONE" },
+ { ICAL_VALARM_COMPONENT, "VALARM" },
+ { ICAL_XSTANDARD_COMPONENT, "STANDARD" }, /*These are part of RFC2445 */
+ { ICAL_XDAYLIGHT_COMPONENT, "DAYLIGHT" }, /*but are not really components*/
+ { ICAL_X_COMPONENT, "X" },
+ { ICAL_VSCHEDULE_COMPONENT, "SCHEDULE" },
+
+ /* CAP components */
+ { ICAL_VQUERY_COMPONENT, "VQUERY" },
+ { ICAL_VCAR_COMPONENT, "VCAR" },
+ { ICAL_VCOMMAND_COMPONENT, "VCOMMAND" },
+
+ /* libical private components */
+ { ICAL_XLICINVALID_COMPONENT, "X-LIC-UNKNOWN" },
+ { ICAL_XLICMIMEPART_COMPONENT, "X-LIC-MIME-PART" },
+ { ICAL_ANY_COMPONENT, "ANY" },
+ { ICAL_XROOT_COMPONENT, "XROOT" },
+
+ /* End of list */
+ { ICAL_NO_COMPONENT, "" },
+};
+
+
+
+const char* icalcomponent_kind_to_string(icalcomponent_kind kind)
+{
+ int i;
+
+ for (i=0; component_map[i].kind != ICAL_NO_COMPONENT; i++) {
+ if (component_map[i].kind == kind) {
+ return component_map[i].name;
+ }
+ }
+
+ return 0;
+
+}
+
+icalcomponent_kind icalcomponent_string_to_kind(const char* string)
+{
+ int i;
+
+ if (string ==0 ) {
+ return ICAL_NO_COMPONENT;
+ }
+
+ for (i=0; component_map[i].kind != ICAL_NO_COMPONENT; i++) {
+ if (strcmp(component_map[i].name, string) == 0) {
+ return component_map[i].kind;
+ }
+ }
+
+ return ICAL_NO_COMPONENT;
+}
+
+
+
icalcompiter
icalcomponent_begin_component(icalcomponent* component,icalcomponent_kind kind)
{
@@ -1374,9 +1439,6 @@ 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);
@@ -1403,6 +1465,10 @@ icalcomponent* icalcomponent_new_vjournal()
{
return icalcomponent_new(ICAL_VJOURNAL_COMPONENT);
}
+icalcomponent* icalcomponent_new_valarm()
+{
+ return icalcomponent_new(ICAL_VALARM_COMPONENT);
+}
icalcomponent* icalcomponent_new_vfreebusy()
{
return icalcomponent_new(ICAL_VFREEBUSY_COMPONENT);
diff --git a/libical/src/libical/icalcomponent.h b/libical/src/libical/icalcomponent.h
index 61f4bf0dbf..6046bbee1e 100644
--- a/libical/src/libical/icalcomponent.h
+++ b/libical/src/libical/icalcomponent.h
@@ -27,6 +27,7 @@
#include "icalproperty.h"
#include "icalvalue.h"
#include "icalenums.h" /* defines icalcomponent_kind */
+#include "icalattendee.h"
#include "pvl.h"
typedef void icalcomponent;
@@ -75,11 +76,6 @@ icalproperty* icalcomponent_get_first_property(icalcomponent* component,
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
@@ -104,16 +100,8 @@ int icalcomponent_count_components(icalcomponent* component,
/* 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.
+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);
@@ -123,6 +111,15 @@ icalcomponent* icalcomponent_get_first_component(icalcomponent* component,
icalcomponent* icalcomponent_get_next_component(icalcomponent* component,
icalcomponent_kind kind);
+/* Using external iterators */
+icalcompiter icalcomponent_begin_component(icalcomponent* component,
+ icalcomponent_kind kind);
+icalcompiter icalcomponent_end_component(icalcomponent* component,
+ icalcomponent_kind kind);
+icalcomponent* icalcompiter_next(icalcompiter* i);
+icalcomponent* icalcompiter_prior(icalcompiter* i);
+icalcomponent* icalcompiter_deref(icalcompiter* i);
+
@@ -136,14 +133,17 @@ 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... */
+/* Internal operations. They are private, and you should not be using them. */
icalcomponent* icalcomponent_get_parent(icalcomponent* component);
void icalcomponent_set_parent(icalcomponent* component,
icalcomponent* parent);
-/* External component iterator */
-icalcomponent* icalcompiter_next(icalcompiter* i);
-icalcomponent* icalcompiter_prior(icalcompiter* i);
-icalcomponent* icalcompiter_deref(icalcompiter* i);
+
+/* Kind conversion routiens */
+
+icalcomponent_kind icalcomponent_string_to_kind(const char* string);
+
+const char* icalcomponent_kind_to_string(icalcomponent_kind kind);
+
/************* Derived class methods. ****************************
@@ -194,9 +194,6 @@ 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);
@@ -204,12 +201,32 @@ void icalcomponent_set_recurrenceid(icalcomponent* comp,
struct icaltimetype v);
struct icaltimetype icalcomponent_get_recurrenceid(icalcomponent* comp);
+
+void icalcomponent_set_organizer(icalcomponent* comp,
+ struct icalorganizertype org);
+ struct icalorganizertype icalcomponent_get_organizer(icalcomponent* comp);
+
+
+void icalcomponent_add_attendee(icalcomponent *comp,
+ struct icalattendeetype attendee);
+
+int icalcomponent_remove_attendee(icalcomponent *comp, char* cuid);
+
+/* Get the Nth attendee. Out of range indices return an attendee
+ with cuid == 0 */
+struct icalattendeetype icalcomponent_get_attendee(icalcomponent *comp,
+ int index);
+
+
+
+
/*************** Type Specific routines ***************/
icalcomponent* icalcomponent_new_vcalendar();
icalcomponent* icalcomponent_new_vevent();
icalcomponent* icalcomponent_new_vtodo();
icalcomponent* icalcomponent_new_vjournal();
+icalcomponent* icalcomponent_new_valarm();
icalcomponent* icalcomponent_new_vfreebusy();
icalcomponent* icalcomponent_new_vtimezone();
icalcomponent* icalcomponent_new_xstandard();
diff --git a/libical/src/libical/icalenums.c b/libical/src/libical/icalenums.c
index 78ca5d7ebe..6751933c3e 100644
--- a/libical/src/libical/icalenums.c
+++ b/libical/src/libical/icalenums.c
@@ -35,408 +35,6 @@
#include <string.h> /* For strncmp */
#include <assert.h>
-struct icalproperty_kind_map {
- icalproperty_kind kind;
- const char *name;
-};
-
-static struct icalproperty_kind_map property_map[] =
-{
- { ICAL_ANY_PROPERTY, "ANY"},
- { ICAL_ACTION_PROPERTY, "ACTION"},
- { ICAL_ATTACH_PROPERTY, "ATTACH"},
- { ICAL_ATTENDEE_PROPERTY, "ATTENDEE"},
- { ICAL_CALSCALE_PROPERTY, "CALSCALE"},
- { ICAL_CATEGORIES_PROPERTY, "CATEGORIES"},
- { ICAL_CLASS_PROPERTY, "CLASS"},
- { ICAL_COMMENT_PROPERTY, "COMMENT"},
- { ICAL_COMPLETED_PROPERTY, "COMPLETED"},
- { ICAL_CONTACT_PROPERTY, "CONTACT"},
- { ICAL_CREATED_PROPERTY, "CREATED"},
- { ICAL_DESCRIPTION_PROPERTY, "DESCRIPTION"},
- { ICAL_DTEND_PROPERTY, "DTEND"},
- { ICAL_DTSTAMP_PROPERTY, "DTSTAMP"},
- { ICAL_DTSTART_PROPERTY, "DTSTART"},
- { ICAL_DUE_PROPERTY, "DUE"},
- { ICAL_DURATION_PROPERTY, "DURATION"},
- { ICAL_EXDATE_PROPERTY, "EXDATE"},
- { ICAL_EXRULE_PROPERTY, "EXRULE"},
- { ICAL_FREEBUSY_PROPERTY, "FREEBUSY"},
- { ICAL_GEO_PROPERTY, "GEO"},
- { ICAL_LASTMODIFIED_PROPERTY, "LAST-MODIFIED"},
- { ICAL_LOCATION_PROPERTY, "LOCATION"},
- { ICAL_METHOD_PROPERTY, "METHOD"},
- { ICAL_ORGANIZER_PROPERTY, "ORGANIZER"},
- { ICAL_PERCENTCOMPLETE_PROPERTY, "PERCENT-COMPLETE"},
- { ICAL_PRIORITY_PROPERTY, "PRIORITY"},
- { ICAL_PRODID_PROPERTY, "PRODID"},
- { ICAL_RDATE_PROPERTY, "RDATE"},
- { ICAL_RECURRENCEID_PROPERTY, "RECURRENCE-ID"},
- { ICAL_RELATEDTO_PROPERTY, "RELATED-TO"},
- { ICAL_REPEAT_PROPERTY, "REPEAT"},
- { ICAL_REQUESTSTATUS_PROPERTY, "REQUEST-STATUS"},
- { ICAL_RESOURCES_PROPERTY, "RESOURCES"},
- { ICAL_RRULE_PROPERTY, "RRULE"},
- { ICAL_SEQUENCE_PROPERTY, "SEQUENCE"},
- { ICAL_STATUS_PROPERTY, "STATUS"},
- { ICAL_SUMMARY_PROPERTY, "SUMMARY"},
- { ICAL_TRANSP_PROPERTY, "TRANSP"},
- { ICAL_TRIGGER_PROPERTY, "TRIGGER"},
- { ICAL_TZID_PROPERTY, "TZID"},
- { ICAL_TZNAME_PROPERTY, "TZNAME"},
- { ICAL_TZOFFSETFROM_PROPERTY, "TZOFFSETFROM"},
- { ICAL_TZOFFSETTO_PROPERTY, "TZOFFSETTO"},
- { ICAL_TZURL_PROPERTY, "TZURL"},
- { ICAL_UID_PROPERTY, "UID"},
- { ICAL_URL_PROPERTY, "URL"},
- { ICAL_VERSION_PROPERTY, "VERSION"},
- { ICAL_X_PROPERTY,"X_PROPERTY"},
-
- /* CAP Object Properties */
-
- { ICAL_SCOPE_PROPERTY, "SCOPE"},
- { ICAL_MAXRESULTS_PROPERTY, "MAXRESULTS"},
- { ICAL_MAXRESULTSSIZE_PROPERTY, "MAXRESULTSSIZE"},
- { ICAL_QUERY_PROPERTY, "QUERY" },
- { ICAL_QUERYNAME_PROPERTY, "QUERYNAME" },
- { ICAL_TARGET_PROPERTY, "TARGET"},
-
- /* libical private properties */
- { ICAL_XLICERROR_PROPERTY,"X-LIC-ERROR"},
- { ICAL_XLICMIMECONTENTTYPE_PROPERTY,"X-LIC-MIME-CONTENT-TYPE"},
- { ICAL_XLICMIMEENCODING_PROPERTY,"X-LIC-MIME-ENCODING"},
- { ICAL_XLICMIMEOPTINFO_PROPERTY,"X-LIC-MIME-OPT-INFO"},
- { ICAL_XLICMIMECHARSET_PROPERTY,"X-LIC-MIME-CHARSET"},
- { ICAL_XLICCLUSTERCOUNT_PROPERTY,"X-LIC-CLUSTERCOUNT"},
-
- /* End of the list */
- { ICAL_NO_PROPERTY, ""}
-};
-
-
-const char* icalenum_property_kind_to_string(icalproperty_kind kind)
-{
- int i;
-
- for (i=0; property_map[i].kind != ICAL_NO_PROPERTY; i++) {
- if (property_map[i].kind == kind) {
- return property_map[i].name;
- }
- }
-
- return 0;
-
-}
-
-icalproperty_kind icalenum_string_to_property_kind(const char* string)
-{
- int i;
-
- if (string ==0 ) {
- return ICAL_NO_PROPERTY;
- }
-
-
- for (i=0; property_map[i].kind != ICAL_NO_PROPERTY; i++) {
- if (strcmp(property_map[i].name, string) == 0) {
- return property_map[i].kind;
- }
- }
-
- if(strncmp(string,"X-",2)==0){
- return ICAL_X_PROPERTY;
- }
-
-
- return ICAL_NO_PROPERTY;
-}
-
-
-
-
-struct icalparameter_kind_map {
- icalparameter_kind kind;
- char name[20];
-};
-
-static struct icalparameter_kind_map parameter_map[] =
-{
- { ICAL_ALTREP_PARAMETER, "ALTREP"},
- { ICAL_CN_PARAMETER, "CN"},
- { ICAL_CUTYPE_PARAMETER, "CUTYPE"},
- { ICAL_DELEGATEDFROM_PARAMETER, "DELEGATED-FROM"},
- { ICAL_DELEGATEDTO_PARAMETER, "DELEGATED-TO"},
- { ICAL_DIR_PARAMETER, "DIR"},
- { ICAL_ENCODING_PARAMETER, "ENCODING"},
- { ICAL_FBTYPE_PARAMETER, "FBTYPE"},
- { ICAL_FMTTYPE_PARAMETER, "FMTTYPE"},
- { ICAL_LANGUAGE_PARAMETER, "LANGUAGE"},
- { ICAL_MEMBER_PARAMETER, "MEMBER"},
- { ICAL_PARTSTAT_PARAMETER, "PARTSTAT"},
- { ICAL_RANGE_PARAMETER, "RANGE"},
- { ICAL_RELATED_PARAMETER, "RELATED"},
- { ICAL_RELTYPE_PARAMETER, "RELTYPE"},
- { ICAL_ROLE_PARAMETER, "ROLE"},
- { ICAL_RSVP_PARAMETER, "RSVP"},
- { ICAL_SENTBY_PARAMETER, "SENT-BY"},
- { ICAL_TZID_PARAMETER, "TZID"},
- { ICAL_VALUE_PARAMETER, "VALUE"},
- { ICAL_X_PARAMETER, "X"},
-
- /* CAP parameters */
-
- /* libical private parameters */
- { ICAL_XLICERRORTYPE_PARAMETER, "X-LIC-ERRORTYPE"},
- { ICAL_XLICCOMPARETYPE_PARAMETER, "X-LIC-COMPARETYPE"},
-
- /* End of list */
- { ICAL_NO_PARAMETER, ""}
-};
-
-const char* icalenum_parameter_kind_to_string(icalparameter_kind kind)
-{
- int i;
-
- for (i=0; parameter_map[i].kind != ICAL_NO_PARAMETER; i++) {
- if (parameter_map[i].kind == kind) {
- return parameter_map[i].name;
- }
- }
-
- return 0;
-
-}
-
-icalparameter_kind icalenum_string_to_parameter_kind(const char* string)
-{
- int i;
-
- if (string ==0 ) {
- return ICAL_NO_PARAMETER;
- }
-
- for (i=0; parameter_map[i].kind != ICAL_NO_PARAMETER; i++) {
- if (strcmp(parameter_map[i].name, string) == 0) {
- return parameter_map[i].kind;
- }
- }
-
- if(strncmp(string,"X-",2)==0){
- return ICAL_X_PARAMETER;
- }
-
- return ICAL_NO_PARAMETER;
-}
-
-struct icalvalue_kind_map {
- icalvalue_kind kind;
- char name[20];
-};
-
-static struct icalvalue_kind_map value_map[] =
-{
- { ICAL_BINARY_VALUE, "BINARY"},
- { ICAL_BOOLEAN_VALUE, "BOOLEAN"},
- { ICAL_CALADDRESS_VALUE, "CAL-ADDRESS"},
- { ICAL_DATE_VALUE, "DATE"},
- { ICAL_DATETIME_VALUE, "DATE-TIME"},
- { ICAL_DURATION_VALUE, "DURATION"},
- { ICAL_FLOAT_VALUE, "FLOAT"},
- { ICAL_INTEGER_VALUE, "INTEGER"},
- { ICAL_PERIOD_VALUE, "PERIOD"},
- { ICAL_RECUR_VALUE, "RECUR"},
- { ICAL_TEXT_VALUE, "TEXT"},
- { ICAL_TIME_VALUE, "TIME"},
- { 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, "ATTACH"}, /* Not an RFC2445 type */
- { ICAL_DATETIMEDATE_VALUE, "DATETIMEDATE"}, /* Not an RFC2445 type */
- { ICAL_DATETIMEPERIOD_VALUE, "DATETIMEPERIOD"}, /* Not an RFC2445 type */
- { ICAL_TRIGGER_VALUE, "TRIGGER"}, /* Not an RFC2445 type */
- { ICAL_QUERY_VALUE, "QUERY"},
- { ICAL_NO_VALUE, ""},
-};
-
-const char* icalenum_value_kind_to_string(icalvalue_kind kind)
-{
- int i;
-
- for (i=0; value_map[i].kind != ICAL_NO_VALUE; i++) {
- if (value_map[i].kind == kind) {
- return value_map[i].name;
- }
- }
-
- return 0;
-
-}
-
-icalvalue_kind 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;
-}
-
-
-struct icalcomponent_kind_map {
- icalcomponent_kind kind;
- char name[20];
-};
-
-
-
-static struct icalcomponent_kind_map component_map[] =
-{
- { ICAL_VEVENT_COMPONENT, "VEVENT" },
- { ICAL_VTODO_COMPONENT, "VTODO" },
- { ICAL_VJOURNAL_COMPONENT, "VJOURNAL" },
- { ICAL_VCALENDAR_COMPONENT, "VCALENDAR" },
- { ICAL_VFREEBUSY_COMPONENT, "VFREEBUSY" },
- { ICAL_VTIMEZONE_COMPONENT, "VTIMEZONE" },
- { ICAL_VALARM_COMPONENT, "VALARM" },
- { ICAL_XSTANDARD_COMPONENT, "STANDARD" }, /*These are part of RFC2445 */
- { ICAL_XDAYLIGHT_COMPONENT, "DAYLIGHT" }, /*but are not really components*/
- { ICAL_X_COMPONENT, "X" },
- { ICAL_VSCHEDULE_COMPONENT, "SCHEDULE" },
-
- /* CAP components */
- { ICAL_VQUERY_COMPONENT, "VQUERY" },
- { ICAL_VCAR_COMPONENT, "VCAR" },
- { ICAL_VCOMMAND_COMPONENT, "VCOMMAND" },
-
- /* libical private components */
- { ICAL_XLICINVALID_COMPONENT, "X-LIC-UNKNOWN" },
- { ICAL_XLICMIMEPART_COMPONENT, "X-LIC-MIME-PART" },
- { ICAL_ANY_COMPONENT, "ANY" },
- { ICAL_XROOT_COMPONENT, "XROOT" },
-
- /* End of list */
- { ICAL_NO_COMPONENT, "" },
-};
-
-const char* icalenum_component_kind_to_string(icalcomponent_kind kind)
-{
- int i;
-
- for (i=0; component_map[i].kind != ICAL_NO_COMPONENT; i++) {
- if (component_map[i].kind == kind) {
- return component_map[i].name;
- }
- }
-
- return 0;
-
-}
-
-icalcomponent_kind icalenum_string_to_component_kind(const char* string)
-{
- int i;
-
- if (string ==0 ) {
- return ICAL_NO_COMPONENT;
- }
-
- for (i=0; component_map[i].kind != ICAL_NO_COMPONENT; i++) {
- if (strcmp(component_map[i].name, string) == 0) {
- return component_map[i].kind;
- }
- }
-
- return ICAL_NO_COMPONENT;
-}
-
-struct icalproperty_kind_value_map {
- icalproperty_kind prop;
- icalvalue_kind value;
-};
-
-static struct icalproperty_kind_value_map propval_map[] =
-{
- { ICAL_CALSCALE_PROPERTY, ICAL_TEXT_VALUE },
- { ICAL_METHOD_PROPERTY, ICAL_METHOD_VALUE },
- { ICAL_PRODID_PROPERTY, ICAL_TEXT_VALUE },
- { ICAL_VERSION_PROPERTY, ICAL_TEXT_VALUE },
- { ICAL_CATEGORIES_PROPERTY, ICAL_TEXT_VALUE },
- { ICAL_CLASS_PROPERTY, ICAL_TEXT_VALUE },
- { ICAL_COMMENT_PROPERTY, ICAL_TEXT_VALUE },
- { ICAL_DESCRIPTION_PROPERTY, ICAL_TEXT_VALUE },
- { ICAL_LOCATION_PROPERTY, ICAL_TEXT_VALUE },
- { ICAL_PERCENTCOMPLETE_PROPERTY, ICAL_INTEGER_VALUE },
- { ICAL_PRIORITY_PROPERTY, ICAL_INTEGER_VALUE },
- { ICAL_RESOURCES_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 },
- { ICAL_TRANSP_PROPERTY, ICAL_TEXT_VALUE },
- { ICAL_TZNAME_PROPERTY, ICAL_TEXT_VALUE },
- { ICAL_TZOFFSETFROM_PROPERTY, ICAL_UTCOFFSET_VALUE },
- { ICAL_TZOFFSETTO_PROPERTY, ICAL_UTCOFFSET_VALUE },
- { ICAL_TZURL_PROPERTY, ICAL_URI_VALUE },
- { ICAL_TZID_PROPERTY, ICAL_TEXT_VALUE },
- { ICAL_ATTENDEE_PROPERTY, ICAL_CALADDRESS_VALUE },
- { ICAL_CONTACT_PROPERTY, ICAL_TEXT_VALUE },
- { ICAL_ORGANIZER_PROPERTY, ICAL_CALADDRESS_VALUE },
- { ICAL_RELATEDTO_PROPERTY, ICAL_TEXT_VALUE },
- { ICAL_URL_PROPERTY, ICAL_URI_VALUE },
- { ICAL_UID_PROPERTY, ICAL_TEXT_VALUE },
- { ICAL_EXRULE_PROPERTY, ICAL_RECUR_VALUE },
- { ICAL_RRULE_PROPERTY, ICAL_RECUR_VALUE },
- { ICAL_ACTION_PROPERTY, ICAL_TEXT_VALUE },
- { ICAL_REPEAT_PROPERTY, ICAL_INTEGER_VALUE },
- { ICAL_CREATED_PROPERTY, ICAL_DATETIME_VALUE },
- { ICAL_DTSTAMP_PROPERTY, ICAL_DATETIME_VALUE },
- { ICAL_LASTMODIFIED_PROPERTY, ICAL_DATETIME_VALUE },
- { ICAL_SEQUENCE_PROPERTY, ICAL_INTEGER_VALUE },
- { ICAL_X_PROPERTY, ICAL_TEXT_VALUE },
- { ICAL_REQUESTSTATUS_PROPERTY, ICAL_STRING_VALUE },
- { ICAL_ATTACH_PROPERTY, ICAL_URI_VALUE },
- { ICAL_GEO_PROPERTY, ICAL_GEO_VALUE },
- { ICAL_DTEND_PROPERTY, ICAL_DATETIME_VALUE },
- { ICAL_DUE_PROPERTY, ICAL_DATETIME_VALUE },
- { ICAL_DTSTART_PROPERTY, ICAL_DATETIME_VALUE },
- { ICAL_RECURRENCEID_PROPERTY, ICAL_DATETIME_VALUE },
- { ICAL_EXDATE_PROPERTY, ICAL_DATETIME_VALUE },
- { ICAL_RDATE_PROPERTY, ICAL_DATETIME_VALUE },
- { ICAL_TRIGGER_PROPERTY, ICAL_DURATION_VALUE },
- { ICAL_DURATION_PROPERTY, ICAL_DURATION_VALUE },
-
- /* CAP properties */
- { ICAL_SCOPE_PROPERTY, ICAL_TEXT_VALUE },
- { ICAL_MAXRESULTS_PROPERTY, ICAL_INTEGER_VALUE},
- { ICAL_MAXRESULTSSIZE_PROPERTY, ICAL_INTEGER_VALUE},
- { ICAL_QUERY_PROPERTY, ICAL_QUERY_VALUE },
- { ICAL_QUERYNAME_PROPERTY, ICAL_TEXT_VALUE },
- { ICAL_TARGET_PROPERTY, ICAL_CALADDRESS_VALUE },
-
-
- /* libical private properties */
- { ICAL_XLICERROR_PROPERTY,ICAL_TEXT_VALUE},
- { ICAL_XLICCLUSTERCOUNT_PROPERTY,ICAL_INTEGER_VALUE},
-
-
- /* End of list */
- { ICAL_NO_PROPERTY, ICAL_NO_PROPERTY}
-};
-
-
-icalvalue_kind icalenum_property_kind_to_value_kind(icalproperty_kind kind)
-{
- int i;
-
- for (i=0; propval_map[i].value != ICAL_NO_VALUE; i++) {
- if ( propval_map[i].prop == kind ) {
- return propval_map[i].value;
- }
- }
-
- return ICAL_NO_VALUE;
-}
struct {
@@ -535,97 +133,3 @@ icalrequeststatus icalenum_num_to_reqstat(short major, short minor)
-struct {icalproperty_method method; const char* str;} method_map[] = {
- {ICAL_METHOD_PUBLISH,"PUBLISH"},
- {ICAL_METHOD_REQUEST,"REQUEST"},
- {ICAL_METHOD_REPLY,"REPLY"},
- {ICAL_METHOD_ADD,"ADD"},
- {ICAL_METHOD_CANCEL,"CANCEL"},
- {ICAL_METHOD_REFRESH,"REFRESH"},
- {ICAL_METHOD_COUNTER,"COUNTER"},
- {ICAL_METHOD_DECLINECOUNTER,"DECLINECOUNTER"},
- /* CAP Methods */
- {ICAL_METHOD_CREATE,"CREATE"},
- {ICAL_METHOD_READ,"READ"},
- {ICAL_METHOD_RESPONSE,"RESPONSE"},
- {ICAL_METHOD_MOVE,"MOVE"},
- {ICAL_METHOD_MODIFY,"MODIFY"},
- {ICAL_METHOD_GENERATEUID,"GENERATEUID"},
- {ICAL_METHOD_DELETE,"DELETE"},
- {ICAL_METHOD_NONE,"NONE"}
-};
-
-
-const char* icalenum_method_to_string(icalproperty_method method)
-{
- int i;
-
- for (i=0; method_map[i].method != ICAL_METHOD_NONE; i++) {
- if ( method_map[i].method == method) {
- return method_map[i].str;
- }
- }
-
- return method_map[i].str; /* should be ICAL_METHOD_NONE */
-}
-
-icalproperty_method icalenum_string_to_method(const char* str)
-{
- int i;
-
- while(*str == ' '){
- str++;
- }
-
-
- for (i=0; method_map[i].method != ICAL_METHOD_NONE; i++) {
- if ( strcmp(method_map[i].str, str) == 0) {
- return method_map[i].method;
- }
- }
-
- 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 d11547efad..21031dd20e 100644
--- a/libical/src/libical/icalenums.h
+++ b/libical/src/libical/icalenums.h
@@ -63,311 +63,6 @@ typedef enum icalcomponent_kind {
} 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;
/***********************************************************************
@@ -420,27 +115,43 @@ 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(const char* string);
-const char* icalenum_value_kind_to_string(icalvalue_kind kind);
-icalvalue_kind icalenum_value_kind_by_prop(icalproperty_kind kind);
+/* Thse routines used to be in icalenums.c, but were moved into the
+ icalproperty, icalparameter, icalvalue, or icalcomponent modules. */
-const char* icalenum_parameter_kind_to_string(icalparameter_kind kind);
-icalparameter_kind icalenum_string_to_parameter_kind(const char* string);
+/* const char* icalproperty_kind_to_string(icalproperty_kind kind);*/
+#define icalenum_property_kind_to_string(x) icalproperty_kind_to_string(x)
-const char* icalenum_component_kind_to_string(icalcomponent_kind kind);
-icalcomponent_kind icalenum_string_to_component_kind(const char* string);
+/*icalproperty_kind icalproperty_string_to_kind(const char* string)*/
+#define icalenum_string_to_property_kind(x) icalproperty_string_to_kind(x)
-icalvalue_kind icalenum_property_kind_to_value_kind(icalproperty_kind kind);
+/*icalvalue_kind icalproperty_kind_to_value_kind(icalproperty_kind kind);*/
+#define icalenum_property_kind_to_value_kind(x) icalproperty_kind_to_value_kind(x)
-const char* icalenum_method_to_string(icalproperty_method);
-icalproperty_method icalenum_string_to_method(const char* string);
+/*const char* icalenum_method_to_string(icalproperty_method);*/
+#define icalenum_method_to_string(x) icalproperty_method_to_string(x)
-const char* icalenum_status_to_string(icalproperty_status);
-icalproperty_status icalenum_string_to_status(const char* string);
+/*icalproperty_method icalenum_string_to_method(const char* string);*/
+#define icalenum_string_to_method(x) icalproperty_string_to_method(x)
-#endif /* !ICALENUMS_H */
+/*const char* icalenum_status_to_string(icalproperty_status);*/
+#define icalenum_status_to_string(x) icalproperty_status_to_string(x)
+
+/*icalproperty_status icalenum_string_to_status(const char* string);*/
+#define icalenum_string_to_status(x) icalproperty_string_to_status(x)
+/*icalvalue_kind icalenum_string_to_value_kind(const char* str);*/
+#define icalenum_string_to_value_kind(x) icalvalue_string_to_kind(x)
+/*const char* icalenum_value_kind_to_string(icalvalue_kind kind);*/
+#define icalenum_value_kind_to_string(x) icalvalue_kind_to_string(x)
+
+/*const char* icalenum_component_kind_to_string(icalcomponent_kind kind);*/
+#define icalenum_component_kind_to_string(x) icalcomponent_kind_to_string(x)
+
+/*icalcomponent_kind icalenum_string_to_component_kind(const char* string);*/
+#define icalenum_string_to_component_kind(x) icalcomponent_string_to_kind(x)
+
+
+#endif /* !ICALENUMS_H */
diff --git a/libical/src/libical/icalerror.c b/libical/src/libical/icalerror.c
index 13c39dadbc..05191defb9 100644
--- a/libical/src/libical/icalerror.c
+++ b/libical/src/libical/icalerror.c
@@ -59,7 +59,7 @@ int icalerror_errors_are_fatal = 1;
int icalerror_errors_are_fatal = 0;
#endif
-struct icalerror_state {
+struct icalerror_state {
icalerrorenum error;
icalerrorstate state;
};
@@ -72,15 +72,82 @@ struct icalerror_state error_state_map[] =
{ ICAL_PARSE_ERROR,ICAL_ERROR_DEFAULT},
{ ICAL_INTERNAL_ERROR,ICAL_ERROR_DEFAULT},
{ ICAL_FILE_ERROR,ICAL_ERROR_DEFAULT},
- { ICAL_ALLOCATION_ERROR,ICAL_ERROR_DEFAULT},
{ ICAL_USAGE_ERROR,ICAL_ERROR_DEFAULT},
- { ICAL_MULTIPLEINCLUSION_ERROR,ICAL_ERROR_DEFAULT},
- { ICAL_TIMEDOUT_ERROR,ICAL_ERROR_DEFAULT},
+ { ICAL_UNIMPLEMENTED_ERROR,ICAL_ERROR_DEFAULT},
{ ICAL_UNKNOWN_ERROR,ICAL_ERROR_DEFAULT},
{ ICAL_NO_ERROR,ICAL_ERROR_DEFAULT}
};
+struct icalerror_string_map {
+ const char* str;
+ icalerrorenum error;
+ char name[160];
+};
+
+static struct icalerror_string_map string_map[] =
+{
+ {"BADARG",ICAL_BADARG_ERROR,"BADARG: Bad argument to function"},
+ { "NEWFAILED",ICAL_NEWFAILED_ERROR,"NEWFAILED: Failed to create a new object via a *_new() routine"},
+ {"MALFORMEDDATA",ICAL_MALFORMEDDATA_ERROR,"MALFORMEDDATA: An input string was not correctly formed or a component has missing or extra properties"},
+ { "PARSE",ICAL_PARSE_ERROR,"PARSE: Failed to parse a part of an iCal component"},
+ {"INTERNAL",ICAL_INTERNAL_ERROR,"INTERNAL: Random internal error. This indicates an error in the library code, not an error in use"},
+ { "FILE",ICAL_FILE_ERROR,"FILE: An operation on a file failed. Check errno for more detail."},
+ { "USAGE",ICAL_USAGE_ERROR,"USAGE: Failed to propertyl sequence calls to a set of interfaces"},
+ { "UNIMPLEMENTED",ICAL_UNIMPLEMENTED_ERROR,"UNIMPLEMENTED: This feature has not been implemented"},
+ { "NO",ICAL_NO_ERROR,"NO: No error"},
+ {"UNKNOWN",ICAL_UNKNOWN_ERROR,"UNKNOWN: Unknown error type -- icalerror_strerror() was probably given bad input"}
+};
+
+
+icalerrorenum icalerror_error_from_string(const char* str){
+
+ icalerrorenum e;
+ int i = 0;
+
+ for( i = 0; string_map[i].error != ICAL_NO_ERROR; i++){
+ if (strcmp(string_map[i].str,str) == 0){
+ e = string_map[i].error;
+ }
+ }
+
+ return e;
+}
+
+icalerrorstate icalerror_supress(const char* error){
+
+ icalerrorenum e = icalerror_error_from_string(error);
+ icalerrorstate es;
+
+ if (e == ICAL_NO_ERROR){
+ return ICAL_ERROR_UNKNOWN;
+ }
+
+
+ es = icalerror_get_error_state(e);
+ icalerror_set_error_state(e,ICAL_ERROR_NONFATAL);
+
+ return es;
+}
+
+char* icalerror_perror()
+{
+ return icalerror_strerror(icalerrno);
+}
+
+void icalerror_restore(const char* error, icalerrorstate es){
+
+
+ icalerrorenum e = icalerror_error_from_string(error);
+
+ if (e != ICAL_NO_ERROR){
+ icalerror_set_error_state(e,es);
+ }
+
+}
+
+
+
void icalerror_set_error_state( icalerrorenum error,
icalerrorstate state)
{
@@ -107,46 +174,6 @@ icalerrorstate icalerror_get_error_state( icalerrorenum error)
}
-void icalerror_set_errno(icalerrorenum e) {
-
- icalerrorstate es;
-
- icalerrno = e;
- es = icalerror_get_error_state(e);
-
- icalerror_stop_here();
-
- if( (es == ICAL_ERROR_FATAL) ||
- (es == ICAL_ERROR_DEFAULT && icalerror_errors_are_fatal == 1)){
-
- fprintf(stderr,"libical: icalerrno_set_error: %s\n",icalerror_strerror(e));
-#ifdef NDEBUG
- icalerror_crash_here();
-#else
- assert(0);
-#endif
- }
-}
-
-
-struct icalerror_string_map {
- icalerrorenum error;
- char name[160];
-};
-
-static struct icalerror_string_map string_map[] =
-{
- {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 or a component has missing or extra properties"},
- {ICAL_PARSE_ERROR,"Failed to parse a part of an iCal component"},
- {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."},
- {ICAL_ALLOCATION_ERROR,"Failed to allocate memory"},
- {ICAL_USAGE_ERROR,"The caller failed to properly sequence called to an object's interface"},
- {ICAL_NO_ERROR,"No error"},
- {ICAL_UNKNOWN_ERROR,"Unknown error type -- icalerror_strerror() was probably given bad input"}
-};
char* icalerror_strerror(icalerrorenum e) {
diff --git a/libical/src/libical/icalerror.h b/libical/src/libical/icalerror.h
index df71110ecb..790fa90f22 100644
--- a/libical/src/libical/icalerror.h
+++ b/libical/src/libical/icalerror.h
@@ -43,6 +43,64 @@ void icalerror_stop_here(void);
void icalerror_crash_here(void);
+typedef enum icalerrorenum {
+
+ ICAL_BADARG_ERROR,
+ ICAL_NEWFAILED_ERROR,
+ ICAL_ALLOCATION_ERROR,
+ ICAL_MALFORMEDDATA_ERROR,
+ ICAL_PARSE_ERROR,
+ ICAL_INTERNAL_ERROR, /* Like assert --internal consist. prob */
+ ICAL_FILE_ERROR,
+ ICAL_USAGE_ERROR,
+ ICAL_UNIMPLEMENTED_ERROR,
+ ICAL_UNKNOWN_ERROR, /* Used for problems in input to icalerror_strerror()*/
+ ICAL_NO_ERROR
+
+} icalerrorenum;
+
+/* The libical error enumeration, like errno*/
+extern icalerrorenum icalerrno;
+
+/* If true, libicl aborts after a call to icalerror_set_error*/
+extern int icalerror_errors_are_fatal;
+
+/* Warning messages */
+
+#ifdef __GNUC__ca
+#define icalerror_warn(message) {fprintf(stderr,"%s(), %s:%d: %s\n",__FUNCTION__,__FILE__,__LINE__,message);}
+#else /* __GNU_C__ */
+#define icalerror_warn(message) {fprintf(stderr,"%s:%d: %s\n",__FILE__,__LINE__,message);}
+#endif /* __GNU_C__ */
+
+
+void icalerror_clear_errno(void);
+void _icalerror_set_errno(icalerrorenum);
+
+/* Make an individual error fatal or non-fatal. */
+typedef enum icalerrorstate {
+ ICAL_ERROR_FATAL, /* Not fata */
+ ICAL_ERROR_NONFATAL, /* Fatal */
+ ICAL_ERROR_DEFAULT, /* Use the value of icalerror_errors_are_fatal*/
+ ICAL_ERROR_UNKNOWN /* Asked state for an unknown error type */
+} icalerrorstate ;
+
+char* icalerror_strerror(icalerrorenum e);
+char* icalerror_perror();
+void icalerror_set_error_state( icalerrorenum error, icalerrorstate);
+icalerrorstate icalerror_get_error_state( icalerrorenum error);
+
+
+#define icalerror_set_errno(x) \
+icalerrno = x; \
+if(icalerror_get_error_state(x)==ICAL_ERROR_FATAL || \
+ (icalerror_get_error_state(x)==ICAL_ERROR_DEFAULT && \
+ icalerror_errors_are_fatal == 1 )){ \
+ icalerror_warn(icalerror_strerror(x)); \
+ assert(0); \
+}
+
+
#ifdef ICAL_ERRORS_ARE_FATAL
#undef NDEBUG
#endif
@@ -60,82 +118,33 @@ void icalerror_crash_here(void);
#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
+
+#else /* ICAL_ERRORS_ARE_FATAL */
#define icalerror_assert(test,message)
-#endif
+#endif /* ICAL_ERRORS_ARE_FATAL */
/* Check & abort if check fails */
#define icalerror_check_arg(test,arg) if(!(test)) { icalerror_set_errno(ICAL_BADARG_ERROR); }
/* Check & return void if check fails*/
-#define icalerror_check_arg_rv(test,arg) if(!(test)) { icalerror_set_errno(ICAL_BADARG_ERROR); return; }
+#define icalerror_check_arg_rv(test,arg) if(!(test)) {icalerror_set_errno(ICAL_BADARG_ERROR); return; }
/* Check & return 0 if check fails*/
-#define icalerror_check_arg_rz(test,arg) if(!(test)) {icalerror_set_errno(ICAL_BADARG_ERROR); return 0;}
+#define icalerror_check_arg_rz(test,arg) if(!(test)) { icalerror_set_errno(ICAL_BADARG_ERROR); return 0;}
/* Check & return an error if check fails*/
-#define icalerror_check_arg_re(test,arg,error) if(!(test)) {icalerror_stop_here(); return error;}
+#define icalerror_check_arg_re(test,arg,error) if(!(test)) { icalerror_stop_here(); assert(0); return error;}
+/* Check & return something*/
+#define icalerror_check_arg_rx(test,arg,x) if(!(test)) { icalerror_set_errno(ICAL_BADARG_ERROR); return x;}
-/* Warning messages */
-#ifdef ICAL_ERRORS_ARE_FATAL
+/* String interfaces to set an error to NONFATAL and restore it to its
+ original value */
-#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;
-
-/* The libical error enumeration, like errno*/
-extern icalerrorenum icalerrno;
-
-/* If true, libicl aborts after a call to icalerror_set_error*/
-extern int icalerror_errors_are_fatal;
-
-void icalerror_clear_errno(void);
-void icalerror_set_errno(icalerrorenum);
-
-/* Make an individual error fatal or non-fatal. */
-typedef enum icalerrorstate {
- ICAL_ERROR_FATAL, /* Not fata */
- ICAL_ERROR_NONFATAL, /* Fatal */
- ICAL_ERROR_DEFAULT, /* Use the value of icalerror_errors_are_fatal*/
- ICAL_ERROR_UNKNOWN /* Asked state for an unknown error type */
-} icalerrorstate ;
-
-void icalerror_set_error_state( icalerrorenum error, icalerrorstate);
-icalerrorstate icalerror_get_error_state( icalerrorenum error);
-
-char* icalerror_strerror(icalerrorenum e);
+icalerrorstate icalerror_supress(const char* error);
+void icalerror_restore(const char* error, icalerrorstate es);
#endif /* !ICALERROR_H */
diff --git a/libical/src/libical/icallangbind.c b/libical/src/libical/icallangbind.c
index d52f491b93..866eb700cc 100644
--- a/libical/src/libical/icallangbind.c
+++ b/libical/src/libical/icallangbind.c
@@ -18,13 +18,15 @@
======================================================================*/
-#include "ical.h"
+#include "icalcomponent.h"
+#include "icalproperty.h"
+#include "icalerror.h"
+#include "icalmemory.h"
#include <malloc.h>
-
-
+#include <string.h>
int* icallangbind_new_array(int size){
- int* p = malloc(size*sizeof(int));
+ int* p = (int*)malloc(size*sizeof(int));
return p; /* Caller handles failures */
}
@@ -36,136 +38,235 @@ int icallangbind_access_array(int* array, int index) {
return array[index];
}
-/* Return the nth occurrence of 'prop' in c */
-icalproperty* icallangbind_get_property(icalcomponent *c, int n, const char* prop)
-{
- int count;
- icalproperty_kind kind;
- icalproperty *p;
- icalcomponent * comps[3];
- int compno = 0;
- int propno = 0;
- if(c == 0 || prop == 0 || n < 0){
- return 0;
- }
- kind = icalenum_string_to_property_kind(prop);
+/* LIke icalcomponent_get_first_component, buut takes a string for the
+ kind and can iterate over X properties as if each X name was a
+ seperate kind */
+icalproperty* icallangbind_get_first_property(icalcomponent *c,
+ const char* prop)
+{
+ icalproperty_kind kind = icalproperty_string_to_kind(prop);
+ icalproperty *p;
if (kind == ICAL_NO_PROPERTY){
return 0;
}
- comps[0] = c;
- comps[1] = icalcomponent_get_first_real_component(c);
- comps[2] = 0;
-
if(kind == ICAL_X_PROPERTY){
+ for(p = icalcomponent_get_first_property(c,kind);
+ p !=0;
+ p = icalcomponent_get_next_property(c,kind)){
+
+ if(strcmp(icalproperty_get_x_name(p),prop) == 0){
+ return p;
+ }
+ }
+ } else {
+ p=icalcomponent_get_first_property(c,kind);
- for(compno ==0; comps[compno]!=0 ; compno++){
+ return p;
+ }
+
+ return 0;
- for(p = icalcomponent_get_first_property(comps[compno],kind);
- p !=0;
- p = icalcomponent_get_next_property(comps[compno],kind)
- ){
+}
- if(strcmp(icalproperty_get_x_name(p),prop) == 0){
+icalproperty* icallangbind_get_next_property(icalcomponent *c,
+ const char* prop)
+{
+ icalproperty_kind kind = icalenum_string_to_property_kind(prop);
+ icalproperty *p;
- if(propno == n ){
- return p;
- }
-
- propno++;
- }
- }
- }
+ if (kind == ICAL_NO_PROPERTY){
+ return 0;
+ }
+ if(kind == ICAL_X_PROPERTY){
+ for(p = icalcomponent_get_next_property(c,kind);
+ p !=0;
+ p = icalcomponent_get_next_property(c,kind)){
+
+ if(strcmp(icalproperty_get_x_name(p),prop) == 0){
+ return p;
+ }
+ }
} else {
- for(compno ==0; comps[compno]!=0 ; compno++){
-
- for(propno=0,
- p = icalcomponent_get_first_property(comps[compno],kind);
- propno != n && p !=0;
- propno++,
- p = icalcomponent_get_next_property(comps[compno],kind)
- )
- {
- }
-
- if(p != 0){
- return p;
- }
-
- }
+ p=icalcomponent_get_next_property(c,kind);
+
+ return p;
}
return 0;
}
-const char* icallangbind_get_property_val(icalproperty* p)
+
+icalcomponent* icallangbind_get_first_component(icalcomponent *c,
+ const char* comp)
{
- icalvalue *v;
- if (p == 0){
+ icalcomponent_kind kind = icalenum_string_to_component_kind(comp);
+
+ if (kind == ICAL_NO_COMPONENT){
return 0;
}
+ return icalcomponent_get_first_component(c,kind);
+}
- v = icalproperty_get_value(p);
+icalcomponent* icallangbind_get_next_component(icalcomponent *c,
+ const char* comp)
+{
+ icalcomponent_kind kind = icalenum_string_to_component_kind(comp);
- if(v == 0){
- return v;
+ if (kind == ICAL_NO_COMPONENT){
+ return 0;
}
-
- return icalvalue_as_ical_string(v);
-
+ return icalcomponent_get_next_component(c,kind);
}
-const char* icallangbind_get_parameter(icalproperty *p, const char* parameter)
+
+#define APPENDS(x) icalmemory_append_string(&buf, &buf_ptr, &buf_size, x);
+
+#define APPENDC(x) icalmemory_append_char(&buf, &buf_ptr, &buf_size, x);
+
+const char* icallangbind_property_eval_string(icalproperty* prop, char* sep)
{
- icalparameter_kind kind;
+ char tmp[25];
+ size_t buf_size = 1024;
+ char* buf = icalmemory_new_buffer(buf_size);
+ char* buf_ptr = buf;
icalparameter *param;
-
- if(p == 0 || parameter == 0){
- return 0;
- }
- kind = icalenum_string_to_parameter_kind(parameter);
+ icalvalue* value;
- if(kind == ICAL_NO_PARAMETER){
+ if( prop == 0){
return 0;
}
- if(kind == ICAL_X_PARAMETER){
- for(param = icalproperty_get_first_parameter(p,ICAL_X_PARAMETER);
- param != 0;
- param = icalproperty_get_next_parameter(p,ICAL_X_PARAMETER)){
+ APPENDS("{ ");
- if(strcmp(icalparameter_get_xname(param),parameter) ==0){
- return icalparameter_as_ical_string(param);
- }
- }
+ value = icalproperty_get_value(prop);
- } else {
+ APPENDS(" 'name' ");
+ APPENDS(sep);
+ APPENDC('\'');
+ APPENDS(icalenum_property_kind_to_string(icalproperty_isa(prop)));
+ APPENDC('\'');
- param = icalproperty_get_first_parameter(p,kind);
-
- if (param !=0){
- return icalparameter_as_ical_string(param);
- }
+ if(value){
+ APPENDS(", 'value_type' ");
+ APPENDS(sep);
+ APPENDC('\'');
+ APPENDS(icalenum_value_kind_to_string(icalvalue_isa(value)));
+ APPENDC('\'');
+ }
+
+ APPENDS(", 'pid' ");
+ APPENDS(sep);
+ APPENDC('\'');
+ snprintf(tmp,25,"%p",prop);
+ APPENDS(tmp);
+ APPENDC('\'');
+
+
+ if(value){
+ switch (icalvalue_isa(value)){
+ case ICAL_ATTACH_VALUE:
+ case ICAL_BINARY_VALUE:
+ case ICAL_NO_VALUE: {
+ icalerror_set_errno(ICAL_INTERNAL_ERROR);
+ break;
+ }
+
+ default:
+ {
+ const char* str = icalvalue_as_ical_string(value);
+ char* copy = (char*) malloc(strlen(str)+1);
+
+ const char *i;
+ char *j;
+
+ if(copy ==0){
+ icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+ break;
+ }
+ /* Remove any newlines */
+
+ for(j=copy, i = str; *i != 0; j++,i++){
+ if(*i=='\n'){
+ i++;
+ }
+ *j = *i;
+ }
+
+ *j = 0;
+
+ APPENDS(", 'value'");
+ APPENDS(sep);
+ APPENDC('\'');
+ APPENDS(copy);
+ APPENDC('\'');
+
+ free(copy);
+ break;
+
+ }
+ }
}
- return 0;
-}
+ /* Add Parameters */
-icalcomponent* icallangbind_get_component(icalcomponent *c, const char* comp)
-{
- if(c == 0 || comp == 0){
- return 0;
+ for(param = icalproperty_get_first_parameter(prop,ICAL_ANY_PARAMETER);
+ param != 0;
+ param = icalproperty_get_next_parameter(prop,ICAL_ANY_PARAMETER)){
+
+ const char* str = icalparameter_as_ical_string(param);
+ char *copy = icalmemory_tmp_copy(str);
+ char *v;
+
+ if(copy == 0){
+ icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+ continue;
+ }
+
+ v = strchr(copy,'=');
+
+
+ if(v == 0){
+ continue;
+ }
+
+ *v = 0;
+
+ v++;
+
+ APPENDS(", ");
+ APPENDC('\'');
+ APPENDS(copy);
+ APPENDC('\'');
+ APPENDS(sep);
+ APPENDC('\'');
+ APPENDS(v);
+ APPENDC('\'');
+
}
-}
+ APPENDC('}');
+ icalmemory_add_tmp_buffer(buf);
+ return buf;
+}
+
+#include "fcntl.h"
+int icallangbind_string_to_open_flag(const char* str)
+{
+ if (strcmp(str,"r") == 0) {return O_RDONLY;}
+ else if (strcmp(str,"r+") == 0) {return O_RDWR;}
+ else if (strcmp(str,"w") == 0) {return O_WRONLY;}
+ else if (strcmp(str,"a") == 0) {return O_WRONLY|O_APPEND;}
+ else return -1;
+}
diff --git a/libical/src/libical/icalmemory.h b/libical/src/libical/icalmemory.h
index 3ae77024c4..52364e289f 100644
--- a/libical/src/libical/icalmemory.h
+++ b/libical/src/libical/icalmemory.h
@@ -5,7 +5,6 @@
$Id$
-
$Locker$
This program is free software; you can redistribute it and/or modify
@@ -71,7 +70,8 @@ void icalmemory_append_string(char** buf, char** pos, size_t* buf_size,
void icalmemory_append_char(char** buf, char** pos, size_t* buf_size,
char ch);
-/* A wrapper around strdup */
+/* A wrapper around strdup. Partly to trap calls to strdup, partly
+ because in -ansi, gcc on Red Hat claims that strudup is undeclared */
char* icalmemory_strdup(const char *s);
#endif /* !ICALMEMORY_H */
diff --git a/libical/src/libical/icalparser.c b/libical/src/libical/icalparser.c
index 462fd164af..44a302431c 100644
--- a/libical/src/libical/icalparser.c
+++ b/libical/src/libical/icalparser.c
@@ -43,6 +43,7 @@
#include "icalmemory.h"
#include "icalerror.h"
#include "icalvalue.h"
+#include "icalderivedparameter.h"
#include "icalparameter.h"
#include "icalproperty.h"
#include "icalcomponent.h"
@@ -66,17 +67,19 @@ char* icalparser_get_param_name(char* line, char **end);
struct icalparser_impl
{
- int buffer_full;
- size_t tmp_buf_size;
- char temp[TMP_BUF_SIZE];
- icalcomponent *root_component;
- int version;
- int level;
- int lineno;
- icalparser_state state;
- pvl_list components;
-
- void *line_gen_data;
+ int buffer_full; /* flag indicates that temp is smaller that
+ data being read into it*/
+ int continuation_line; /* last line read was a continuation line */
+ size_t tmp_buf_size;
+ char temp[TMP_BUF_SIZE];
+ icalcomponent *root_component;
+ int version;
+ int level;
+ int lineno;
+ icalparser_state state;
+ pvl_list components;
+
+ void *line_gen_data;
};
@@ -410,9 +413,20 @@ char* icalparser_get_line(icalparser *parser,
line_p = line = icalmemory_new_buffer(buf_size);
line[0] = '\0';
+ /* Read lines by calling line_gen_func and putting the data into
+ impl->temp. If the line is a continuation line ( begins with a
+ space after a newline ) then append the data onto line and read
+ again. Otherwise, exit the loop. */
+
while(1) {
- /* The buffer is not clear, so transfer the data in it to the
+ /* The first part of the loop deals with the temp buffer,
+ which was read on he last pass through the loop. The
+ routine is split like this because it has to read lone line
+ ahead to determine if a line is a continuation line. */
+
+
+ /* The tmp buffer is not clear, so transfer the data in it to the
output. This may be left over from a previous call */
if (impl->temp[0] != '\0' ) {
@@ -420,19 +434,37 @@ char* icalparser_get_line(icalparser *parser,
mark the buffer as full. The means we will do another
read later, because the line is not finished */
if (impl->temp[impl->tmp_buf_size-1] == 0 &&
- impl->temp[impl->tmp_buf_size-2] != '\n'){
+ impl->temp[impl->tmp_buf_size-2] != '\n'&&
+ impl->temp[impl->tmp_buf_size-2] != 0 ){
impl->buffer_full = 1;
} else {
impl->buffer_full = 0;
}
/* Copy the temp to the output and clear the temp buffer. */
- icalmemory_append_string(&line,&line_p,&buf_size,impl->temp);
- impl->temp[0] = '\0' ;
+ if(impl->continuation_line==1){
+ /* back up the pointer to erase the continuation characters */
+ impl->continuation_line = 0;
+ line_p--;
+
+ if ( *(line_p-1) == '\r'){
+ line_p--;
+ }
+
+ /* copy one space up to eliminate the leading space*/
+ icalmemory_append_string(&line,&line_p,&buf_size,
+ impl->temp+1);
+
+ } else {
+ icalmemory_append_string(&line,&line_p,&buf_size,impl->temp);
+ }
+
+ impl->temp[0] = '\0' ;
}
impl->temp[impl->tmp_buf_size-1] = 1; /* Mark end of buffer */
+ /****** Here is where the routine gets string data ******************/
if ((*line_gen_func)(impl->temp,impl->tmp_buf_size,impl->line_gen_data)
==0){/* Get more data */
@@ -459,17 +491,7 @@ char* icalparser_get_line(icalparser *parser,
if ( line_p > line+1 && *(line_p-1) == '\n' && impl->temp[0] == ' ') {
- /* back up the pointer to erase the continuation characters */
- line_p--;
-
- if ( *(line_p-1) == '\r'){
- line_p--;
- }
-
- /* shift the temp buffer down to eliminate the leading space*/
- memmove(&(impl->temp[0]),&(impl->temp[1]),impl->tmp_buf_size);
-
- impl->temp[impl->tmp_buf_size-1] = impl->temp[impl->tmp_buf_size-2];
+ impl->continuation_line = 1;
} else if ( impl->buffer_full == 1 ) {
@@ -507,7 +529,7 @@ void insert_error(icalcomponent* comp, char* text,
if (text == 0){
snprintf(temp,1024,"%s:",message);
} else {
- snprintf(temp,1024,"%s: \'%s\'",message,text);
+ snprintf(temp,1024,"%s: %s",message,text);
}
icalcomponent_add_property
@@ -518,6 +540,20 @@ void insert_error(icalcomponent* comp, char* text,
0));
}
+int line_is_blank(char* line){
+ int i=0;
+
+ for(i=0; *(line+i)!=0; i++){
+ char c = *(line+i);
+
+ if(c != ' ' && c != '\n' && c != '\t'){
+ return 0;
+ }
+ }
+
+ return 1;
+}
+
icalcomponent* icalparser_parse(icalparser *parser,
char* (*line_gen_func)(char *s, size_t size,
void* d))
@@ -527,11 +563,14 @@ icalcomponent* icalparser_parse(icalparser *parser,
icalcomponent *c=0;
icalcomponent *root=0;
struct icalparser_impl *impl = (struct icalparser_impl*)parser;
+ icalerrorstate es = icalerror_get_error_state(ICAL_MALFORMEDDATA_ERROR);
icalerror_check_arg_rz((parser !=0),"parser");
+ icalerror_set_error_state(ICAL_MALFORMEDDATA_ERROR,ICAL_ERROR_NONFATAL);
+
do{
- line = icalparser_get_line(parser, line_gen_func);
+ line = icalparser_get_line(parser, line_gen_func);
if ((c = icalparser_add_line(parser,line)) != 0){
@@ -570,10 +609,13 @@ icalcomponent* icalparser_parse(icalparser *parser,
}
} while ( line != 0);
+ icalerror_set_error_state(ICAL_MALFORMEDDATA_ERROR,es);
+
return root;
}
+
icalcomponent* icalparser_add_line(icalparser* parser,
char* line)
{
@@ -582,6 +624,7 @@ icalcomponent* icalparser_add_line(icalparser* parser,
char *end;
int vcount = 0;
icalproperty *prop;
+ icalproperty_kind prop_kind;
icalvalue *value;
icalvalue_kind value_kind = ICAL_NO_VALUE;
@@ -596,6 +639,10 @@ icalcomponent* icalparser_add_line(icalparser* parser,
return 0;
}
+ if(line_is_blank(line) == 1){
+ return 0;
+ }
+
/* Begin by getting the property name at the start of the line. The
property name may end up being "BEGIN" or "END" in which case it
is not really a property, but the marker for the start or end of
@@ -626,11 +673,21 @@ icalcomponent* icalparser_add_line(icalparser* parser,
if(strcmp(str,"BEGIN") == 0){
icalcomponent *c;
+ icalcomponent_kind comp_kind;
impl->level++;
str = icalparser_get_next_value(end,&end, value_kind);
- c = icalcomponent_new_from_string(str);
+
+ comp_kind = icalenum_string_to_component_kind(str);
+
+ if (comp_kind == ICAL_NO_COMPONENT){
+ c = icalcomponent_new(ICAL_XLICINVALID_COMPONENT);
+ insert_error(c,str,"Parse error in component name",
+ ICAL_XLICERRORTYPE_COMPONENTPARSEERROR);
+ }
+
+ c = icalcomponent_new(comp_kind);
if (c == 0){
c = icalcomponent_new(ICAL_XLICINVALID_COMPONENT);
@@ -696,23 +753,29 @@ icalcomponent* icalparser_add_line(icalparser* parser,
/**********************************************************************
* Handle property names
- **********************************************************************/
+ **********************************************************************/
+
/* At this point, the property name really is a property name,
(Not a component name) so make a new property and add it to
the component */
- prop = icalproperty_new_from_string(str);
+
+ prop_kind = icalproperty_string_to_kind(str);
+
+ prop = icalproperty_new(prop_kind);
if (prop != 0){
icalcomponent *tail = pvl_data(pvl_tail(impl->components));
+ if(prop_kind==ICAL_X_PROPERTY){
+ icalproperty_set_x_name(prop,str);
+ }
+
icalcomponent_add_property(tail, prop);
/* Set the value kind for the default for this type of
property. This may be re-set by a VALUE parameter */
- value_kind =
- icalenum_property_kind_to_value_kind(
- icalproperty_isa(prop));
+ value_kind = icalproperty_kind_to_value_kind(icalproperty_isa(prop));
} else {
icalcomponent* tail = pvl_data(pvl_tail(impl->components));
@@ -755,13 +818,13 @@ icalcomponent* icalparser_add_line(icalparser* parser,
if (name == 0){
/* 'tail' defined above */
- insert_error(tail, str, "Can't parse parameter name",
+ insert_error(tail, str, "Cant parse parameter name",
ICAL_XLICERRORTYPE_PARAMETERNAMEPARSEERROR);
tail = 0;
break;
}
- kind = icalenum_string_to_parameter_kind(name);
+ kind = icalparameter_string_to_kind(name);
if(kind == ICAL_X_PARAMETER){
param = icalparameter_new(ICAL_X_PARAMETER);
@@ -773,11 +836,11 @@ icalcomponent* icalparser_add_line(icalparser* parser,
} else if (kind != ICAL_NO_PARAMETER){
- param = icalparameter_new_from_string(kind,pvalue);
+ param = icalparameter_new_from_value_string(kind,pvalue);
} else {
/* Error. Failed to parse the parameter*/
/* 'tail' defined above */
- insert_error(tail, str, "Can't parse parameter name",
+ insert_error(tail, str, "Cant parse parameter name",
ICAL_XLICERRORTYPE_PARAMETERNAMEPARSEERROR);
tail = 0;
impl->state = ICALPARSER_ERROR;
@@ -786,7 +849,7 @@ icalcomponent* icalparser_add_line(icalparser* parser,
if (param == 0){
/* 'tail' defined above */
- insert_error(tail,str,"Can't parse parameter value",
+ insert_error(tail,str,"Cant parse parameter value",
ICAL_XLICERRORTYPE_PARAMETERVALUEPARSEERROR);
tail = 0;
@@ -798,7 +861,9 @@ icalcomponent* icalparser_add_line(icalparser* parser,
if (icalparameter_isa(param)==ICAL_VALUE_PARAMETER){
value_kind = (icalvalue_kind)
- icalparameter_get_value(param);
+ icalparameter_value_to_value_kind(
+ icalparameter_get_value(param)
+ );
if (value_kind == ICAL_NO_VALUE){
@@ -813,7 +878,7 @@ icalcomponent* icalparser_add_line(icalparser* parser,
icalparameter_free(param);
value_kind =
- icalenum_property_kind_to_value_kind(
+ icalproperty_kind_to_value_kind(
icalproperty_isa(prop));
icalparameter_free(param);
@@ -868,9 +933,9 @@ icalcomponent* icalparser_add_line(icalparser* parser,
icalproperty_kind prop_kind = icalproperty_isa(prop);
icalcomponent* tail = pvl_data(pvl_tail(impl->components));
- sprintf(temp,"Can't parse as %s value in %s property. Removing entire property",
- icalenum_value_kind_to_string(value_kind),
- icalenum_property_kind_to_string(prop_kind));
+ sprintf(temp,"Cant parse as %s value in %s property. Removing entire property",
+ icalvalue_kind_to_string(value_kind),
+ icalproperty_kind_to_string(prop_kind));
insert_error(tail, str, temp,
ICAL_XLICERRORTYPE_VALUEPARSEERROR);
@@ -897,7 +962,7 @@ icalcomponent* icalparser_add_line(icalparser* parser,
icalcomponent *tail = pvl_data(pvl_tail(impl->components));
sprintf(temp,"No value for %s property. Removing entire property",
- icalenum_property_kind_to_string(prop_kind));
+ icalproperty_kind_to_string(prop_kind));
insert_error(tail, str, temp,
ICAL_XLICERRORTYPE_VALUEPARSEERROR);
@@ -975,8 +1040,8 @@ icalcomponent* icalparser_clean(icalparser* parser)
}
struct slg_data {
- char* pos;
- char* str;
+ const char* pos;
+ const char* str;
};
char* string_line_generator(char *out, size_t buf_size, void *d)
@@ -1017,18 +1082,26 @@ char* string_line_generator(char *out, size_t buf_size, void *d)
return out;
}
-icalcomponent* icalparser_parse_string(char* str)
+icalcomponent* icalparser_parse_string(const char* str)
{
icalcomponent *c;
struct slg_data d;
icalparser *p;
+ icalerrorstate es = icalerror_get_error_state(ICAL_PARSE_ERROR);
+
d.pos = 0;
d.str = str;
p = icalparser_new();
icalparser_set_gen_data(p,&d);
+
+ icalerror_set_error_state(ICAL_PARSE_ERROR,ICAL_ERROR_NONFATAL);
+
c = icalparser_parse(p,string_line_generator);
+
+ icalerror_set_error_state(ICAL_PARSE_ERROR,es);
+
icalparser_free(p);
return c;
diff --git a/libical/src/libical/icalparser.h b/libical/src/libical/icalparser.h
index efbe86eb21..5e1c88ffc0 100644
--- a/libical/src/libical/icalparser.h
+++ b/libical/src/libical/icalparser.h
@@ -74,7 +74,7 @@ icalcomponent* icalparser_parse(icalparser *parser,
void icalparser_set_gen_data(icalparser* parser, void* data);
-icalcomponent* icalparser_parse_string(char* str);
+icalcomponent* icalparser_parse_string(const char* str);
/***********************************************************************
diff --git a/libical/src/libical/icalrecur.c b/libical/src/libical/icalrecur.c
index d5c73e80dd..51fdf63a79 100644
--- a/libical/src/libical/icalrecur.c
+++ b/libical/src/libical/icalrecur.c
@@ -99,26 +99,29 @@
larger time span than the interval. For instance, if
INTERVAL=DAILY, BYMONTH is a contracting rule part.
- Check_contracting_rules() uses check_restriction() to do its
- work. Check_restriction() uses expand_map[] to determine if a rule
+ Check_contracting_rules() uses icalrecur_check_rulepart() to do its
+ work. icalrecur_check_rulepart() uses expand_map[] to determine if a rule
is contracting, and if it is, and if the BY rule part has some data,
then the routine checks if the value of a component of the time is
part of the byrule part. For instance, for "INTERVAL=DAILY;
- BYMONTH=6,10", check_restriction() would check that the time value
+ BYMONTH=6,10", icalrecur_check_rulepart() would check that the time value
given to it has a month of either 6 or 10.
- icalrecurrencetype_test()
Finally, icalrecur_iterator_next() does a few other checks on the
time value, and if it passes, it returns the time.
- A note about the end_of_data flag. This flag is usually set early in
- a next_* routine and returned in the end. The way it is used allows
- the next_* routine to set the last time back to the first element in
- a BYxx rule, and then signal to the higer level routine to increment
- the next higher level. For instance. WITH FREQ=MONTHLY;BYDAY=TU,FR,
- After next_weekday_by_month runs though both TU and FR, it sets the
- week day back to TU and sets end_of_data. This signals next_month to
- increment the month.
+ A note about the end_of_data flag. The flag indicates that the
+ routine is at the end of its data -- the last BY rule if the routine
+ is using by rules, or the last day of the week/month/year/etc if
+ not.
+
+ This flag is usually set early in a next_* routine and returned in
+ the end. The way it is used allows the next_* routine to set the
+ last time back to the first element in a BYxx rule, and then signal
+ to the higer level routine to increment the next higher level. For
+ instance. WITH FREQ=MONTHLY;BYDAY=TU,FR, After next_weekday_by_month
+ runs though both TU and FR, it sets the week day back to TU and sets
+ end_of_data to 1x. This signals next_month to increment the month.
======================================================================*/
@@ -143,9 +146,31 @@
#include <assert.h>
#include <stddef.h> /* For offsetof() macro */
+#include "pvl.h"
+
#define TEMP_MAX 1024
+#define BYDAYIDX impl->by_indices[BY_DAY]
+#define BYDAYPTR impl->by_ptrs[BY_DAY]
+
+#define BYMONIDX impl->by_indices[BY_MONTH]
+#define BYMONPTR impl->by_ptrs[BY_MONTH]
+
+#define BYMDIDX impl->by_indices[BY_MONTH_DAY]
+#define BYMDPTR impl->by_ptrs[BY_MONTH_DAY]
+
+#define BYWEEKIDX impl->by_indices[BY_WEEK_NO]
+#define BYWEEKPTR impl->by_ptrs[BY_WEEK_NO]
+
+const char* icalrecur_freq_to_string(icalrecurrencetype_frequency kind);
+icalrecurrencetype_frequency icalrecur_string_to_freq(const char* str);
+
+const char* icalrecur_weekday_to_string(icalrecurrencetype_weekday kind);
+icalrecurrencetype_weekday icalrecur_string_to_weekday(const char* str);
+
+
+
/*********************** Rule parsing routines ************************/
struct icalrecur_parser {
@@ -250,10 +275,10 @@ void icalrecur_add_byrules(struct icalrecur_parser *parser, short *array,
/* Get optional sign. HACK. sign is not allowed for all BYxxx
rule parts */
if( *t == '-'){
- sign = 1;
+ sign = -1;
t++;
} else if (*t == '+'){
- sign = -1;
+ sign = 1;
t++;
}
@@ -279,7 +304,7 @@ void icalrecur_add_bydayrules(struct icalrecur_parser *parser, const char* vals)
char* end;
char* vals_copy;
- vals_copy = strdup(vals);
+ vals_copy = icalmemory_strdup(vals);
end = (char*)vals_copy+strlen(vals_copy);
n = vals_copy;
@@ -343,7 +368,7 @@ struct icalrecurrencetype icalrecurrencetype_from_string(const char* str)
/* Set up the parser struct */
parser.rule = str;
- parser.copy = strdup(parser.rule);
+ parser.copy = icalmemory_strdup(parser.rule);
parser.this_clause = parser.copy;
if(parser.copy == 0){
@@ -366,7 +391,7 @@ struct icalrecurrencetype icalrecurrencetype_from_string(const char* str)
}
if (strcmp(name,"FREQ") == 0){
- parser.rt.freq = icalrecur_string_to_recurrence(value);
+ parser.rt.freq = icalrecur_string_to_freq(value);
} else if (strcmp(name,"COUNT") == 0){
parser.rt.count = atoi(value);
} else if (strcmp(name,"UNTIL") == 0){
@@ -451,7 +476,7 @@ char* icalrecurrencetype_as_string(struct icalrecurrencetype *recur)
icalmemory_append_string(&str,&str_p,&buf_sz,"FREQ=");
icalmemory_append_string(&str,&str_p,&buf_sz,
- icalrecur_recurrence_to_string(recur->freq));
+ icalrecur_freq_to_string(recur->freq));
if(recur->until.year != 0){
@@ -493,7 +518,7 @@ char* icalrecurrencetype_as_string(struct icalrecurrencetype *recur)
pos = icalrecurrencetype_day_position(array[i]);
- if (pos == 1)
+ if (pos == 0)
icalmemory_append_string(&str,&str_p,&buf_sz,daystr);
else {
sprintf(temp,"%d%s",pos,daystr);
@@ -538,20 +563,21 @@ enum byrule {
struct icalrecur_iterator_impl {
- struct icaltimetype dtstart; /* Hack. Make into time_t */
- struct icaltimetype last; /* last time return from _iterator_next*/
- int occurrence_no; /* number of step made on t iterator */
- struct icalrecurrencetype rule;
-
- short days[366];
- short days_index;
-
- enum byrule byrule;
- short by_indices[9];
- short orig_data[9]; /* 1 if there was data in the byrule */
-
-
- short *by_ptrs[9]; /* Pointers into the by_* array elements of the rule */
+ struct icaltimetype dtstart; /* Hack. Make into time_t */
+ struct icaltimetype last; /* last time return from _iterator_next*/
+ int occurrence_no; /* number of step made on t iterator */
+ struct icalrecurrencetype rule;
+
+ short days[366];
+ short days_index;
+
+ enum byrule byrule;
+ short by_indices[9];
+ short orig_data[9]; /* 1 if there was data in the byrule */
+
+
+ short *by_ptrs[9]; /* Pointers into the by_* array elements of the rule */
+
};
int icalrecur_iterator_sizeof_byarray(short* byarray)
@@ -689,20 +715,23 @@ void setup_defaults(struct icalrecur_iterator_impl* impl,
}
-int expand_year_days(struct icalrecur_iterator_impl* impl,short year);
-
int has_by_data(struct icalrecur_iterator_impl* impl, enum byrule byrule){
return (impl->orig_data[byrule] == 1);
}
+int expand_year_days(struct icalrecur_iterator_impl* impl,short year);
+
+
icalrecur_iterator* icalrecur_iterator_new(struct icalrecurrencetype rule,
struct icaltimetype dtstart)
{
struct icalrecur_iterator_impl* impl;
icalrecurrencetype_frequency freq;
+ short days_in_month;
+
if ( ( impl = (struct icalrecur_iterator_impl *)
malloc(sizeof(struct icalrecur_iterator_impl))) == 0) {
icalerror_set_errno(ICAL_NEWFAILED_ERROR);
@@ -733,6 +762,11 @@ icalrecur_iterator* icalrecur_iterator_new(struct icalrecurrencetype rule,
memset(impl->orig_data,0,9);
+ /* Note which by rules had data in them when the iterator was
+ created. We can't use the actuall by_x arrays, because the
+ empty ones will be given default values later in this
+ routine. The orig_data array will be used later in has_by_data */
+
impl->orig_data[BY_MONTH]
= (impl->rule.by_month[0]!=ICAL_RECURRENCE_ARRAY_MAX);
impl->orig_data[BY_WEEK_NO]
@@ -762,7 +796,7 @@ icalrecur_iterator* icalrecur_iterator_new(struct icalrecurrencetype rule,
icalrecur_two_byrule(impl,BY_YEAR_DAY,BY_MONTH_DAY) ||
icalrecur_two_byrule(impl,BY_YEAR_DAY,BY_DAY) ){
- icalerror_set_errno(ICAL_USAGE_ERROR);
+ icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
return 0;
}
@@ -770,18 +804,18 @@ icalrecur_iterator* icalrecur_iterator_new(struct icalrecurrencetype rule,
/* BYWEEKNO and BYMONTH rule parts may not both appear.*/
if(icalrecur_two_byrule(impl,BY_WEEK_NO,BY_MONTH)){
- icalerror_set_errno(ICAL_USAGE_ERROR);
+ icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
- icalerror_set_errno(ICAL_USAGE_ERROR);
+ icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
return 0;
}
/* BYWEEKNO and BYMONTHDAY rule parts may not both appear.*/
if(icalrecur_two_byrule(impl,BY_WEEK_NO,BY_MONTH_DAY)){
- icalerror_set_errno(ICAL_USAGE_ERROR);
+ icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
- icalerror_set_errno(ICAL_USAGE_ERROR);
+ icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
return 0;
}
@@ -790,10 +824,8 @@ icalrecur_iterator* icalrecur_iterator_new(struct icalrecurrencetype rule,
BYWEEKNO may appear. */
if(freq == ICAL_MONTHLY_RECURRENCE &&
- ( icalrecur_one_byrule(impl,BY_WEEK_NO) ||
- icalrecur_one_byrule(impl,BY_YEAR_DAY)) ) {
-
- icalerror_set_errno(ICAL_USAGE_ERROR);
+ icalrecur_one_byrule(impl,BY_WEEK_NO)){
+ icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
return 0;
}
@@ -802,13 +834,17 @@ icalrecur_iterator* icalrecur_iterator_new(struct icalrecurrencetype rule,
BYYEARDAY may appear. */
if(freq == ICAL_WEEKLY_RECURRENCE &&
- ( icalrecur_one_byrule(impl,BY_MONTH_DAY) ||
- icalrecur_one_byrule(impl,BY_YEAR_DAY)) ) {
-
- icalerror_set_errno(ICAL_USAGE_ERROR);
+ icalrecur_one_byrule(impl,BY_MONTH_DAY )) {
+ icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
return 0;
}
+ /* BYYEARDAY may only appear in YEARLY rules */
+ if(freq != ICAL_YEARLY_RECURRENCE &&
+ icalrecur_one_byrule(impl,BY_YEAR_DAY )) {
+ icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+ return 0;
+ }
/* Rewrite some of the rules and set up defaults to make later
processing easier. Primarily, t involves copying an element
@@ -831,6 +867,7 @@ icalrecur_iterator* icalrecur_iterator_new(struct icalrecurrencetype rule,
setup_defaults(impl,BY_MONTH,ICAL_MONTHLY_RECURRENCE,impl->dtstart.month,
&(impl->last.month));
+
if(impl->rule.freq == ICAL_WEEKLY_RECURRENCE ){
if(impl->by_ptrs[BY_DAY][0] == ICAL_RECURRENCE_ARRAY_MAX){
@@ -841,7 +878,7 @@ icalrecur_iterator* icalrecur_iterator_new(struct icalrecurrencetype rule,
} else {
/* If there is BY_DAY data, then we need to move the initial
- time to the start of the BY_DAY data. That if if the
+ time to the start of the BY_DAY data. That is if the
start time is on a Wednesday, and the rule has
BYDAY=MO,WE,FR, move the initial time back to
monday. Otherwise, jumping to the next week ( jumping 7
@@ -864,10 +901,11 @@ icalrecur_iterator* icalrecur_iterator_new(struct icalrecurrencetype rule,
}
+ /* For YEARLY rule, begin by setting up the year days array */
if(impl->rule.freq == ICAL_YEARLY_RECURRENCE){
- expand_year_days(impl,impl->dtstart.year);
- }
+ expand_year_days(impl,impl->last.year);
+ }
/* If this is a monthly interval with by day data, then we need to
@@ -882,28 +920,49 @@ icalrecur_iterator* icalrecur_iterator_new(struct icalrecurrencetype rule,
impl->by_ptrs[BY_DAY][impl->by_indices[BY_DAY]]);
short poscount = 0;
- short days_in_month =
- icaltime_days_in_month(impl->last.month, impl->last.year) ;
+ days_in_month =
+ icaltime_days_in_month(impl->last.month, impl->last.year);
- for(impl->last.day = 1;
- impl->last.day <= days_in_month;
- impl->last.day++){
-
- if(icaltime_day_of_week(impl->last) == dow){
- if(++poscount == pos){
- break;
- }
- }
- }
+ if(pos >= 0){
+ /* Count up from the first day pf the month to find the
+ pos'th weekday of dow ( like the second monday. ) */
+
+ for(impl->last.day = 1;
+ impl->last.day <= days_in_month;
+ impl->last.day++){
+
+ if(icaltime_day_of_week(impl->last) == dow){
+ if(++poscount == pos || pos == 0){
+ break;
+ }
+ }
+ }
+ } else {
+ /* Count down from the last day pf the month to find the
+ pos'th weekday of dow ( like the second to last monday. ) */
+ pos = -pos;
+ for(impl->last.day = days_in_month;
+ impl->last.day != 0;
+ impl->last.day--){
+
+ if(icaltime_day_of_week(impl->last) == dow){
+ if(++poscount == pos ){
+ break;
+ }
+ }
+ }
+ }
+
- if(impl->last.day > days_in_month){
- icalerror_set_errno(ICAL_USAGE_ERROR);
+ if(impl->last.day > days_in_month || impl->last.day == 0){
+ icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
return 0;
}
}
+
return impl;
}
@@ -921,34 +980,59 @@ void icalrecur_iterator_free(icalrecur_iterator* i)
}
-
-
void increment_year(struct icalrecur_iterator_impl* impl, int inc)
{
impl->last.year+=inc;
}
-
-
-
-void increment_month(struct icalrecur_iterator_impl* impl, int inc)
+/* Increment month is different that the other incement_* routines --
+ it figures out the interval for itself, and uses BYMONTH data if
+ available. */
+void increment_month(struct icalrecur_iterator_impl* impl)
{
int years;
- impl->last.month+=inc;
-
- /* Months are offset by one */
- impl->last.month--;
-
- years = impl->last.month / 12;
-
- impl->last.month = impl->last.month % 12;
-
- impl->last.month++;
-
- if (years != 0){
- increment_year(impl,years);
- }
+ if(has_by_data(impl,BY_MONTH) ){
+ /* Ignore the frequency and use the byrule data */
+
+ impl->by_indices[BY_MONTH]++;
+
+ if (impl->by_ptrs[BY_MONTH][impl->by_indices[BY_MONTH]]
+ ==ICAL_RECURRENCE_ARRAY_MAX){
+ impl->by_indices[BY_MONTH] = 0;
+
+ increment_year(impl,1);
+
+ }
+
+ impl->last.month =
+ impl->by_ptrs[BY_MONTH][impl->by_indices[BY_MONTH]];
+
+ } else {
+
+ int inc;
+
+ if(impl->rule.freq == ICAL_MONTHLY_RECURRENCE){
+ inc = impl->rule.interval;
+ } else {
+ inc = 1;
+ }
+
+ impl->last.month+=inc;
+
+ /* Months are offset by one */
+ impl->last.month--;
+
+ years = impl->last.month / 12;
+
+ impl->last.month = impl->last.month % 12;
+
+ impl->last.month++;
+
+ if (years != 0){
+ increment_year(impl,years);
+ }
+ }
}
void increment_monthday(struct icalrecur_iterator_impl* impl, int inc)
@@ -964,7 +1048,7 @@ void increment_monthday(struct icalrecur_iterator_impl* impl, int inc)
if (impl->last.day > days_in_month){
impl->last.day = impl->last.day-days_in_month;
- increment_month(impl,1);
+ increment_month(impl);
}
}
}
@@ -1211,46 +1295,6 @@ int next_day(struct icalrecur_iterator_impl* impl)
}
-/* This routine is only called by next_month and next_year, so it does
- not have a clause for this_frequency */
-int next_monthday(struct icalrecur_iterator_impl* impl)
-{
-
- short has_by_data = (impl->by_ptrs[BY_MONTH_DAY][0]!=ICAL_RECURRENCE_ARRAY_MAX);
- short mday;
- short end_of_data = 0;
-
- assert(has_by_data );
-
- if (next_hour(impl) == 0){
- return 0;
- }
-
- impl->by_indices[BY_MONTH_DAY]++;
-
- mday = impl->by_ptrs[BY_MONTH_DAY][impl->by_indices[BY_MONTH_DAY]];
-
- if ( mday ==ICAL_RECURRENCE_ARRAY_MAX){
- impl->by_indices[BY_MONTH_DAY] = 0;
-
- end_of_data = 1;
- }
-
- if (mday > 0){
- impl->last.day = mday;
- } else {
- short days_in_month = icaltime_days_in_month(impl->last.month,
- impl->last.year);
- impl->last.day = days_in_month-mday+1;
- }
-
- if(has_by_data && end_of_data ){
- increment_month(impl,1);
- }
-
- return end_of_data;
-
-}
int next_yearday(struct icalrecur_iterator_impl* impl)
{
@@ -1336,143 +1380,185 @@ int next_weekday_by_week(struct icalrecur_iterator_impl* impl)
}
-int next_weekday_by_month(struct icalrecur_iterator_impl* impl)
-{
+int nth_weekday(short dow, short pos, struct icaltimetype t){
- short end_of_data = 0;
- struct icaltimetype start_of_month; /* Start of month */
- short pos, poscount, dow, days_in_month;
+ short days_in_month = icaltime_days_in_month(t.month,t.year);
+ short end_dow, start_dow;
+ short wd;
- if (next_hour(impl) == 0){
- return 0;
- }
+ if(pos >= 0){
+ t.day = 1;
+ start_dow = icaltime_day_of_week(t);
+
+ if (pos != 0) {
+ pos--;
+ }
+
+ /* find month day of first occurrence of dow -- such as the
+ month day of the first monday */
- assert( impl->by_ptrs[BY_DAY][0]!=ICAL_RECURRENCE_ARRAY_MAX);
+ wd = dow-start_dow+1;
- while(1) {
- impl->by_indices[BY_DAY]++; /* Look at next elem in BYDAY array */
-
- /* Are we at the end of the BYDAY array? */
- if (impl->by_ptrs[BY_DAY][impl->by_indices[BY_DAY]]
- ==ICAL_RECURRENCE_ARRAY_MAX){
-
- impl->by_indices[BY_DAY] = 0; /* Reset to 0 */
- end_of_data = 1; /* Signal that we're at the end */
- }
-
- dow = icalrecurrencetype_day_day_of_week(
- impl->by_ptrs[BY_DAY][impl->by_indices[BY_DAY]]);
- pos = icalrecurrencetype_day_position(
- impl->by_ptrs[BY_DAY][impl->by_indices[BY_DAY]]);
+ if (wd <= 0){
+ wd = wd + 7;
+ }
- start_of_month = impl->last;
+ wd = wd + pos * 7;
+
+ } else {
+ t.day = days_in_month;
+ end_dow = icaltime_day_of_week(t);
- /* Find right day in month. HACK. Find an arithmetic way to do
- this */
+ pos++;
- poscount = 0;
- days_in_month =
- icaltime_days_in_month(impl->last.month, impl->last.year) ;
+ /* find month day of last occurrence of dow -- such as the
+ month day of the last monday */
- for(start_of_month.day = 1;
- start_of_month.day <= days_in_month;
- start_of_month.day++){
+ wd = (end_dow - dow);
- if(icaltime_day_of_week(start_of_month) == dow){
- if(++poscount == pos){
- break;
- }
- }
- }
+ if (wd < 0){
+ wd = wd+ 7;
+ }
- if (!end_of_data == 1 &&
- (
- start_of_month.day > days_in_month ||
- icaltime_compare(start_of_month,impl->last) <= 0
- )
- ){
- continue;
- }
+ wd = days_in_month - wd;
- impl->last.day = start_of_month.day;
- impl->last.month = start_of_month.month;
- impl->last.year = start_of_month.year;
-
- return end_of_data;
- }
+ wd = wd + pos * 7;
+ }
+
+ return wd;
}
+
int next_month(struct icalrecur_iterator_impl* impl)
{
+ int data_valid = 1;
+
+ short this_frequency = (impl->rule.freq == ICAL_MONTHLY_RECURRENCE);
+
+ assert( has_by_data(impl,BY_MONTH) || this_frequency);
+
+ /* Iterate through the occurrences within a day. If we don't get to
+ the end of the intra-day data, don't bother going to the next
+ month */
+
+ if (next_hour(impl) == 0){
+ return data_valid; /* Signal that the data is valid */
+ }
+
+
+ /* Now iterate through the occurrences within a month -- by days,
+ weeks or weekdays. */
+
+ if(has_by_data(impl,BY_DAY) && has_by_data(impl,BY_MONTH_DAY)){
+ /* Cases like: FREQ=MONTHLY;INTERVAL=1;BYDAY=FR;BYMONTHDAY=13 */
+ short day, idx,j;
+ short days_in_month = icaltime_days_in_month(impl->last.month,
+ impl->last.year);
+ /* Iterate through the remaining days in the month and check if
+ each day is listed in the BY_DAY array and in the BY_MONTHDAY
+ array. This seems very inneficient, but I think it is the
+ simplest way to account for both BYDAY=1FR (First friday in
+ month) and BYDAY=FR ( every friday in month ) */
+
+ for(day = impl->last.day+1; day <= days_in_month; day++){
+ for(idx = 0; BYDAYPTR[idx] != ICAL_RECURRENCE_ARRAY_MAX; idx++){
+ for(j = 0; BYMDPTR[j]!=ICAL_RECURRENCE_ARRAY_MAX; j++){
+ short dow =
+ icalrecurrencetype_day_day_of_week(BYDAYPTR[idx]);
+ short pos = icalrecurrencetype_day_position(BYDAYPTR[idx]);
+ short mday = BYMDPTR[j];
+ short this_dow;
+
+ impl->last.day = day;
+ this_dow = icaltime_day_of_week(impl->last);
+
+ if( (pos == 0 && dow == this_dow && mday == day) ||
+ (nth_weekday(dow,pos,impl->last) == day && mday==day)){
+ goto MDEND;
+ }
+ }
+ }
+ }
- short this_frequency = (impl->rule.freq == ICAL_MONTHLY_RECURRENCE);
-
- short end_of_data = 0;
+ MDEND:
- assert( has_by_data(impl,BY_MONTH) || this_frequency);
+ if ( day > days_in_month){
+ impl->last.day = 1;
+ increment_month(impl);
+ data_valid = 0; /* signal that impl->last is invalid */
+ }
- /* Week day data overrides monthday data */
- if(has_by_data(impl,BY_DAY)){
+
+ } else if(has_by_data(impl,BY_DAY)){
+ /* Cases like: FREQ=MONTHLY;INTERVAL=1;BYDAY=FR */
/* For this case, the weekdays are relative to the
month. BYDAY=FR -> First Friday in month, etc. */
- if (next_weekday_by_month(impl) == 0){
- return 0;
- }
- } else {
- if (next_monthday(impl) == 0){
- return 0;
- }
- }
-
- if(has_by_data(impl,BY_MONTH) ){
- /* Ignore the frequency and use the byrule data */
-
- impl->by_indices[BY_MONTH]++;
-
- if (impl->by_ptrs[BY_MONTH][impl->by_indices[BY_MONTH]]
- ==ICAL_RECURRENCE_ARRAY_MAX){
- impl->by_indices[BY_MONTH] = 0;
-
- end_of_data = 1;
+ short day, idx;
+ short days_in_month = icaltime_days_in_month(impl->last.month,
+ impl->last.year);
+
+ assert( BYDAYPTR[0]!=ICAL_RECURRENCE_ARRAY_MAX);
+
+ /* Iterate through the remaining days in the month and check if
+ each day is listed in the BY_DAY array. This seems very
+ inneficient, but I think it is the simplest way to account
+ for both BYDAY=1FR (First friday in month) and BYDAY=FR (
+ every friday in month ) */
+
+ for(day = impl->last.day+1; day <= days_in_month; day++){
+ for(idx = 0; BYDAYPTR[idx] != ICAL_RECURRENCE_ARRAY_MAX; idx++){
+ short dow = icalrecurrencetype_day_day_of_week(BYDAYPTR[idx]);
+ short pos = icalrecurrencetype_day_position(BYDAYPTR[idx]);
+ short this_dow;
+
+ impl->last.day = day;
+ this_dow = icaltime_day_of_week(impl->last);
+
+ if( (pos == 0 && dow == this_dow ) ||
+ (nth_weekday(dow,pos,impl->last) == day)){
+ goto DEND;
+ }
+ }
}
- impl->last.month =
- impl->by_ptrs[BY_MONTH][impl->by_indices[BY_MONTH]];
+ DEND:
- } else if( !has_by_data(impl,BY_MONTH) && this_frequency ){
-
- if(has_by_data(impl,BY_DAY)){
-
- short dayinc = 28;
-
- /* BY_DAY data specified a day of week, but incrementing the
- month changes the day of the week -- Nov 2 is not the
- same DOW as Oct 2. So, we need to fix the day of week by
- incrementing in even weeks into the next month. . */
-
-
- if ( impl->last.day + dayinc
- <= icaltime_days_in_month(impl->last.month, impl->last.year)){
- dayinc += 7;
- }
+ if ( day > days_in_month){
+ impl->last.day = 1;
+ increment_month(impl);
+ data_valid = 0; /* signal that impl->last is invalid */
+ }
- increment_monthday(impl,dayinc);
+ } else if (has_by_data(impl,BY_MONTH_DAY)) {
+ /* Cases like: FREQ=MONTHLY;COUNT=10;BYMONTHDAY=-3 */
+ short day;
- } else {
+ assert( BYMDPTR[0]!=ICAL_RECURRENCE_ARRAY_MAX);
- /* Compute the next value from the last time and the
- frequency interval*/
- increment_month(impl,impl->rule.interval);
+ BYMDIDX++;
+
+ /* Are we at the end of the BYDAY array? */
+ if (BYMDPTR[BYMDIDX] ==ICAL_RECURRENCE_ARRAY_MAX){
+
+ BYMDIDX = 0; /* Reset to 0 */
+ increment_month(impl);
}
-
- }
-
-
- if(has_by_data(impl,BY_MONTH) && end_of_data && this_frequency ){
- increment_year(impl,1);
+
+ day = BYMDPTR[BYMDIDX];
+
+ if (day < 0) {
+ day = icaltime_days_in_month(impl->last.month,impl->last.year)+
+ day + 1;
+ }
+
+ impl->last.day = day;
+
+ } else {
+ increment_month(impl);
}
- return end_of_data;
+
+ return data_valid; /* Signal that the data is valid */
}
@@ -1484,11 +1570,16 @@ int next_week(struct icalrecur_iterator_impl* impl)
short end_of_data = 0;
+ /* Increment to the next week day */
if (next_weekday_by_week(impl) == 0){
- return 0;
+ return 0; /* Have not reached end of week yet */
}
- if( impl->by_ptrs[BY_WEEK_NO][0]!=ICAL_RECURRENCE_ARRAY_MAX){
+ /* If we get here, we have incremented through the entire week, and
+ can increment to the next week */
+
+
+ if( has_by_data){
/* Use the Week Number byrule data */
int week_no;
struct icaltimetype t;
@@ -1513,11 +1604,11 @@ int next_week(struct icalrecur_iterator_impl* impl)
impl->last = icaltime_normalize(impl->last);
} else if( !has_by_data && this_frequency ){
-
-
+ /* If there is no BY_WEEK_NO data, just jump forward 7 days. */
increment_monthday(impl,7*impl->rule.interval);
}
+
if(has_by_data && end_of_data && this_frequency ){
increment_year(impl,1);
}
@@ -1527,6 +1618,69 @@ int next_week(struct icalrecur_iterator_impl* impl)
}
+pvl_list expand_by_day(struct icalrecur_iterator_impl* impl,short year)
+{
+ /* Try to calculate each of the occurrences. */
+ int i;
+ pvl_list days_list = pvl_newlist();
+
+ short start_dow, end_dow, end_year_day, start_doy;
+ struct icaltimetype tmp = impl->last;
+
+ tmp.year= year;
+ tmp.month = 1;
+ tmp.day = 1;
+ tmp.is_date = 1;
+
+ start_dow = icaltime_day_of_week(tmp);
+ start_doy = icaltime_start_doy_of_week(tmp);
+
+ /* Get the last day of the year*/
+ tmp.year++;
+ tmp = icaltime_normalize(tmp);
+ tmp.day--;
+ tmp = icaltime_normalize(tmp);
+
+ end_dow = icaltime_day_of_week(tmp);
+ end_year_day = icaltime_day_of_year(tmp);
+
+ for(i = 0; BYDAYPTR[i] != ICAL_RECURRENCE_ARRAY_MAX; i++){
+ short dow =
+ icalrecurrencetype_day_day_of_week(BYDAYPTR[i]);
+ short pos = icalrecurrencetype_day_position(BYDAYPTR[i]);
+
+ if(pos == 0){
+ /* add all of the days of the year with this day-of-week*/
+ int week;
+ for(week = 0; week < 52 ; week ++){
+ short doy = start_doy + (week * 7) + dow-1;
+
+ if(doy > end_year_day){
+ break;
+ } else {
+ pvl_push(days_list,(void*)(int)doy);
+ }
+ }
+
+ } else if ( pos > 0) {
+ int first;
+ /* First occurrence of dow in year */
+ if( dow >= start_dow) {
+ first = dow - start_dow + 1;
+ } else {
+ first = dow - start_dow + 8;
+ }
+
+ pvl_push(days_list,(void*)(first+ (pos-1) * 7));
+
+ } else { /* pos < 0 */
+ assert(0);
+ }
+ }
+
+ return days_list;
+}
+
/* For INTERVAL=YEARLY, set up the days[] array in the iterator to
list all of the days of the current year that are specified in this
@@ -1537,15 +1691,31 @@ int expand_year_days(struct icalrecur_iterator_impl* impl,short year)
int j,k;
int days_index=0;
struct icaltimetype t;
+ int flags;
+#define HBD(x) has_by_data(impl,x)
t.is_date = 1; /* Needed to make day_of_year routines work property */
memset(&t,0,sizeof(t));
memset(impl->days,ICAL_RECURRENCE_ARRAY_MAX_BYTE,sizeof(impl->days));
- if(has_by_data(impl,BY_MONTH) && !has_by_data(impl,BY_MONTH_DAY)
- && !has_by_data(impl,BY_DAY)){
+ flags = (HBD(BY_DAY) ? 1<<BY_DAY : 0) +
+ (HBD(BY_WEEK_NO) ? 1<<BY_WEEK_NO : 0) +
+ (HBD(BY_MONTH_DAY) ? 1<<BY_MONTH_DAY : 0) +
+ (HBD(BY_MONTH) ? 1<<BY_MONTH : 0) +
+ (HBD(BY_YEAR_DAY) ? 1<<BY_YEAR_DAY : 0);
+
+
+ switch(flags) {
+
+ case 0: {
+ /* FREQ=YEARLY; */
+
+ break;
+ }
+ case 1<<BY_MONTH: {
+ /* FREQ=YEARLY; BYMONTH=3,11*/
for(j=0;impl->by_ptrs[BY_MONTH][j]!=ICAL_RECURRENCE_ARRAY_MAX;j++){
struct icaltimetype t;
@@ -1562,10 +1732,81 @@ int expand_year_days(struct icalrecur_iterator_impl* impl,short year)
impl->days[days_index++] = doy;
}
+ break;
+ }
+ case 1<<BY_MONTH_DAY: {
+ /* FREQ=YEARLY; BYMONTHDAY=1,15*/
+ assert(0);
+ break;
+ }
+
+ case (1<<BY_MONTH_DAY) + (1<<BY_MONTH): {
+ /* FREQ=YEARLY; BYMONTHDAY=1,15; BYMONTH=10 */
+
+ for(j=0;impl->by_ptrs[BY_MONTH][j]!=ICAL_RECURRENCE_ARRAY_MAX;j++){
+ for(k=0;impl->by_ptrs[BY_MONTH_DAY][k]!=ICAL_RECURRENCE_ARRAY_MAX;k++)
+ {
+ short month = impl->by_ptrs[BY_MONTH][j];
+ short month_day = impl->by_ptrs[BY_MONTH_DAY][k];
+ short doy;
+
+ t.day = month_day;
+ t.month = month;
+ t.year = year;
+ t.is_date = 1;
+
+ doy = icaltime_day_of_year(t);
+
+ impl->days[days_index++] = doy;
+
+ }
+ }
+
+ break;
+ }
+
+ case 1<<BY_WEEK_NO: {
+ /* FREQ=YEARLY; BYWEEKNO=20,50 */
+
+ struct icaltimetype t;
+ short dow;
+
+ t.day = impl->dtstart.day;
+ t.month = impl->dtstart.month;
+ t.year = year;
+ t.is_date = 1;
+
+ dow = icaltime_day_of_week(t);
+ /* HACK Not finished */
+
+ break;
+ }
+ case (1<<BY_WEEK_NO) + (1<<BY_MONTH_DAY): {
+ /*FREQ=YEARLY; WEEKNO=20,50; BYMONTH= 6,11 */
+ assert(0);
+ break;
}
- else if ( has_by_data(impl,BY_MONTH) && has_by_data(impl,BY_DAY)){
+
+ case 1<<BY_DAY: {
+ /*FREQ=YEARLY; BYDAY=TH,20MO,-10FR*/
+ int days_index = 0;
+ pvl_elem i;
+ pvl_list days = expand_by_day(impl,year);
+
+
+ for(i=pvl_head(days);i!=0;i=pvl_next(i)){
+ short day = (short)(int)pvl_data(i);
+ impl->days[days_index++] = day;
+ }
+
+ break;
+ }
+
+ case (1<<BY_DAY)+(1<<BY_MONTH): {
+ /*FREQ=YEARLY; BYDAY=TH,20MO,-10FR; BYMONTH = 12*/
+
for(j=0;impl->by_ptrs[BY_MONTH][j]!=ICAL_RECURRENCE_ARRAY_MAX;j++){
short month = impl->by_ptrs[BY_MONTH][j];
@@ -1596,58 +1837,90 @@ int expand_year_days(struct icalrecur_iterator_impl* impl,short year)
}
}
}
- } else if (has_by_data(impl,BY_MONTH) && has_by_data(impl,BY_MONTH_DAY)){
+ break;
+ }
- for(j=0;impl->by_ptrs[BY_MONTH][j]!=ICAL_RECURRENCE_ARRAY_MAX;j++){
- for(k=0;impl->by_ptrs[BY_MONTH_DAY][k]!=ICAL_RECURRENCE_ARRAY_MAX;k++)
- {
- short month = impl->by_ptrs[BY_MONTH][j];
- short month_day = impl->by_ptrs[BY_MONTH_DAY][k];
- short doy;
+ case (1<<BY_DAY) + (1<<BY_MONTH_DAY) : {
+ /*FREQ=YEARLY; BYDAY=TH,20MO,-10FR; BYMONTHDAY=1,15*/
+ assert(0);
+ break;
+ }
- t.day = month_day;
- t.month = month;
- t.year = year;
- t.is_date = 1;
+ case (1<<BY_DAY) + (1<<BY_MONTH_DAY) + (1<<BY_MONTH): {
+ /*FREQ=YEARLY; BYDAY=TH,20MO,-10FR; BYMONTHDAY=10; MYMONTH=6,11*/
+
+ int days_index = 0;
+ pvl_elem itr;
+ pvl_list days = expand_by_day(impl,year);
+
+ for(itr=pvl_head(days);itr!=0;itr=pvl_next(itr)){
+ short day = (short)(int)pvl_data(itr);
+ struct icaltimetype tt;
+ short i,j;
+
+ tt = icaltime_from_day_of_year(day,year);
+
+ for(i = 0; BYMONPTR[i] != ICAL_RECURRENCE_ARRAY_MAX; i++){
+ for(j = 0; BYMDPTR[j]!=ICAL_RECURRENCE_ARRAY_MAX; j++){
+ short mday = BYMDPTR[j];
+ short month = BYMONPTR[i];
+
+ if(tt.month == month && tt.day == mday){
+ impl->days[days_index++] = day;
+ }
+ }
+ }
- doy = icaltime_day_of_year(t);
+ }
- impl->days[days_index++] = doy;
+ break;
+ }
+
+ case (1<<BY_DAY) + (1<<BY_WEEK_NO) : {
+ /*FREQ=YEARLY; BYDAY=TH,20MO,-10FR; WEEKNO=20,50*/
+
+ int days_index = 0;
+ pvl_elem itr;
+ pvl_list days = expand_by_day(impl,year);
+
+ for(itr=pvl_head(days);itr!=0;itr=pvl_next(itr)){
+ short day = (short)(int)pvl_data(itr);
+ struct icaltimetype tt;
+ short i;
+
+ tt = icaltime_from_day_of_year(day,year);
+
+ for(i = 0; BYWEEKPTR[i] != ICAL_RECURRENCE_ARRAY_MAX; i++){
+ short weekno = BYWEEKPTR[i];
+
+ if(weekno== icaltime_week_number(tt)){
+ impl->days[days_index++] = day;
+ }
}
+
}
- } else if (has_by_data(impl,BY_WEEK_NO) && !has_by_data(impl,BY_DAY)){
-
- struct icaltimetype t;
- short dow;
-
- t.day = impl->dtstart.day;
- t.month = impl->dtstart.month;
- t.year = year;
- t.is_date = 1;
+ break;
+ }
- dow = icaltime_day_of_week(t);
- /* HACK Not finished */
-
+ case (1<<BY_DAY) + (1<<BY_WEEK_NO) + (1<<BY_MONTH_DAY): {
+ /*FREQ=YEARLY; BYDAY=TH,20MO,-10FR; WEEKNO=20,50; BYMONTHDAY=1,15*/
+ assert(0);
+ break;
+ }
- } else if (has_by_data(impl,BY_WEEK_NO) && has_by_data(impl,BY_DAY)){
- /* HACK Not finished */
- } else if (has_by_data(impl,BY_YEAR_DAY)){
-
+ case 1<<BY_YEAR_DAY: {
for(j=0;impl->by_ptrs[BY_YEAR_DAY][j]!=ICAL_RECURRENCE_ARRAY_MAX;j++){
short doy = impl->by_ptrs[BY_YEAR_DAY][j];
impl->days[days_index++] = doy;
- }
-
- } else if (has_by_data(impl,BY_MONTH_DAY) ){
- /* HACK Not finished */
-
- } else if (has_by_data(impl,BY_DAY)){
- /* HACK Not finished */
+ }
+ break;
+ }
- } else {
- assert(0);
- /* HACK Not finished */
+ default: {
+ assert(0);
+ break;
+ }
}
@@ -1658,17 +1931,15 @@ int expand_year_days(struct icalrecur_iterator_impl* impl,short year)
int next_year(struct icalrecur_iterator_impl* impl)
{
struct icaltimetype next;
- short end_of_data=0;
if (next_hour(impl) == 0){
return 0;
}
- impl->days_index++;
-
- if (impl->days[impl->days_index] == ICAL_RECURRENCE_ARRAY_MAX){
+ if (impl->days[++impl->days_index] == ICAL_RECURRENCE_ARRAY_MAX){
impl->days_index = 0;
- end_of_data = 1;
+ increment_year(impl,impl->rule.interval);
+ expand_year_days(impl,impl->last.year);
}
next = icaltime_from_day_of_year(impl->days[impl->days_index],impl->last.year);
@@ -1676,16 +1947,26 @@ int next_year(struct icalrecur_iterator_impl* impl)
impl->last.day = next.day;
impl->last.month = next.month;
-
- if(end_of_data){
- increment_year(impl,impl->rule.interval);
- expand_year_days(impl,impl->last.year);
- }
-
return 1;
}
-int check_restriction(struct icalrecur_iterator_impl* impl,
+int icalrecur_check_rulepart(struct icalrecur_iterator_impl* impl,
+ short v, enum byrule byrule)
+{
+ int itr;
+
+ if(impl->by_ptrs[byrule][0]!=ICAL_RECURRENCE_ARRAY_MAX){
+ for(itr=0; impl->by_ptrs[byrule][itr]!=ICAL_RECURRENCE_ARRAY_MAX;itr++){
+ if(impl->by_ptrs[byrule][itr] == v){
+ return 1;
+ }
+ }
+ }
+
+ return 0;
+}
+
+int check_contract_restriction(struct icalrecur_iterator_impl* impl,
enum byrule byrule, short v)
{
int pass = 0;
@@ -1709,6 +1990,7 @@ int check_restriction(struct icalrecur_iterator_impl* impl,
}
}
+
int check_contracting_rules(struct icalrecur_iterator_impl* impl)
{
@@ -1717,14 +1999,14 @@ int check_contracting_rules(struct icalrecur_iterator_impl* impl)
int year_day=0;
if (
- check_restriction(impl,BY_SECOND,impl->last.second) &&
- check_restriction(impl,BY_MINUTE,impl->last.minute) &&
- check_restriction(impl,BY_HOUR,impl->last.hour) &&
- check_restriction(impl,BY_DAY,day_of_week) &&
- check_restriction(impl,BY_WEEK_NO,week_no) &&
- check_restriction(impl,BY_MONTH_DAY,impl->last.day) &&
- check_restriction(impl,BY_MONTH,impl->last.month) &&
- check_restriction(impl,BY_YEAR_DAY,year_day) )
+ check_contract_restriction(impl,BY_SECOND,impl->last.second) &&
+ check_contract_restriction(impl,BY_MINUTE,impl->last.minute) &&
+ check_contract_restriction(impl,BY_HOUR,impl->last.hour) &&
+ check_contract_restriction(impl,BY_DAY,day_of_week) &&
+ check_contract_restriction(impl,BY_WEEK_NO,week_no) &&
+ check_contract_restriction(impl,BY_MONTH_DAY,impl->last.day) &&
+ check_contract_restriction(impl,BY_MONTH,impl->last.month) &&
+ check_contract_restriction(impl,BY_YEAR_DAY,year_day) )
{
return 1;
@@ -1735,6 +2017,7 @@ int check_contracting_rules(struct icalrecur_iterator_impl* impl)
struct icaltimetype icalrecur_iterator_next(icalrecur_iterator *itr)
{
+ int valid = 1;
struct icalrecur_iterator_impl* impl =
(struct icalrecur_iterator_impl*)itr;
@@ -1752,6 +2035,7 @@ struct icaltimetype icalrecur_iterator_next(icalrecur_iterator *itr)
}
do {
+ valid = 1;
switch(impl->rule.freq){
case ICAL_SECONDLY_RECURRENCE: {
@@ -1775,7 +2059,7 @@ struct icaltimetype icalrecur_iterator_next(icalrecur_iterator *itr)
break;
}
case ICAL_MONTHLY_RECURRENCE: {
- next_month(impl);
+ valid = next_month(impl);
break;
}
case ICAL_YEARLY_RECURRENCE:{
@@ -1783,17 +2067,19 @@ struct icaltimetype icalrecur_iterator_next(icalrecur_iterator *itr)
break;
}
default:{
- assert(0); /* HACK, need a better error */
+ icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
+ return icaltime_null_time();
}
}
- if(impl->last.year >= 2038){
+ if(impl->last.year >= 2038 ){
/* HACK */
return icaltime_null_time();
}
} while(!check_contracting_rules(impl)
- || icaltime_compare(impl->last,impl->dtstart) < 0);
+ || icaltime_compare(impl->last,impl->dtstart) < 0
+ || valid == 0);
/* Ignore null times and times that are after the until time */
@@ -1830,6 +2116,9 @@ thursday of the year) These routines decode the day values.
The day's position in the period ( Nth-ness) and the numerical value
of the day are encoded together as: pos*7 + dow
+
+A position of 0 means 'any' or 'every'
+
*/
enum icalrecurrencetype_weekday icalrecurrencetype_day_day_of_week(short day)
@@ -1845,9 +2134,6 @@ short icalrecurrencetype_day_position(short day)
pos = (abs(day)-wd)/8 * ((day<0)?-1:1);
- if(pos == 0){
- pos = 1;
- }
return pos;
}
@@ -1909,7 +2195,7 @@ struct {
{ICAL_NO_RECURRENCE,0}
};
-const char* icalrecur_recurrence_to_string(icalrecurrencetype_frequency kind)
+const char* icalrecur_freq_to_string(icalrecurrencetype_frequency kind)
{
int i;
@@ -1921,7 +2207,7 @@ const char* icalrecur_recurrence_to_string(icalrecurrencetype_frequency kind)
return 0;
}
-icalrecurrencetype_frequency icalrecur_string_to_recurrence(const char* str)
+icalrecurrencetype_frequency icalrecur_string_to_freq(const char* str)
{
int i;
@@ -1933,6 +2219,10 @@ icalrecurrencetype_frequency icalrecur_string_to_recurrence(const char* str)
return ICAL_NO_RECURRENCE;
}
+/* Fill an array with the 'count' number of occurrences generated by
+ the rrule. Note that the times are returned in UTC, but the times
+ are calculated in local time. YOu will have to convert the results
+ back into local time before using them. */
int icalrecur_expand_recurrence(char* rule, time_t start,
int count, time_t* array)
@@ -1953,7 +2243,7 @@ int icalrecur_expand_recurrence(char* rule, time_t start,
next = icalrecur_iterator_next(ritr);
!icaltime_is_null_time(next) && i < count;
next = icalrecur_iterator_next(ritr)){
-
+
tt = icaltime_as_timet(next);
if (tt >= start ){
diff --git a/libical/src/libical/icaltime.c b/libical/src/libical/icaltime.c
index b3c94229bf..37ae194bd0 100644
--- a/libical/src/libical/icaltime.c
+++ b/libical/src/libical/icaltime.c
@@ -73,75 +73,80 @@ icaltime_from_timet(time_t tm, int is_date)
return tt;
}
-/* This will hold the last "TZ=XXX" string we used with putenv(). After we
- call putenv() again to set a new TZ string, we can free the previous one.
- As far as I know, no libc implementations actually free the memory used in
- the environment variables (how could they know if it is a static string or
- a malloc'ed string?), so we have to free it ourselves. */
-static char* saved_tz = NULL;
+/* Structure used by set_tz to hold an old value of TZ, and the new
+ value, which is in memory we will have to free in unset_tz */
+struct set_tz_save {char* orig_tzid; char* new_env_str;};
-
-/* If you use set_tz(), you must call unset_tz() some time later to restore the
- original TZ. Pass unset_tz() the string that set_tz() returns. */
-char* set_tz(const char* tzid)
+/* Temporarily change the TZ environmental variable. */
+struct set_tz_save set_tz(const char* tzid)
{
- char *old_tz, *old_tz_copy = NULL, *new_tz;
-
- /* Get the old TZ setting and save a copy of it to return. */
- old_tz = getenv("TZ");
- if(old_tz){
- old_tz_copy = (char*)malloc(strlen (old_tz) + 4);
- if(old_tz_copy == 0){
- icalerror_set_errno(ICAL_NEWFAILED_ERROR);
- return 0;
- }
+ char *orig_tzid = 0;
+ char *new_env_str;
+ struct set_tz_save savetz;
+ size_t tmp_sz;
- strcpy (old_tz_copy, "TZ=");
- strcpy (old_tz_copy + 3, old_tz);
- }
+ savetz.orig_tzid = 0;
+ savetz.new_env_str = 0;
- /* Create the new TZ string. */
- new_tz = (char*)malloc(strlen (tzid) + 4);
+ if(getenv("TZ") != 0){
+ orig_tzid = (char*)icalmemory_strdup(getenv("TZ"));
- if(new_tz == 0){
- icalerror_set_errno(ICAL_NEWFAILED_ERROR);
- return 0;
+ if(orig_tzid == 0){
+ icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+ return savetz;
+ }
}
- strcpy (new_tz, "TZ=");
- strcpy (new_tz + 3, tzid);
+ tmp_sz =strlen(tzid)+4;
+ new_env_str = (char*)malloc(tmp_sz);
- /* Add the new TZ to the environment. */
- putenv(new_tz);
+ if(new_env_str == 0){
+ icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+ return savetz;
+ }
+
+ /* Copy the TZid into a string with the form that putenv expects. */
+ strcpy(new_env_str,"TZ=");
+ strcpy(new_env_str+3,tzid);
- /* Free any previous TZ environment string we have used. */
- if (saved_tz)
- free (saved_tz);
+ putenv(new_env_str);
- /* Save a pointer to the TZ string we just set, so we can free it later. */
- saved_tz = new_tz;
+ /* Old value of TZ and the string we will have to free later */
+ savetz.orig_tzid = orig_tzid;
+ savetz.new_env_str = new_env_str;
- return old_tz_copy; /* This will be zero if the TZ env var was not set */
+ return savetz;
}
-void unset_tz(char *tzstr)
+void unset_tz(struct set_tz_save savetz)
{
- /* restore the original environment */
+ /* restore the original TZ environment */
+
+ char* orig_tzid = savetz.orig_tzid;
- if(tzstr!=0){
- putenv(tzstr);
+ if(orig_tzid!=0){
+ size_t tmp_sz =strlen(orig_tzid)+4;
+ char* orig_env_str = (char*)malloc(tmp_sz);
+
+ if(orig_env_str == 0){
+ icalerror_set_errno(ICAL_NEWFAILED_ERROR);
+ return;
+ }
+
+ strcpy(orig_env_str,"TZ=");
+ strcpy(orig_env_str+3,orig_tzid);
+
+ putenv(orig_env_str);
+
+ free(orig_tzid);
} else {
putenv("TZ"); /* Delete from environment */
}
- /* Free any previous TZ environment string we have used. */
- if (saved_tz)
- free (saved_tz);
-
- /* Save a pointer to the TZ string we just set, so we can free it later.
- (This can possibly be NULL if there was no TZ to restore.) */
- saved_tz = tzstr;
+ if(savetz.new_env_str != 0){
+ free(savetz.new_env_str);
+ }
}
@@ -324,7 +329,7 @@ struct icaltimetype icaltime_from_string(const char* str)
}
} else if (size == 8) { /* A DATE */
- tt.is_utc = 0;
+ tt.is_utc = 1;
tt.is_date = 1;
} else { /* error */
icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
@@ -352,8 +357,9 @@ struct icaltimetype icaltime_from_string(const char* str)
char ctime_str[20];
char* icaltime_as_ctime(struct icaltimetype t)
{
- time_t tt = icaltime_as_timet(t);
-
+ time_t tt;
+
+ tt = icaltime_as_timet(t);
sprintf(ctime_str,"%s",ctime(&tt));
ctime_str[strlen(ctime_str)-1] = 0;
@@ -400,6 +406,7 @@ short icaltime_day_of_week(struct icaltimetype t){
return tm->tm_wday+1;
}
+/* Day of the year that the first day of the week (Sunday) is on */
short icaltime_start_doy_of_week(struct icaltimetype t){
time_t tt = icaltime_as_timet(t);
time_t start_tt;
@@ -431,6 +438,19 @@ short icaltime_start_doy_of_week(struct icaltimetype t){
}
+short icaltime_week_number(struct icaltimetype ictt)
+{
+ char str[5];
+ time_t t = icaltime_as_timet(ictt);
+ int week_no;
+
+ strftime(str,5,"%V", gmtime(&t));
+
+ week_no = atoi(str);
+
+ return week_no;
+
+}
short icaltime_day_of_year(struct icaltimetype t){
@@ -452,6 +472,7 @@ struct icaltimetype icaltime_from_day_of_year(short doy, short year)
{
struct tm stm;
time_t tt;
+ struct set_tz_save old_tz = set_tz("UTC");
/* Get the time of january 1 of this year*/
memset(&stm,0,sizeof(struct tm));
@@ -459,6 +480,8 @@ struct icaltimetype icaltime_from_day_of_year(short doy, short year)
stm.tm_mday = 1;
tt = mktime(&stm);
+ unset_tz(old_tz);
+
/* Now add in the days */
@@ -536,380 +559,10 @@ icaltime_compare_date_only (struct icaltimetype a, struct icaltimetype b)
}
}
-struct icalperiodtype icalperiodtype_from_string (const char* str)
-{
-
- struct icalperiodtype p, null_p;
- char *s = strdup(str);
- char *start, *end = s;
- int old_ieaf = icalerror_errors_are_fatal;
-
- p.start = p.end = icaltime_null_time();
- p.duration = icaldurationtype_from_int(0);
-
- null_p = p;
-
- if(s == 0) goto error;
-
- start = s;
- end = strchr(s, '/');
-
- if(end == 0) goto error;
-
- *end = 0;
- end++;
-
- p.start = icaltime_from_string(start);
-
- if (icaltime_is_null_time(p.start)) goto error;
-
- icalerror_errors_are_fatal = 0;
- p.end = icaltime_from_string(end);
- icalerror_errors_are_fatal = old_ieaf;
-
- if (icaltime_is_null_time(p.end)){
-
- p.duration = icaldurationtype_from_string(end);
-
- if(icaldurationtype_as_int(p.duration) == 0) goto error;
- }
-
- return p;
-
- error:
- icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
- return null_p;
-}
-
-
-const char* icalperiodtype_as_ical_string(struct icalperiodtype p)
-{
-
- const char* start;
- const char* end;
-
- char *buf;
- size_t buf_size = 40;
- char* buf_ptr = 0;
-
- buf = (char*)icalmemory_new_buffer(buf_size);
- buf_ptr = buf;
-
-
- start = icaltime_as_ical_string(p.start);
-
- icalmemory_append_string(&buf, &buf_ptr, &buf_size, start);
-
- if(!icaltime_is_null_time(p.end)){
- end = icaltime_as_ical_string(p.end);
- } else {
- end = icaldurationtype_as_ical_string(p.duration);
- }
-
- icalmemory_append_char(&buf, &buf_ptr, &buf_size, '/');
-
- icalmemory_append_string(&buf, &buf_ptr, &buf_size, end);
-
- return buf;
-}
-
-
-time_t
-icalperiodtype_duration (struct icalperiodtype period);
-
-
-time_t
-icalperiodtype_end (struct icalperiodtype period);
-
-
-struct icalperiodtype icalperiodtype_null_period() {
- struct icalperiodtype p;
- p.start = icaltime_null_time();
- p.end = icaltime_null_time();
- p.duration = icaldurationtype_null_duration();
-
- return p;
-}
-int icalperiodtype_is_null_period(struct icalperiodtype p){
-
- if(icaltime_is_null_time(p.start) &&
- icaltime_is_null_time(p.end) &&
- icaldurationtype_is_null_duration(p.duration)){
- return 1;
- } else {
- return 0;
- }
-}
-
-int icalperiodtype_is_valid_period(struct icalperiodtype p){
- if(icaltime_is_valid_time(p.start) &&
- (icaltime_is_valid_time(p.end) || icaltime_is_null_time(p.end)) )
- {
- return 1;
- }
-
- return 0;
-}
-
-/* From Russel Steinthal */
-int icaldurationtype_as_int(struct icaldurationtype dur)
-{
- return (int)( (dur.seconds +
- (60 * dur.minutes) +
- (60 * 60 * dur.hours) +
- (60 * 60 * 24 * dur.days) +
- (60 * 60 * 24 * 7 * dur.weeks))
- * (dur.is_neg==1? -1 : 1) ) ;
-}
-
-/* From Seth Alves, <alves@hungry.com> */
-struct icaldurationtype icaldurationtype_from_int(int t)
-{
- struct icaldurationtype dur;
- int 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);
-
- dur.is_neg = t<0? 1 : 0;
-
- return dur;
-}
-
-#ifndef ICAL_NO_LIBICAL
-#include "icalvalue.h"
-struct icaldurationtype icaldurationtype_from_string(const char* str)
-{
-
- int i;
- int begin_flag = 0;
- int time_flag = 0;
- int date_flag = 0;
- int week_flag = 0;
- int digits=-1;
- int scan_size = -1;
- int size = strlen(str);
- char p;
- struct icaldurationtype d;
-
- memset(&d, 0, sizeof(struct icaldurationtype));
-
- for(i=0;i != size;i++){
- p = str[i];
-
- switch(p)
- {
- case '-': {
- if(i != 0 || begin_flag == 1) goto error;
-
- d.is_neg = 1;
- break;
- }
-
- case 'P': {
- if (i != 0 && i !=1 ) goto error;
- begin_flag = 1;
- break;
- }
-
- case 'T': {
- time_flag = 1;
- break;
- }
-
- case '0':
- case '1':
- case '2':
- case '3':
- case '4':
- case '5':
- case '6':
- case '7':
- case '8':
- case '9':
- {
-
- /* HACK. Skip any more digits if the l;ast one
- read has not been assigned */
- if(digits != -1){
- break;
- }
-
- if (begin_flag == 0) goto error;
- /* Get all of the digits, not one at a time */
- scan_size = sscanf((char*)(str+i),"%d",&digits);
- if(scan_size == 0) goto error;
- break;
- }
-
- case 'H': {
- if (time_flag == 0||week_flag == 1||d.hours !=0||digits ==-1)
- goto error;
- d.hours = digits; digits = -1;
- break;
- }
- case 'M': {
- if (time_flag == 0||week_flag==1||d.minutes != 0||digits ==-1)
- goto error;
- d.minutes = digits; digits = -1;
- break;
- }
- case 'S': {
- if (time_flag == 0||week_flag==1||d.seconds!=0||digits ==-1)
- goto error;
- d.seconds = digits; digits = -1;
- break;
- }
- case 'W': {
- if (time_flag==1||date_flag==1||d.weeks!=0||digits ==-1)
- goto error;
- week_flag = 1;
- d.weeks = digits; digits = -1;
- break;
- }
- case 'D': {
- if (time_flag==1||week_flag==1||d.days!=0||digits ==-1)
- goto error;
- date_flag = 1;
- d.days = digits; digits = -1;
- break;
- }
- default: {
- goto error;
- }
-
- }
- }
-
- return d;
-
-
- error:
- icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
- memset(&d, 0, sizeof(struct icaldurationtype));
- return d;
-
-}
-
-#define TMP_BUF_SIZE 1024
-void append_duration_segment(char** buf, char** buf_ptr, size_t* buf_size,
- char* sep, unsigned int value) {
-
- char temp[TMP_BUF_SIZE];
-
- sprintf(temp,"%d",value);
-
- icalmemory_append_string(buf, buf_ptr, buf_size, temp);
- icalmemory_append_string(buf, buf_ptr, buf_size, sep);
-
-}
-
-char* icaldurationtype_as_ical_string(struct icaldurationtype d)
-{
-
- char *buf, *output_line;
- size_t buf_size = 256;
- char* buf_ptr = 0;
- int seconds;
-
- buf = (char*)icalmemory_new_buffer(buf_size);
- buf_ptr = buf;
-
-
- seconds = icaldurationtype_as_int(d);
-
- if(seconds !=0){
-
- if(d.is_neg == 1){
- icalmemory_append_char(&buf, &buf_ptr, &buf_size, '-');
- }
-
- icalmemory_append_char(&buf, &buf_ptr, &buf_size, 'P');
-
- if (d.weeks != 0 ) {
- append_duration_segment(&buf, &buf_ptr, &buf_size, "W", d.weeks);
- }
-
- if (d.days != 0 ) {
- append_duration_segment(&buf, &buf_ptr, &buf_size, "D", d.days);
- }
-
- if (d.hours != 0 || d.minutes != 0 || d.seconds != 0) {
-
- icalmemory_append_string(&buf, &buf_ptr, &buf_size, "T");
-
- if (d.hours != 0 ) {
- append_duration_segment(&buf, &buf_ptr, &buf_size, "H", d.hours);
- }
- if (d.minutes != 0 ) {
- append_duration_segment(&buf, &buf_ptr, &buf_size, "M",
- d.minutes);
- }
- if (d.seconds != 0 ) {
- append_duration_segment(&buf, &buf_ptr, &buf_size, "S",
- d.seconds);
- }
-
- }
- } else {
- icalmemory_append_string(&buf, &buf_ptr, &buf_size, "PTS0");
- }
-
- output_line = icalmemory_tmp_copy(buf);
- icalmemory_free_buffer(buf);
-
- return output_line;
-
-}
-
-#endif
-
-struct icaldurationtype icaldurationtype_null_duration()
-{
- struct icaldurationtype d;
-
- memset(&d,0,sizeof(struct icaldurationtype));
-
- return d;
-}
-
-int icaldurationtype_is_null_duration(struct icaldurationtype d)
-{
- if(icaldurationtype_as_int(d) == 0){
- return 1;
- } else {
- return 0;
- }
-}
-
+/* These are defined in icalduration.c:
struct icaltimetype icaltime_add(struct icaltimetype t,
struct icaldurationtype d)
-{
- int dt = icaldurationtype_as_int(d);
-
- t.second += dt;
-
- t = icaltime_normalize(t);
-
- return t;
-}
-
struct icaldurationtype icaltime_subtract(struct icaltimetype t1,
struct icaltimetype t2)
-{
-
- time_t t1t = icaltime_as_timet(t1);
- time_t t2t = icaltime_as_timet(t2);
-
- return icaldurationtype_from_int(t1t-t2t);
-
-
-}
+*/
diff --git a/libical/src/libical/icaltime.h b/libical/src/libical/icaltime.h
index 165b88d943..0f0379b76e 100644
--- a/libical/src/libical/icaltime.h
+++ b/libical/src/libical/icaltime.h
@@ -38,6 +38,7 @@ struct icaltime_span {
int is_busy; /* 1->busy time, 0-> free time */
};
+
struct icaltimetype
{
int year;
@@ -56,12 +57,19 @@ struct icaltimetype
/* Convert seconds past UNIX epoch to a timetype*/
struct icaltimetype icaltime_from_timet(time_t v, int is_date);
+
+/* Return the time as seconds past the UNIX epoch */
time_t icaltime_as_timet(struct icaltimetype);
+
+/* Return a string represention of the time, in RFC2445 format. The
+ string is owned by libical */
char* icaltime_as_ical_string(struct icaltimetype tt);
/* Like icaltime_from_timet(), except that the input may be in seconds
- past the epoch in floating time */
+ past the epoch in floating time. This routine is deprecated */
struct icaltimetype icaltime_from_int(int v, int is_date, int is_utc);
+
+/* Like icaltime_as_timet, but in a floating epoch. This routine is deprecated */
int icaltime_as_int(struct icaltimetype);
/* create a time from an ISO format string */
@@ -81,76 +89,56 @@ struct icaltimetype icaltime_as_utc(struct icaltimetype tt,
struct icaltimetype icaltime_as_zone(struct icaltimetype tt,
const char* tzid);
-
+/* Return a null time, which indicates no time has been set. This time represent the beginning of the epoch */
struct icaltimetype icaltime_null_time(void);
+/* Return true of the time is null. */
int icaltime_is_null_time(struct icaltimetype t);
+
+/* Returns false if the time is clearly invalid, but is not null. This
+ is usually the result of creating a new time type buy not clearing
+ it, or setting one of the flags to an illegal value. */
int icaltime_is_valid_time(struct icaltimetype t);
+/* Reset all of the time components to be in their normal ranges. For
+ instance, given a time with minutes=70, the minutes will be reduces
+ to 10, and the hour incremented. This allows the caller to do
+ arithmetic on times without worrying about overflow or
+ underflow. */
struct icaltimetype icaltime_normalize(struct icaltimetype t);
+/* Return the day of the year of the given time */
short icaltime_day_of_year(struct icaltimetype t);
+
+/* Create a new time, given a day of year and a year. */
struct icaltimetype icaltime_from_day_of_year(short doy, short year);
+/* Return the day of the week of the given time. Sunday is 1 */
short icaltime_day_of_week(struct icaltimetype t);
+
+/* Return the day of the year for the Sunday of the week that the
+ given time is within. */
short icaltime_start_doy_of_week(struct icaltimetype t);
+/* Return a string with the time represented in the same format as ctime(). THe string is owned by libical */
char* icaltime_as_ctime(struct icaltimetype);
-short icaltime_week_number(short day_of_month, short month, short year);
+/* Return the week number for the week the given time is within */
+short icaltime_week_number(struct icaltimetype t);
+/* Create a new time from a weeknumber and a year. */
struct icaltimetype icaltime_from_week_number(short week_number, short year);
+/* Return -1, 0, or 1 to indicate that a<b, a==b or a>b */
int icaltime_compare(struct icaltimetype a,struct icaltimetype b);
+/* like icaltime_compare, but only use the date parts. */
int icaltime_compare_date_only(struct icaltimetype a, struct icaltimetype b);
-
+/* Return the number of days in the given month */
short icaltime_days_in_month(short month,short year);
-struct icaldurationtype
-{
- int is_neg;
- unsigned int days;
- unsigned int weeks;
- unsigned int hours;
- unsigned int minutes;
- unsigned int seconds;
-};
-
-struct icaldurationtype icaldurationtype_from_int(int t);
-struct icaldurationtype icaldurationtype_from_string(const char*);
-int icaldurationtype_as_int(struct icaldurationtype duration);
-char* icaldurationtype_as_ical_string(struct icaldurationtype d);
-struct icaldurationtype icaldurationtype_null_duration();
-int icaldurationtype_is_null_duration(struct icaldurationtype d);
-
-struct icalperiodtype
-{
- struct icaltimetype start; /* Must be absolute */
- struct icaltimetype end; /* Must be absolute */
- struct icaldurationtype duration;
-};
-
-struct icalperiodtype icalperiodtype_from_string (const char* str);
-const char* icalperiodtype_as_ical_string(struct icalperiodtype p);
-struct icalperiodtype icalperiodtype_null_period();
-int icalperiodtype_is_null_period(struct icalperiodtype p);
-int icalperiodtype_is_valid_period(struct icalperiodtype p);
-
-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.h b/libical/src/libical/icaltypes.h
index 7c0d2dd617..04e04c9dc3 100644
--- a/libical/src/libical/icaltypes.h
+++ b/libical/src/libical/icaltypes.h
@@ -25,8 +25,11 @@
#define ICALTYPES_H
#include <time.h>
-#include "icalenums.h" /* for recurrence enums */
+#include "icalenums.h"
#include "icaltime.h"
+#include "icalduration.h"
+#include "icalperiod.h"
+
/* This type type should probably be an opaque type... */
struct icalattachtype
@@ -104,4 +107,30 @@ struct icalreqstattype {
struct icalreqstattype icalreqstattype_from_string(char* str);
char* icalreqstattype_as_string(struct icalreqstattype);
+
+
+struct icaltimezonephase {
+ const char* tzname;
+ int is_stdandard; /* 1 = standard tme, 0 = daylight savings time */
+ struct icaltimetype dtstart;
+ int offsetto;
+ int tzoffsetfrom;
+ const char* comment;
+ struct icaldatetimeperiodtype rdate;
+ const char* rrule;
+};
+
+
+struct icaltimezonetype {
+ const char* tzid;
+ struct icaltimetype last_mod;
+ const char* tzurl;
+
+ /* Array of phases. The end of the array is a phase with tzname == 0 */
+ struct icaltimezonephase *phases;
+};
+
+void icaltimezonetype_free(struct icaltimezonetype tzt);
+
+
#endif /* !ICALTYPES_H */
diff --git a/libical/src/libicalss/Makefile.am b/libical/src/libicalss/Makefile.am
index 732d970738..28a3adc6ee 100644
--- a/libical/src/libicalss/Makefile.am
+++ b/libical/src/libicalss/Makefile.am
@@ -7,11 +7,10 @@ LEX_OUTPUT_ROOT = lex.ss
all: icalss.h
INCLUDES = \
- -I$(top_builddir) \
-I$(top_srcdir)/src \
-I$(top_builddir)/src \
-I$(top_srcdir)/src/libical \
- -I$(srcdir)/libical
+ -I$(top_builddir)/src/libical
libicalss_la_LDFLAGS = -version-info 0:0:0
@@ -25,11 +24,14 @@ libicalss_la_SOURCES = \
icalfilesetimpl.h \
icalset.c \
icalsslexer.l \
- icalssutil.c \
icalssyacc.h \
icalssyacc.y \
icalspanlist.c \
icalmessage.c \
+ icalcstpclient.c \
+ icalcstpclient.h \
+ icalcstpserver.c \
+ icalcstpserver.h \
icalcstp.c
libicalssincludedir = $(includedir)
@@ -40,11 +42,13 @@ COMBINEDHEADERS = \
icalfileset.h \
icaldirset.h \
icalcalendar.h \
- icalssutil.h \
icalclassify.h \
icalspanlist.h \
icalmessage.h \
- icalcstp.h
+ icalcstp.h \
+ icalcstpclient.h \
+ icalcstpserver.h
+
icalss.h: $(COMBINEDHEADERS)
cat $(COMBINEDHEADERS) | egrep -v "#include.*\"ical" \
diff --git a/libical/src/libicalss/icalcstp.h b/libical/src/libicalss/icalcstp.h
index 2ebccd622a..dfc361830e 100644
--- a/libical/src/libicalss/icalcstp.h
+++ b/libical/src/libicalss/icalcstp.h
@@ -30,134 +30,48 @@
#include "ical.h"
-/********************** Server (Reciever) Interfaces *************************/
-
-/* On the server side, the caller will recieve data from the incoming
- socket and pass it to icalcstps_next_input. The caller then takes
- the return from icalcstps_next_outpu and sends it out through the
- socket. This gives the caller a point of control. If the cstp code
- connected to the socket itself, it would be hard for the caller to
- do anything else after the cstp code was started.
-
- All of the server abd client command routines will generate
- response codes. On the server side, these responses will be turned
- into text and sent to the client. On the client side, the reponse
- is the one sent from the server.
-
- Since each command can return multiple responses, the responses are
- stored in the icalcstps object and are accesses by
- icalcstps_first_response() and icalcstps_next_response()
-
- How to use:
-
- 1) Construct a new icalcstps, bound to your code via stubs
- 2) Repeat forever:
- 2a) Get string from client & give to icalcstps_next_input()
- 2b) Repeat until icalcstp_next_output returns 0:
- 2b1) Call icalcstps_next_output.
- 2b2) Send string to client.
-*/
-
-
-
-typedef void icalcstps;
-
-/* Er, they aren't really stubs, but pointers to the rountines that
- icalcstps_process_incoming will call when it recognizes a CSTP
- command in the data. BTW, the CONTINUE command is named 'cont'
- because 'continue' is a C keyword */
-struct icalcstps_stubs {
- icalerrorenum (*abort)(icalcstps* cstp);
- icalerrorenum (*authenticate)(icalcstps* cstp, char* mechanism,
- char* data);
- icalerrorenum (*calidexpand)(icalcstps* cstp, char* calid);
- icalerrorenum (*capability)(icalcstps* cstp);
- icalerrorenum (*cont)(icalcstps* cstp, unsigned int time);
- icalerrorenum (*identify)(icalcstps* cstp, char* id);
- icalerrorenum (*disconnect)(icalcstps* cstp);
- icalerrorenum (*sendata)(icalcstps* cstp, unsigned int time,
- icalcomponent *comp);
- icalerrorenum (*starttls)(icalcstps* cstp, char* command,
- char* data);
- icalerrorenum (*upnexpand)(icalcstps* cstp, char* upn);
- icalerrorenum (*unknown)(icalcstps* cstp, char* command, char* data);
+/* Connection state, from the state machine in RFC2445 */
+enum cstps_state {
+ NO_STATE,
+ CONNECTED,
+ AUTHENTICATED,
+ IDENTIFIED,
+ DISCONNECTED,
+ RECEIVE
};
+/* CSTP Commands that a client can issue to a server */
+typedef enum icalcstp_command {
+ ICAL_ABORT_COMMAND,
+ ICAL_AUTHENTICATE_COMMAND,
+ ICAL_CAPABILITY_COMMAND,
+ ICAL_CONTINUE_COMMAND,
+ ICAL_CALIDEXPAND_COMMAND,
+ ICAL_IDENTIFY_COMMAND,
+ ICAL_DISCONNECT_COMMAND,
+ ICAL_SENDDATA_COMMAND,
+ ICAL_STARTTLS_COMMAND,
+ ICAL_UPNEXPAND_COMMAND,
+ ICAL_COMPLETE_COMMAND,
+ ICAL_UNKNOWN_COMMAND
+} icalcstp_command;
+
+
+
+/* A statement is a combination of command or response code and a
+ component that the server and client exchage with each other. */
+struct icalcstp_statement {
+ icalcstp_command command;
+ char* str_data; /* If non-NUll use as arguments to command */
+ int int_data; /* If non-NULL use as arguments to command */
+
+ icalrequeststatus code;
+
+ icalcomponent* data;
+};
-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 **************************/
-
-/* How to use:
-
- 1) Construct a new icalcstpc
- 2) Issue a command by calling one of the command routines.
- 3) Repeat until both call icalcstpc_next_output and
- icalcstpc_next_input return 0:
- 3a) Call icalcstpc_next_output. Send string to server.
- 3b) Get string from server, & give to icalcstp_next_input()
- 4) Iterate with icalcstpc_first_response & icalcstp_next_response to
- get the servers responses
- 5) Repeat at #2
-*/
-
-typedef void* icalcstpc;
-
-/* Response code sent by the server. */
-typedef struct icalcstpc_response {
- icalrequeststatus code;
- char *arg; /* These strings are owned by libical */
- char *debug_text;
- char *more_text;
- void* result;
-} icalcstpc_response;
-
-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);
-
+const char* icalcstp_command_to_string(icalcstp_command command);
+icalcstp_command icalcstp_string_to_command(const char* str);
#endif /* !ICALCSTP_H */
diff --git a/libical/src/libicalvcal/Makefile.am b/libical/src/libicalvcal/Makefile.am
index 3c307e7f4c..c409347d14 100644
--- a/libical/src/libicalvcal/Makefile.am
+++ b/libical/src/libicalvcal/Makefile.am
@@ -4,8 +4,7 @@ INCLUDES = \
-I$(top_builddir) \
-I$(top_srcdir)/src/libical \
-I$(top_builddir)/src/libical \
- -I$(top_srcdir)/src/libicalss \
- -I$(srcdir)
+ -I$(top_srcdir)/src/libicalss
libicalvcal_la_LDFLAGS = -version-info 0:0:0
diff --git a/libical/src/test/Makefile.am b/libical/src/test/Makefile.am
index 2830afdaa0..d4fa33c040 100644
--- a/libical/src/test/Makefile.am
+++ b/libical/src/test/Makefile.am
@@ -1,16 +1,16 @@
noinst_PROGRAMS = copycluster regression parser storage stow recur testmime testvcal process testclassify
-LDADD = ../libicalss/libicalss.la ../libicalvcal/libicalvcal.la ../libical/libical.la
+LDADD = ../libicalss/.libs/libicalss.a ../libicalvcal/.libs/libicalvcal.a ../libical/.libs/libical.a
-INCLUDES = \
- -I. \
- -I../libicalvcal \
- -I$(srcdir)/../libicalvcal \
- -I$(srcdir) \
- -I../libical \
- -I$(srcdir)/../libical \
- -I../libicalss \
+INCLUDES = \
+ -I. \
+ -I../libicalvcal \
+ -I$(srcdir)/../libicalvcal \
+ -I$(srcdir) \
+ -I../libical \
+ -I$(srcdir)/../libical \
+ -I../libicalss \
-I$(srcdir)/../libicalss
copycluster_SOURCES = copycluster.c
diff --git a/libical/src/test/copycluster.c b/libical/src/test/copycluster.c
index fa87e25385..4eefc37758 100644
--- a/libical/src/test/copycluster.c
+++ b/libical/src/test/copycluster.c
@@ -31,8 +31,14 @@
#include "icalfileset.h"
#include <errno.h>
#include <string.h> /* For strerror */
+#include <signal.h> /* for signal */
+#include <unistd.h> /* for alarm */
#include "icalrestriction.h"
+static void sig_alrm(int i){
+ fprintf(stderr,"Could not get lock on file\n");
+ exit(1);
+}
/* This program copies a file that holds iCal components to an other file. */
@@ -57,10 +63,14 @@ int main(int c, char *argv[]){
}
- icalerror_set_error_state(ICAL_MALFORMEDDATA_ERROR, ICAL_ERROR_NONFATAL);
icalerror_set_error_state(ICAL_PARSE_ERROR, ICAL_ERROR_NONFATAL);
+
+ signal(SIGALRM,sig_alrm);
+
+ alarm(0);
clusterin = icalfileset_new(argv[1]);
+ alarm(0);
if (clusterin == 0){
printf("Could not open input cluster \"%s\"",argv[1]);
@@ -81,13 +91,16 @@ int main(int c, char *argv[]){
itr != 0;
itr = icalset_get_next_component(clusterin)){
+ icalerror_set_error_state(ICAL_BADARG_ERROR, ICAL_ERROR_NONFATAL);
icalrestriction_check(itr);
+ icalerror_set_error_state(ICAL_BADARG_ERROR, ICAL_ERROR_DEFAULT);
if (itr != 0){
if(tostdout){
printf("--------------\n%s\n",icalcomponent_as_ical_string(itr));
+
} else {
icalfileset_add_component(clusterout,
diff --git a/libical/src/test/regression.c b/libical/src/test/regression.c
index 00c686d027..3512905cfe 100644
--- a/libical/src/test/regression.c
+++ b/libical/src/test/regression.c
@@ -41,6 +41,14 @@
#include <sys/time.h> /* for select */
+/* For GNU libc, strcmp appears to be a macro, so using strcmp in
+ assert results in incomprehansible assertion messages. This
+ eliminates the problem */
+
+int regrstrcmp(const char* a, const char* b){
+ return strcmp(a,b);
+}
+
/* This example creates and minipulates the ical object that appears
* in rfc 2445, page 137 */
@@ -253,7 +261,7 @@ icalcomponent* create_new_component()
icalproperty_add_parameter(
property,
- icalparameter_new_rsvp(1)
+ icalparameter_new_rsvp(ICAL_RSVP_TRUE)
);
icalproperty_add_parameter(
@@ -380,7 +388,7 @@ icalcomponent* create_new_component_with_va_args()
icalproperty_vanew_attendee(
"employee-A@host.com",
icalparameter_new_role(ICAL_ROLE_REQPARTICIPANT),
- icalparameter_new_rsvp(1),
+ icalparameter_new_rsvp(ICAL_RSVP_TRUE),
icalparameter_new_cutype(ICAL_CUTYPE_GROUP),
0
),
@@ -440,7 +448,7 @@ char** get_required_attendees(icalproperty* event)
if ( icalparameter_get_role(parameter) == ICAL_ROLE_REQPARTICIPANT)
{
- attendees[c++] = strdup(icalproperty_get_attendee(p));
+ attendees[c++] = icalmemory_strdup(icalproperty_get_attendee(p));
if (c >= max) {
max *= 2;
@@ -542,6 +550,35 @@ void test_values()
if (v!=0) icalvalue_free(v);
+ assert(ICAL_BOOLEAN_VALUE ==
+ icalparameter_value_to_value_kind(ICAL_VALUE_BOOLEAN));
+ assert(ICAL_UTCOFFSET_VALUE ==
+ icalparameter_value_to_value_kind(ICAL_VALUE_UTCOFFSET));
+ assert(ICAL_RECUR_VALUE ==
+ icalparameter_value_to_value_kind(ICAL_VALUE_RECUR));
+ assert(ICAL_CALADDRESS_VALUE ==
+ icalparameter_value_to_value_kind(ICAL_VALUE_CALADDRESS));
+ assert(ICAL_PERIOD_VALUE ==
+ icalparameter_value_to_value_kind(ICAL_VALUE_PERIOD));
+ assert(ICAL_BINARY_VALUE ==
+ icalparameter_value_to_value_kind(ICAL_VALUE_BINARY));
+ assert(ICAL_TEXT_VALUE ==
+ icalparameter_value_to_value_kind(ICAL_VALUE_TEXT));
+ assert(ICAL_DURATION_VALUE ==
+ icalparameter_value_to_value_kind(ICAL_VALUE_DURATION));
+ assert(ICAL_INTEGER_VALUE == icalparameter_value_to_value_kind(ICAL_VALUE_INTEGER));
+ assert(ICAL_TIME_VALUE ==
+ icalparameter_value_to_value_kind(ICAL_VALUE_TIME));
+ assert(ICAL_URI_VALUE ==
+ icalparameter_value_to_value_kind(ICAL_VALUE_URI));
+ assert(ICAL_FLOAT_VALUE ==
+ icalparameter_value_to_value_kind(ICAL_VALUE_FLOAT));
+ assert(ICAL_X_VALUE ==
+ icalparameter_value_to_value_kind(ICAL_VALUE_X));
+ assert(ICAL_DATETIME_VALUE ==
+ icalparameter_value_to_value_kind(ICAL_VALUE_DATETIME));
+ assert(ICAL_DATE_VALUE ==
+ icalparameter_value_to_value_kind(ICAL_VALUE_DATE));
/* v = icalvalue_new_caladdress(0);
@@ -604,14 +641,48 @@ void test_properties()
void test_parameters()
{
icalparameter *p;
+ int i;
+ int enums[] = {ICAL_CUTYPE_INDIVIDUAL,ICAL_CUTYPE_RESOURCE,ICAL_FBTYPE_BUSY,ICAL_PARTSTAT_NEEDSACTION,ICAL_ROLE_NONPARTICIPANT,ICAL_XLICCOMPARETYPE_LESSEQUAL,ICAL_XLICERRORTYPE_MIMEPARSEERROR,-1};
+
+ char* str1 = "A Common Name";
- p = icalparameter_new_cn("A Common Name");
+ p = icalparameter_new_cn(str1);
printf("Common Name: %s\n",icalparameter_get_cn(p));
+ assert(regrstrcmp(str1,icalparameter_get_cn(p)) == 0);
+
printf("As String: %s\n",icalparameter_as_ical_string(p));
+ assert(regrstrcmp(icalparameter_as_ical_string(p),"CN=A Common Name")==0);
+
icalparameter_free(p);
+
+
+ p = icalparameter_new_from_string("PARTSTAT=ACCEPTED");
+ assert(icalparameter_isa(p) == ICAL_PARTSTAT_PARAMETER);
+ assert(icalparameter_get_partstat(p) == ICAL_PARTSTAT_ACCEPTED);
+
+ p = icalparameter_new_from_string("ROLE=CHAIR");
+ assert(icalparameter_isa(p) == ICAL_ROLE_PARAMETER);
+ assert(icalparameter_get_partstat(p) == ICAL_ROLE_CHAIR);
+
+ p = icalparameter_new_from_string("PARTSTAT=X-FOO");
+ assert(icalparameter_isa(p) == ICAL_PARTSTAT_PARAMETER);
+ assert(icalparameter_get_partstat(p) == ICAL_PARTSTAT_X);
+
+ p = icalparameter_new_from_string("X-PARAM=X-FOO");
+ assert(icalparameter_isa(p) == ICAL_X_PARAMETER);
+
+
+ for (i=0;enums[i] != -1; i++){
+
+ printf("%s\n",icalparameter_enum_to_string(enums[i]));
+ assert(icalparameter_string_to_enum(
+ icalparameter_enum_to_string(enums[i]))==enums[i]);
+ }
+
+
}
@@ -1038,7 +1109,7 @@ void test_restriction()
icalproperty_vanew_attendee(
"employee-A@host.com",
icalparameter_new_role(ICAL_ROLE_REQPARTICIPANT),
- icalparameter_new_rsvp(1),
+ icalparameter_new_rsvp(ICAL_RSVP_TRUE),
icalparameter_new_cutype(ICAL_CUTYPE_GROUP),
0
),
@@ -1047,7 +1118,7 @@ void test_restriction()
icalproperty_new_class("PUBLIC"),
icalproperty_new_created(atime),
icalproperty_new_summary("XYZ Project Review"),
-/* icalproperty_vanew_dtstart(
+ /* icalproperty_new_dtstart(
atime,
icalparameter_new_tzid("US-Eastern"),
0
@@ -1171,6 +1242,23 @@ void test_recur()
}
+void test_expand_recurrence(){
+
+ time_t arr[10];
+ time_t now = 931057385;
+ int i;
+ icalrecur_expand_recurrence( "FREQ=MONTHLY;BYDAY=MO,WE", now,
+ 5, arr );
+
+ printf("Start %s",ctime(&now) );
+ for (i=0; i<5; i++)
+ {
+ printf("i=%d %s\n", i, ctime(&arr[i]) );
+ }
+
+}
+
+
enum byrule {
NO_CONTRACTION = -1,
@@ -1336,12 +1424,28 @@ void test_period()
{
struct icalperiodtype p;
+ icalvalue *v;
p = icalperiodtype_from_string("19971015T050000Z/PT8H30M");
printf("%s\n",icalperiodtype_as_ical_string(p));
+ assert(strcmp(icalperiodtype_as_ical_string(p),
+ "19971015T050000Z/PT8H30M") == 0);
p = icalperiodtype_from_string("19971015T050000Z/19971015T060000Z");
printf("%s\n",icalperiodtype_as_ical_string(p));
+ assert(strcmp(icalperiodtype_as_ical_string(p),
+ "19971015T050000Z/19971015T060000Z") == 0);
+
+ p = icalperiodtype_from_string("19970101T120000/PT3H");
+ printf("%s\n",icalperiodtype_as_ical_string(p));
+ assert(strcmp(icalperiodtype_as_ical_string(p),
+ "19970101T120000/PT3H") == 0);
+
+ v = icalvalue_new_from_string(ICAL_PERIOD_VALUE,"19970101T120000/PT3H");
+ printf("%s\n",icalvalue_as_ical_string(v));
+ assert(strcmp(icalvalue_as_ical_string(v),
+ "19970101T120000/PT3H") == 0);
+
}
@@ -1473,10 +1577,10 @@ void do_test_time(char* zone)
printf("Orig (ical) : %s\n", ictt_as_string(ictt));
icttnorm = ictt;
icttnorm.second -= 60 * 60 * 24 * 5;
- icttnorm = icaltime_normalize(ictt);
+ icttnorm = icaltime_normalize(icttnorm);
printf("-5d in sec : %s\n", ictt_as_string(icttnorm));
icttnorm.day += 60;
- icttnorm = icaltime_normalize(ictt);
+ icttnorm = icaltime_normalize(icttnorm);
printf("+60 d : %s\n", ictt_as_string(icttnorm));
@@ -1754,7 +1858,7 @@ char* test_set_tz(const char* tzid)
/* Put the new time zone into the environment */
if(getenv("TZ") != 0){
- tzstr = (char*)strdup(getenv("TZ"));
+ tzstr = (char*)icalmemory_strdup(getenv("TZ"));
if(tzstr == 0){
icalerror_set_errno(ICAL_NEWFAILED_ERROR);
@@ -2301,6 +2405,10 @@ void test_recur_parser()
}
+char* ical_strstr(const char *haystack, const char *needle){
+ return strstr(haystack,needle);
+}
+
void test_doy()
{
struct icaltimetype tt1, tt2;
@@ -2310,17 +2418,22 @@ void test_doy()
doy = icaltime_day_of_year(tt1);
tt2 = icaltime_from_day_of_year(doy,1995);
printf("%d %s %s\n",doy, icaltime_as_ctime(tt1),icaltime_as_ctime(tt2));
+ assert(tt2.day == 1 && tt2.month == 3);
+ assert(doy == 60);
tt1 = icaltime_from_string("19960301");
doy = icaltime_day_of_year(tt1);
tt2 = icaltime_from_day_of_year(doy,1996);
printf("%d %s %s\n",doy, icaltime_as_ctime(tt1),icaltime_as_ctime(tt2));
+ assert(tt2.day == 1 && tt2.month == 3);
+ assert(doy == 61);
tt1 = icaltime_from_string("19970301");
doy = icaltime_day_of_year(tt1);
tt2 = icaltime_from_day_of_year(doy,1997);
printf("%d %s %s\n",doy, icaltime_as_ctime(tt1),icaltime_as_ctime(tt2));
-
+ assert(tt2.day == 1 && tt2.month == 3);
+ assert(doy == 60);
}
@@ -2832,17 +2945,54 @@ void test_file_locks()
assert(sec == final);
}
-/* For GNU libc, strcmp appears to be a macro, so using strcmp in assert results in incomprehansible assertion messages. This eliminates the problem */
+void test_action()
+{
+ icalcomponent *c;
+ icalproperty *p;
+
+ static const char test_icalcomp_str[] =
+"BEGIN:VEVENT\n"
+"ACTION:EMAIL\n"
+"ACTION:PROCEDURE\n"
+"ACTION:AUDIO\n"
+"ACTION:FUBAR\n"
+"END:VEVENT\r\n";
+
+
+ c = icalparser_parse_string ((char *) test_icalcomp_str);
+ if (!c) {
+ fprintf (stderr, "main(): could not parse the component\n");
+ exit (EXIT_FAILURE);
+ }
+
+ printf("%s\n\n",icalcomponent_as_ical_string(c));
+
+ p = icalcomponent_get_first_property(c,ICAL_ACTION_PROPERTY);
+
+ assert(icalproperty_get_action(p) == ICAL_ACTION_EMAIL);
+
+ p = icalcomponent_get_next_property(c,ICAL_ACTION_PROPERTY);
+
+ assert(icalproperty_get_action(p) == ICAL_ACTION_PROCEDURE);
+
+ p = icalcomponent_get_next_property(c,ICAL_ACTION_PROPERTY);
+
+ assert(icalproperty_get_action(p) == ICAL_ACTION_AUDIO);
+
+ p = icalcomponent_get_next_property(c,ICAL_ACTION_PROPERTY);
+
+ assert(icalproperty_get_action(p) == ICAL_ACTION_X);
+ assert(regrstrcmp(icalvalue_get_x(icalproperty_get_value(p)), "FUBAR")==0);
+
-int ttstrcmp(const char* a, const char* b){
- return strcmp(a,b);
}
+
+
void test_trigger()
{
struct icaltriggertype tr;
- struct icaldatetimeperiodtype dtp;
icalcomponent *c;
icalproperty *p;
char* str;
@@ -2883,7 +3033,7 @@ void test_trigger()
str = icalproperty_as_ical_string(p);
printf("%s\n",str);
- assert(ttstrcmp("TRIGGER\n ;VALUE=DATE-TIME\n :19970101T120000\n",str) == 0);
+ assert(regrstrcmp("TRIGGER\n ;VALUE=DATE-TIME\n :19970101T120000\n",str) == 0);
icalproperty_free(p);
/* TRIGGER, as a DURATION */
@@ -2893,7 +3043,7 @@ void test_trigger()
str = icalproperty_as_ical_string(p);
printf("%s\n",str);
- assert(ttstrcmp("TRIGGER\n :P3DT3H50M45S\n",str) == 0);
+ assert(regrstrcmp("TRIGGER\n ;VALUE=DURATION\n :P3DT3H50M45S\n",str) == 0);
icalproperty_free(p);
/* TRIGGER, as a DATETIME, VALUE=DATETIME*/
@@ -2904,7 +3054,7 @@ void test_trigger()
str = icalproperty_as_ical_string(p);
printf("%s\n",str);
- assert(ttstrcmp("TRIGGER\n ;VALUE=DATE-TIME\n :19970101T120000\n",str) == 0);
+ assert(regrstrcmp("TRIGGER\n ;VALUE=DATE-TIME\n :19970101T120000\n",str) == 0);
icalproperty_free(p);
/*TRIGGER, as a DURATION, VALUE=DATETIME */
@@ -2916,7 +3066,7 @@ void test_trigger()
str = icalproperty_as_ical_string(p);
printf("%s\n",str);
- assert(ttstrcmp("TRIGGER\n ;VALUE=DURATION\n :P3DT3H50M45S\n",str) == 0);
+ assert(regrstrcmp("TRIGGER\n ;VALUE=DURATION\n :P3DT3H50M45S\n",str) == 0);
icalproperty_free(p);
/* TRIGGER, as a DATETIME, VALUE=DURATION*/
@@ -2927,7 +3077,7 @@ void test_trigger()
str = icalproperty_as_ical_string(p);
printf("%s\n",str);
- assert(ttstrcmp("TRIGGER\n ;VALUE=DATE-TIME\n :19970101T120000\n",str) == 0);
+ assert(regrstrcmp("TRIGGER\n ;VALUE=DATE-TIME\n :19970101T120000\n",str) == 0);
icalproperty_free(p);
/*TRIGGER, as a DURATION, VALUE=DURATION */
@@ -2939,7 +3089,7 @@ void test_trigger()
str = icalproperty_as_ical_string(p);
printf("%s\n",str);
- assert(ttstrcmp("TRIGGER\n ;VALUE=DURATION\n :P3DT3H50M45S\n",str) == 0);
+ assert(regrstrcmp("TRIGGER\n ;VALUE=DURATION\n :P3DT3H50M45S\n",str) == 0);
icalproperty_free(p);
@@ -2951,7 +3101,7 @@ void test_trigger()
str = icalproperty_as_ical_string(p);
printf("%s\n",str);
- assert(ttstrcmp("TRIGGER\n ;VALUE=DATE-TIME\n :19970101T120000\n",str) == 0);
+ assert(regrstrcmp("TRIGGER\n ;VALUE=DATE-TIME\n :19970101T120000\n",str) == 0);
icalproperty_free(p);
/*TRIGGER, as a DURATION, VALUE=BINARY */
@@ -2963,7 +3113,7 @@ void test_trigger()
str = icalproperty_as_ical_string(p);
printf("%s\n",str);
- assert(ttstrcmp("TRIGGER\n ;VALUE=DURATION\n :P3DT3H50M45S\n",str) == 0);
+ assert(regrstrcmp("TRIGGER\n ;VALUE=DURATION\n :P3DT3H50M45S\n",str) == 0);
icalproperty_free(p);
@@ -2976,7 +3126,6 @@ void test_rdate()
struct icaldatetimeperiodtype dtp;
icalproperty *p;
char* str;
- struct icaltimetype time = icaltime_from_string("19970101T120000");
struct icalperiodtype period;
period.start = icaltime_from_string("19970101T120000");
@@ -2989,7 +3138,7 @@ void test_rdate()
p = icalproperty_new_rdate(dtp);
str = icalproperty_as_ical_string(p);
printf("%s\n",str);
- assert(ttstrcmp("RDATE\n :19970101T120000\n",str) == 0);
+ assert(regrstrcmp("RDATE\n ;VALUE=DATE-TIME\n :19970101T120000\n",str) == 0);
icalproperty_free(p);
@@ -3000,7 +3149,7 @@ void test_rdate()
str = icalproperty_as_ical_string(p);
printf("%s\n",str);
- assert(ttstrcmp("RDATE\n ;VALUE=PERIOD\n :19970101T120000/PT3H10M15S\n",str) == 0);
+ assert(regrstrcmp("RDATE\n ;VALUE=PERIOD\n :19970101T120000/PT3H10M15S\n",str) == 0);
icalproperty_free(p);
/* RDATE, as DATE-TIME, VALUE=DATE-TIME */
@@ -3010,7 +3159,7 @@ void test_rdate()
icalproperty_add_parameter(p,icalparameter_new_value(ICAL_VALUE_DATETIME));
str = icalproperty_as_ical_string(p);
printf("%s\n",str);
- assert(ttstrcmp("RDATE\n ;VALUE=DATE-TIME\n :19970101T120000\n",str) == 0);
+ assert(regrstrcmp("RDATE\n ;VALUE=DATE-TIME\n :19970101T120000\n",str) == 0);
icalproperty_free(p);
@@ -3021,7 +3170,7 @@ void test_rdate()
icalproperty_add_parameter(p,icalparameter_new_value(ICAL_VALUE_DATETIME));
str = icalproperty_as_ical_string(p);
printf("%s\n",str);
- assert(ttstrcmp("RDATE\n ;VALUE=PERIOD\n :19970101T120000/PT3H10M15S\n",str) == 0);
+ assert(regrstrcmp("RDATE\n ;VALUE=PERIOD\n :19970101T120000/PT3H10M15S\n",str) == 0);
icalproperty_free(p);
@@ -3032,7 +3181,7 @@ void test_rdate()
icalproperty_add_parameter(p,icalparameter_new_value(ICAL_VALUE_PERIOD));
str = icalproperty_as_ical_string(p);
printf("%s\n",str);
- assert(ttstrcmp("RDATE\n ;VALUE=DATE-TIME\n :19970101T120000\n",str) == 0);
+ assert(regrstrcmp("RDATE\n ;VALUE=DATE-TIME\n :19970101T120000\n",str) == 0);
icalproperty_free(p);
@@ -3043,7 +3192,7 @@ void test_rdate()
icalproperty_add_parameter(p,icalparameter_new_value(ICAL_VALUE_PERIOD));
str = icalproperty_as_ical_string(p);
printf("%s\n",str);
- assert(ttstrcmp("RDATE\n ;VALUE=PERIOD\n :19970101T120000/PT3H10M15S\n",str) == 0);
+ assert(regrstrcmp("RDATE\n ;VALUE=PERIOD\n :19970101T120000/PT3H10M15S\n",str) == 0);
icalproperty_free(p);
@@ -3054,7 +3203,7 @@ void test_rdate()
icalproperty_add_parameter(p,icalparameter_new_value(ICAL_VALUE_BINARY));
str = icalproperty_as_ical_string(p);
printf("%s\n",str);
- assert(ttstrcmp("RDATE\n ;VALUE=DATE-TIME\n :19970101T120000\n",str) == 0);
+ assert(regrstrcmp("RDATE\n ;VALUE=DATE-TIME\n :19970101T120000\n",str) == 0);
icalproperty_free(p);
@@ -3065,29 +3214,150 @@ void test_rdate()
icalproperty_add_parameter(p,icalparameter_new_value(ICAL_VALUE_BINARY));
str = icalproperty_as_ical_string(p);
printf("%s\n",str);
- assert(ttstrcmp("RDATE\n ;VALUE=PERIOD\n :19970101T120000/PT3H10M15S\n",str) == 0);
+ assert(regrstrcmp("RDATE\n ;VALUE=PERIOD\n :19970101T120000/PT3H10M15S\n",str) == 0);
icalproperty_free(p);
}
+void test_langbind()
+{
+ icalcomponent *c, *inner;
+ icalproperty *p;
+
+ static const char test_str[] =
+"BEGIN:VEVENT\n"
+"ATTENDEE;RSVP=TRUE;ROLE=REQ-PARTICIPANT;CUTYPE=GROUP:MAILTO:employee-A@host.com\n"
+"COMMENT: Comment that \n spans a line\n"
+"DTSTART:19970101T120000\n"
+"DTSTART:19970101T120000Z\n"
+"DTSTART:19970101\n"
+"DURATION:P3DT4H25M\n"
+"FREEBUSY:19970101T120000/19970101T120000\n"
+"FREEBUSY:19970101T120000/P3DT4H25M\n"
+"END:VEVENT\n";
+
+
+ printf("%s\n",test_str);
+
+ c = icalparser_parse_string(test_str);
+ inner = icalcomponent_get_inner(c);
+
+
+ for(
+ p = icallangbind_get_first_property(inner,"ANY");
+ p != 0;
+ p = icallangbind_get_next_property(inner,"ANY")
+ ) {
+
+ printf("%s\n",icallangbind_property_eval_string(p,":"));
+ }
+
+
+
+ p = icalcomponent_get_first_property(inner,ICAL_ATTENDEE_PROPERTY);
+
+ icalproperty_set_parameter_from_string(p,"CUTYPE","INDIVIDUAL");
+
+ printf("%s\n",icalproperty_as_ical_string(p));
+
+
+ icalproperty_set_value_from_string(p,"mary@foo.org","TEXT");
+
+ printf("%s\n",icalproperty_as_ical_string(p));
+
+}
+
+void test_property_parse()
+{
+ icalproperty *p;
+
+ p= icalproperty_new_from_string(
+ "ATTENDEE;RSVP=TRUE;ROLE=REQ-PARTICIPANT;CUTYPE=GROUP:MAILTO:employee-A@host.com");
+
+ assert (p != 0);
+ printf("%s\n",icalproperty_as_ical_string(p));
+
+
+ p= icalproperty_new_from_string("DTSTART:19970101T120000Z\n");
+
+ assert (p != 0);
+ printf("%s\n",icalproperty_as_ical_string(p));
+
+}
+
+
+void test_value_parameter()
+{
+
+ icalcomponent *c;
+ icalproperty *p;
+ icalparameter *param;
+
+ static const char test_icalcomp_str[] =
+"BEGIN:VEVENT\n"
+"DTSTART;VALUE=DATE-TIME:19971123T123000\n"
+"DTSTART;VALUE=DATE:19971123\n"
+"DTSTART;VALUE=FOO:19971123T123000\n"
+"END:VEVENT\n";
+
+ c = icalparser_parse_string ((char *) test_icalcomp_str);
+ if (!c) {
+ fprintf (stderr, "main(): could not parse the component\n");
+ exit (EXIT_FAILURE);
+ }
+
+ printf("%s",icalcomponent_as_ical_string(c));
+
+ p = icalcomponent_get_first_property(c,ICAL_DTSTART_PROPERTY);
+ param = icalproperty_get_first_parameter(p,ICAL_VALUE_PARAMETER);
+ assert(icalparameter_get_value(param) == ICAL_VALUE_DATETIME);
+
+ p = icalcomponent_get_next_property(c,ICAL_DTSTART_PROPERTY);
+ param = icalproperty_get_first_parameter(p,ICAL_VALUE_PARAMETER);
+ assert(icalparameter_get_value(param) == ICAL_VALUE_DATE);
+
+}
+
+
+void test_x_property()
+{
+ icalproperty *p;
+
+ p= icalproperty_new_from_string(
+ "X-LIC-PROPERTY: This is a note");
+
+ printf("%s\n",icalproperty_as_ical_string(p));
+
+ assert(icalproperty_isa(p) == ICAL_X_PROPERTY);
+ assert(regrstrcmp(icalproperty_get_x_name(p),"X-LIC-PROPERTY")==0);
+ assert(regrstrcmp(icalproperty_get_x(p)," This is a note")==0);
+
+}
+
int main(int argc, char *argv[])
{
int c;
extern char *optarg;
- extern int optind, optopt;
+ extern int optopt;
int errflg=0;
char* program_name = strrchr(argv[0],'/');
- int ttime=0, trecur=0,tspan=0, tmisc=0, tgauge = 0, tfile = 0;
+ int ttime=0, trecur=0,tspan=0, tmisc=0, tgauge = 0, tfile = 0,
+ tbasic = 0;
if(argc==1) {
- ttime = trecur = tspan = tmisc = tgauge = tfile = 1;
+ ttime = trecur = tspan = tmisc = tgauge = tfile = tbasic = 1;
}
- while ((c = getopt(argc, argv, "t:s:r:m:g:f:")) != -1) {
+ while ((c = getopt(argc, argv, "t:s:r:m:g:f:b:")) != -1) {
switch (c) {
+ case 'b': {
+ tbasic = atoi(optarg);
+ break;
+ }
+
case 't': {
ttime = atoi(optarg);
break;
@@ -3146,7 +3416,7 @@ int main(int argc, char *argv[])
printf("\n------------Test time----------------\n");
test_time();
}
-
+
if(ttime==1 || ttime==4){
printf("\n------------Test day of year---------\n");
test_doy();
@@ -3179,6 +3449,13 @@ int main(int argc, char *argv[])
test_recur_parameter_bug();
}
+ if(trecur==1 || trecur==5){
+ printf("\n------------Test Array Expansion---------\n");
+ test_expand_recurrence();
+ }
+
+
+
if(tspan==1 || tspan==2){
printf("\n------------Test FBlist------------\n");
@@ -3239,6 +3516,55 @@ int main(int argc, char *argv[])
test_rdate();
}
+ if(tmisc == 1 || tmisc == 6){
+
+ printf("\n------------Test language binding---------------\n");
+ test_langbind();
+ }
+
+
+ if(tmisc == 1 || tmisc == 7){
+
+ printf("\n------------Test property parser---------------\n");
+ test_property_parse();
+ }
+
+ if(tmisc == 1 || tmisc == 8){
+ printf("\n------------Test Action ------------------\n");
+ test_action();
+ }
+
+ if(tmisc == 1 || tmisc == 9){
+ printf("\n------------Test Value Parameter ------------------\n");
+ test_value_parameter();
+ }
+
+ if(tmisc == 1 || tmisc == 10){
+ printf("\n------------Test X property ------------------\n");
+ test_x_property();
+ }
+
+
+ if(tbasic == 1 || tbasic == 2){
+ printf("\n------------Test Values---------------\n");
+ test_values();
+ }
+
+ if(tbasic == 1 || tbasic == 3){
+ printf("\n------------Test Parameters-----------\n");
+ test_parameters();
+ }
+
+ if(tbasic == 1 || tbasic == 4){
+ printf("\n------------Test Properties-----------\n");
+ test_properties();
+ }
+
+ if(tbasic == 1 || tbasic == 5){
+ printf("\n------------Test Components ----------\n");
+ test_components();
+ }
+
if(tmisc == 1){
printf("\n------------Test Convenience ------------\n");
@@ -3262,18 +3588,6 @@ int main(int argc, char *argv[])
printf("\n------------Test Compare---------------\n");
test_compare();
- printf("\n------------Test Values---------------\n");
- test_values();
-
- printf("\n------------Test Parameters-----------\n");
- test_parameters();
-
- printf("\n------------Test Properties-----------\n");
- test_properties();
-
- printf("\n------------Test Components ----------\n");
- test_components();
-
printf("\n------------Create Components --------\n");
create_new_component();
diff --git a/libical/src/test/stow.c b/libical/src/test/stow.c
index 2570e3ad0c..e676c677f3 100644
--- a/libical/src/test/stow.c
+++ b/libical/src/test/stow.c
@@ -49,6 +49,10 @@ char* program_name;
void usage(char *message);
+#ifndef PATH_MAX
+#define PATH_MAX 256 /* HACK */
+#endif
+
enum options {
STORE_IN_FILE,
@@ -485,7 +489,7 @@ 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\
+-i\tSpecify input file. Otherwise, input comes 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\