diff options
Diffstat (limited to 'libical/src')
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\ |