[Commits] .cvsignore NONE 1.1.2.1 Makefile.am NONE 1.1.2.1 Makefile.in NONE 1.1.2.1 icalattendee.c NONE 1.1.2.1 icalattendee.h NONE 1.1.2.1 icalcomponent.c NONE 1.1.2.1 icalcomponent.h NONE 1.1.2.1 icalderivedparameter.c.in NONE 1.1.2.1 icalderivedparameter.h.in NONE 1.1.2.1 icalderivedproperty.c.in NONE 1.1.2.1 icalderivedproperty.h.in NONE 1.1.2.1 icalderivedvalue.c.in NONE 1.1.2.1 icalderivedvalue.h.in NONE 1.1.2.1 icalduration.c NONE 1.1.2.1 icalduration.h NONE 1.1.2.1 icalenums.c NONE 1.1.2.1 icalenums.h NONE 1.1.2.1 icalerror.c NONE 1.1.2.1 icalerror.h NONE 1.1.2.1 icallangbind.c NONE 1.1.2.1 icallangbind.h NONE 1.1.2.1 icallexer.l NONE 1.1.2.1 icalmemory.c NONE 1.1.2.1 icalmemory.h NONE 1.1.2.1 icalmime.c NONE 1.1.2.1 icalmime.h NONE 1.1.2.1 icalparameter.c NONE 1.1.2.1 icalparameter.h NONE 1.1.2.1 icalparameterimpl.h NONE 1.1.2.1 icalparser.c NONE 1.1.2.1 icalparser.h NONE 1.1.2.1 icalperiod.c NONE 1.1.2.1 icalperiod.h NONE 1.1.2.1 icalproperty.c NONE 1.1.2.1 icalproperty.h NONE 1.1.2.1 icalrecur.c NONE 1.1.2.1 icalrecur.h NONE 1.1.2.1 icalrestriction.c.in NONE 1.1.2.1 icalrestriction.h NONE 1.1.2.1 icaltime.c NONE 1.1.2.1 icaltime.h NONE 1.1.2.1 icaltypes.c NONE 1.1.2.1 icaltypes.h NONE 1.1.2.1 icalvalue.c NONE 1.1.2.1 icalvalue.h NONE 1.1.2.1 icalvalueimpl.h NONE 1.1.2.1 icalversion.h NONE 1.1.2.1 icalversion.h.in NONE 1.1.2.1 icalyacc.output NONE 1.1.2.1 icalyacc.y NONE 1.1.2.1 pvl.c NONE 1.1.2.1 pvl.h NONE 1.1.2.1 sspm.c NONE 1.1.2.1 sspm.h NONE 1.1.2.1 vsnprintf.c NONE 1.1.2.1
colin at claws-mail.org
colin at claws-mail.org
Wed Feb 13 21:50:32 CET 2013
Update of /home/claws-mail/claws/src/plugins/vcalendar/libical/libical
In directory srv:/tmp/cvs-serv22674/src/plugins/vcalendar/libical/libical
Added Files:
Tag: gtk2
.cvsignore Makefile.am Makefile.in icalattendee.c
icalattendee.h icalcomponent.c icalcomponent.h
icalderivedparameter.c.in icalderivedparameter.h.in
icalderivedproperty.c.in icalderivedproperty.h.in
icalderivedvalue.c.in icalderivedvalue.h.in icalduration.c
icalduration.h icalenums.c icalenums.h icalerror.c icalerror.h
icallangbind.c icallangbind.h icallexer.l icalmemory.c
icalmemory.h icalmime.c icalmime.h icalparameter.c
icalparameter.h icalparameterimpl.h icalparser.c icalparser.h
icalperiod.c icalperiod.h icalproperty.c icalproperty.h
icalrecur.c icalrecur.h icalrestriction.c.in icalrestriction.h
icaltime.c icaltime.h icaltypes.c icaltypes.h icalvalue.c
icalvalue.h icalvalueimpl.h icalversion.h icalversion.h.in
icalyacc.output icalyacc.y pvl.c pvl.h sspm.c sspm.h
vsnprintf.c
Log Message:
2013-02-13 [colin] 3.9.0cvs65
* src/plugins/address_dup_finder/placeholder.txt
* src/plugins/synce/placeholder.txt
Removed, deprecated plugins
* src/plugins/Makefile.am
* src/plugins/vcalendar/Makefile.am
* src/plugins/vcalendar/Makefile.in
* src/plugins/vcalendar/common-views.c
* src/plugins/vcalendar/common-views.h
* src/plugins/vcalendar/day-view.c
* src/plugins/vcalendar/icaltime_as_local.c
* src/plugins/vcalendar/icaltime_as_local.h
* src/plugins/vcalendar/month-view.c
* src/plugins/vcalendar/placeholder.txt
* src/plugins/vcalendar/plugin.c
* src/plugins/vcalendar/vcal_dbus.c
* src/plugins/vcalendar/vcal_dbus.h
* src/plugins/vcalendar/vcal_folder.c
* src/plugins/vcalendar/vcal_folder.h
* src/plugins/vcalendar/vcal_interface.h
* src/plugins/vcalendar/vcal_manager.c
* src/plugins/vcalendar/vcal_manager.h
* src/plugins/vcalendar/vcal_meeting_gtk.c
* src/plugins/vcalendar/vcal_meeting_gtk.h
* src/plugins/vcalendar/vcal_prefs.c
* src/plugins/vcalendar/vcal_prefs.h
* src/plugins/vcalendar/vcalendar.c
* src/plugins/vcalendar/vcalendar.h
* src/plugins/vcalendar/version.rc
* src/plugins/vcalendar/libical/.cvsignore
* src/plugins/vcalendar/libical/Makefile.am
* src/plugins/vcalendar/libical/Makefile.in
* src/plugins/vcalendar/libical/design-data/.cvsignore
* src/plugins/vcalendar/libical/design-data/Makefile.am
* src/plugins/vcalendar/libical/design-data/Makefile.in
* src/plugins/vcalendar/libical/design-data/parameters.csv
* src/plugins/vcalendar/libical/design-data/properties.csv
* src/plugins/vcalendar/libical/design-data/restrictions.csv
* src/plugins/vcalendar/libical/design-data/status.txt
* src/plugins/vcalendar/libical/design-data/value-types.csv
* src/plugins/vcalendar/libical/libical/.cvsignore
* src/plugins/vcalendar/libical/libical/Makefile.am
* src/plugins/vcalendar/libical/libical/Makefile.in
* src/plugins/vcalendar/libical/libical/icalattendee.c
* src/plugins/vcalendar/libical/libical/icalattendee.h
* src/plugins/vcalendar/libical/libical/icalcomponent.c
* src/plugins/vcalendar/libical/libical/icalcomponent.h
* src/plugins/vcalendar/libical/libical/icalderivedparameter.c.in
* src/plugins/vcalendar/libical/libical/icalderivedparameter.h.in
* src/plugins/vcalendar/libical/libical/icalderivedproperty.c.in
* src/plugins/vcalendar/libical/libical/icalderivedproperty.h.in
* src/plugins/vcalendar/libical/libical/icalderivedvalue.c.in
* src/plugins/vcalendar/libical/libical/icalderivedvalue.h.in
* src/plugins/vcalendar/libical/libical/icalduration.c
* src/plugins/vcalendar/libical/libical/icalduration.h
* src/plugins/vcalendar/libical/libical/icalenums.c
* src/plugins/vcalendar/libical/libical/icalenums.h
* src/plugins/vcalendar/libical/libical/icalerror.c
* src/plugins/vcalendar/libical/libical/icalerror.h
* src/plugins/vcalendar/libical/libical/icallangbind.c
* src/plugins/vcalendar/libical/libical/icallangbind.h
* src/plugins/vcalendar/libical/libical/icallexer.l
* src/plugins/vcalendar/libical/libical/icalmemory.c
* src/plugins/vcalendar/libical/libical/icalmemory.h
* src/plugins/vcalendar/libical/libical/icalmime.c
* src/plugins/vcalendar/libical/libical/icalmime.h
* src/plugins/vcalendar/libical/libical/icalparameter.c
* src/plugins/vcalendar/libical/libical/icalparameter.h
* src/plugins/vcalendar/libical/libical/icalparameterimpl.h
* src/plugins/vcalendar/libical/libical/icalparser.c
* src/plugins/vcalendar/libical/libical/icalparser.h
* src/plugins/vcalendar/libical/libical/icalperiod.c
* src/plugins/vcalendar/libical/libical/icalperiod.h
* src/plugins/vcalendar/libical/libical/icalproperty.c
* src/plugins/vcalendar/libical/libical/icalproperty.h
* src/plugins/vcalendar/libical/libical/icalrecur.c
* src/plugins/vcalendar/libical/libical/icalrecur.h
* src/plugins/vcalendar/libical/libical/icalrestriction.c.in
* src/plugins/vcalendar/libical/libical/icalrestriction.h
* src/plugins/vcalendar/libical/libical/icaltime.c
* src/plugins/vcalendar/libical/libical/icaltime.h
* src/plugins/vcalendar/libical/libical/icaltypes.c
* src/plugins/vcalendar/libical/libical/icaltypes.h
* src/plugins/vcalendar/libical/libical/icalvalue.c
* src/plugins/vcalendar/libical/libical/icalvalue.h
* src/plugins/vcalendar/libical/libical/icalvalueimpl.h
* src/plugins/vcalendar/libical/libical/icalversion.h
* src/plugins/vcalendar/libical/libical/icalversion.h.in
* src/plugins/vcalendar/libical/libical/icalyacc.output
* src/plugins/vcalendar/libical/libical/icalyacc.y
* src/plugins/vcalendar/libical/libical/pvl.c
* src/plugins/vcalendar/libical/libical/pvl.h
* src/plugins/vcalendar/libical/libical/sspm.c
* src/plugins/vcalendar/libical/libical/sspm.h
* src/plugins/vcalendar/libical/libical/vsnprintf.c
* src/plugins/vcalendar/libical/scripts/.cvsignore
* src/plugins/vcalendar/libical/scripts/Makefile.am
* src/plugins/vcalendar/libical/scripts/Makefile.in
* src/plugins/vcalendar/libical/scripts/mkderivedcomponents.pl
* src/plugins/vcalendar/libical/scripts/mkderivedparameters.pl
* src/plugins/vcalendar/libical/scripts/mkderivedproperties.pl
* src/plugins/vcalendar/libical/scripts/mkderivedvalues.pl
* src/plugins/vcalendar/libical/scripts/mkparameterrestrictions.pl
* src/plugins/vcalendar/libical/scripts/mkrestrictionrecords.pl
* src/plugins/vcalendar/libical/scripts/mkrestrictiontable.pl
* src/plugins/vcalendar/libical/scripts/readvaluesfile.pl
Add vcalendar.
--- NEW FILE: icalproperty.h ---
/* -*- Mode: C -*- */
/*======================================================================
FILE: icalproperty.h
CREATOR: eric 20 March 1999
$Id: icalproperty.h,v 1.1.2.1 2013-02-13 20:50:30 colin Exp $
$Locker: $
(C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
This program is free software; you can redistribute it and/or modify
it under the terms of either:
The LGPL as published by the Free Software Foundation, version
2.1, available at: http://www.fsf.org/copyleft/lesser.html
Or:
The Mozilla Public License Version 1.0. You may obtain a copy of
the License at http://www.mozilla.org/MPL/
The original code is icalparam.h
======================================================================*/
#ifndef ICALPROPERTY_H
#define ICALPROPERTY_H
#include <time.h>
#include "icalderivedparameter.h"
#include "icalvalue.h"
#include "icalrecur.h"
/* Actually in icalderivedproperty.h:
typedef void icalproperty; */
#include "icalderivedproperty.h" /* To get icalproperty_kind enumerations */
icalproperty* icalproperty_new(icalproperty_kind kind);
icalproperty* icalproperty_new_clone(icalproperty * prop);
icalproperty* icalproperty_new_from_string(char* str);
char* icalproperty_as_ical_string(icalproperty* prop);
void icalproperty_free(icalproperty* prop);
icalproperty_kind icalproperty_isa(icalproperty* property);
int icalproperty_isa_property(void* property);
void icalproperty_add_parameter(icalproperty* prop,icalparameter* parameter);
void icalproperty_set_parameter(icalproperty* prop,icalparameter* parameter);
void icalproperty_set_parameter_from_string(icalproperty* prop,
const char* name, const char* value);
const char* icalproperty_get_parameter_as_string(icalproperty* prop,
const char* name);
void icalproperty_remove_parameter(icalproperty* prop,
icalparameter_kind kind);
int icalproperty_count_parameters(icalproperty* prop);
/* Iterate through the parameters */
icalparameter* icalproperty_get_first_parameter(icalproperty* prop,
icalparameter_kind kind);
icalparameter* icalproperty_get_next_parameter(icalproperty* prop,
icalparameter_kind kind);
/* Access the value of the property */
void icalproperty_set_value(icalproperty* prop, icalvalue* value);
void icalproperty_set_value_from_string(icalproperty* prop,const char* value, const char* kind);
icalvalue* icalproperty_get_value(icalproperty* prop);
const char* icalproperty_get_value_as_string(icalproperty* prop);
/* Deal with X properties */
void icalproperty_set_x_name(icalproperty* prop, char* name);
char* icalproperty_get_x_name(icalproperty* prop);
/* Return the name of the property -- the type name converted to a
string, or the value of _get_x_name if the type is and X property */
char* icalproperty_get_name (icalproperty* prop);
icalvalue_kind icalparameter_value_to_value_kind(icalparameter_value value);
/* Convert kinds to string and get default value type */
icalvalue_kind icalproperty_kind_to_value_kind(icalproperty_kind kind);
icalvalue_kind icalproperty_value_kind_to_kind(icalvalue_kind kind);
const char* icalproperty_kind_to_string(icalproperty_kind kind);
icalproperty_kind icalproperty_string_to_kind(const char* string);
icalproperty_method icalproperty_string_to_method(const char* str);
const char* icalproperty_method_to_string(icalproperty_method method);
const char* icalproperty_enum_to_string(int e);
int icalproperty_string_to_enum(const char* str);
const char* icalproperty_status_to_string(icalproperty_status);
icalproperty_status icalproperty_string_to_status(const char* string);
int icalproperty_enum_belongs_to_property(icalproperty_kind kind, int e);
#endif /*ICALPROPERTY_H*/
--- NEW FILE: Makefile.am ---
#======================================================================
# FILE: Makefile.am
# CREATOR: eric
#
# $Id: Makefile.am,v 1.1.2.1 2013-02-13 20:50:29 colin 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)/src/plugins/vcalendar/libical/design-data
ICALSCRIPTS = $(top_srcdir)/src/plugins/vcalendar/libical/scripts
noinst_LTLIBRARIES = libical.la
YFLAGS = -d -v -t -pical_yy
LFLAGS = -Pical_yy
LEX_OUTPUT_ROOT = lex.ical_yy
INCLUDES = \
-I$(top_builddir) \
-I$(top_srcdir) \
-I$(top_builddir) \
-I$(srcdir) \
-I$(top_srcdir)/src/plugins/vcalendar/libical \
-I$(top_srcdir)/src/plugins/vcalendar/libical/libical
libical_la_LDFLAGS = -version-info 0:0:0
libical_la_SOURCES = \
icalattendee.h \
icalattendee.c \
icalcomponent.c \
icalcomponent.h \
icalenums.c \
icalenums.h \
icalerror.c \
icalerror.h \
icallexer.l \
icalmemory.c \
icalmemory.h \
icalmime.c \
icalmime.h \
icalparameter.c \
icalparameter.h \
icalparameterimpl.h \
icalderivedparameter.c \
icalderivedparameter.h \
icalparser.c \
icalparser.h \
icalderivedproperty.c \
icalderivedproperty.h \
icalproperty.c \
icalproperty.h \
icalrecur.c \
icalrecur.h \
icalrestriction.c \
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 \
pvl.h \
sspm.c \
sspm.h \
vsnprintf.c \
icallangbind.h
libicalincludedir = $(includedir)/claws-mail/plugins/@PACKAGE@
libicalinclude_HEADERS = ical.h
# ORDERING OF HEADERS IS SIGNIFICANT. Don't change this ordering. It
# is required to make the combined header ical.h properly
COMBINEDHEADERS = \
$(top_builddir)/src/plugins/vcalendar/libical/libical/icalversion.h \
$(top_srcdir)/src/plugins/vcalendar/libical/libical/icaltime.h \
$(top_srcdir)/src/plugins/vcalendar/libical/libical/icalduration.h \
$(top_srcdir)/src/plugins/vcalendar/libical/libical/icalperiod.h \
$(top_srcdir)/src/plugins/vcalendar/libical/libical/icalenums.h \
$(top_srcdir)/src/plugins/vcalendar/libical/libical/icaltypes.h \
$(top_srcdir)/src/plugins/vcalendar/libical/libical/icalrecur.h \
icalderivedvalue.h \
icalderivedparameter.h \
icalvalue.h \
icalparameter.h \
icalderivedproperty.h \
icalproperty.h \
$(top_srcdir)/src/plugins/vcalendar/libical/libical/icalattendee.h \
$(top_srcdir)/src/plugins/vcalendar/libical/libical/pvl.h \
$(top_srcdir)/src/plugins/vcalendar/libical/libical/icalcomponent.h \
$(top_srcdir)/src/plugins/vcalendar/libical/libical/icalparser.h \
$(top_srcdir)/src/plugins/vcalendar/libical/libical/icalmemory.h \
$(top_srcdir)/src/plugins/vcalendar/libical/libical/icalerror.h \
$(top_srcdir)/src/plugins/vcalendar/libical/libical/icalrestriction.h \
$(top_srcdir)/src/plugins/vcalendar/libical/libical/sspm.h \
$(top_srcdir)/src/plugins/vcalendar/libical/libical/icalmime.h \
$(top_srcdir)/src/plugins/vcalendar/libical/libical/icallangbind.h
BUILT_SOURCES = \
ical.h \
icalderivedparameter.c \
icalderivedparameter.h \
icalderivedproperty.c \
icalderivedproperty.h \
icalrestriction.c \
icalderivedvalue.c \
icalderivedvalue.h
ical.h: $(COMBINEDHEADERS)
cat $(COMBINEDHEADERS) \
| egrep -v "#include.*\"ical" \
| egrep -v "#include.*\"pvl\.h\"" > ical.h
icallexer.c : icalyacc.h
# parameters
PARAMETERDEPS = \
$(ICALSCRIPTS)/mkderivedparameters.pl \
$(DESIGNDATA)/parameters.csv \
icalderivedparameter.c.in \
icalderivedparameter.h.in
icalderivedparameter.h: $(PARAMETERDEPS)
$(PERL) -I $(ICALSCRIPTS) $(ICALSCRIPTS)/mkderivedparameters.pl -i $(srcdir)/icalderivedparameter.h.in -h $(DESIGNDATA)/parameters.csv > icalderivedparameter.h
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)/properties.csv \
$(DESIGNDATA)/value-types.csv \
icalderivedproperty.c.in \
icalderivedproperty.h.in
icalderivedproperty.h: $(PROPERTYDEPS)
$(PERL) -I$(ICALSCRIPTS) $(ICALSCRIPTS)/mkderivedproperties.pl \
-i $(srcdir)/icalderivedproperty.h.in -h $(DESIGNDATA)/properties.csv\
${DESIGNDATA}/value-types.csv > icalderivedproperty.h
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
RESTRICTIONDEPS = \
$(ICALSCRIPTS)/mkrestrictiontable.pl \
$(DESIGNDATA)/restrictions.csv \
icalrestriction.c.in
icalrestriction.c: $(RESTRICTIONDEPS)
$(PERL) $(ICALSCRIPTS)/mkrestrictiontable.pl -i $(srcdir)/icalrestriction.c.in \
$(DESIGNDATA)/restrictions.csv > icalrestriction.c
# values
VALUEDEPS = \
$(ICALSCRIPTS)/mkderivedvalues.pl \
$(DESIGNDATA)/value-types.csv \
icalderivedvalue.c.in \
icalderivedvalue.h.in
icalderivedvalue.h: $(VALUEDEPS)
$(PERL) -I$(ICALSCRIPTS) $(ICALSCRIPTS)/mkderivedvalues.pl \
-i $(srcdir)/icalderivedvalue.h.in -h $(DESIGNDATA)/value-types.csv > icalderivedvalue.h
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)
EXTRA_DIST = \
icalderivedparameter.c.in \
icalderivedparameter.h.in \
icalderivedproperty.c.in \
icalderivedproperty.h.in \
icalrestriction.c.in \
icalderivedvalue.c.in \
icalderivedvalue.h.in \
icalversion.h.in \
icallexer.c \
icalyacc.c
AM_CPPFLAGS = -DNDEBUG $(GLIB_CFLAGS)
--- NEW FILE: icalyacc.output ---
Nonterminals useless in grammar
trigger
Terminals unused in grammar
FLOATNUMBER
STRING
EOL
EQUALS
CHARACTER
COLON
COMMA
SEMICOLON
MINUS
TIMESEPERATOR
TRUE
FALSE
FREQ
BYDAY
BYHOUR
BYMINUTE
BYMONTH
BYMONTHDAY
BYSECOND
BYSETPOS
BYWEEKNO
BYYEARDAY
DAILY
MINUTELY
MONTHLY
SECONDLY
WEEKLY
HOURLY
YEARLY
INTERVAL
COUNT
UNTIL
WKST
MO
SA
SU
TU
WE
TH
FR
BIT8
ACCEPTED
ADD
AUDIO
BASE64
BINARY
BOOLEAN
BUSY
BUSYTENTATIVE
BUSYUNAVAILABLE
CALADDRESS
CANCEL
CANCELLED
CHAIR
CHILD
COMPLETED
CONFIDENTIAL
CONFIRMED
COUNTER
DATE
DATETIME
DECLINECOUNTER
DECLINED
DELEGATED
DISPLAY
DRAFT
DURATION
EMAIL
END
FINAL
FLOAT
FREE
GREGORIAN
GROUP
INDIVIDUAL
INPROCESS
INTEGER
NEEDSACTION
NONPARTICIPANT
OPAQUE
OPTPARTICIPANT
PARENT
PERIOD
PRIVATE
PROCEDURE
PUBLIC
PUBLISH
RECUR
REFRESH
REPLY
REQPARTICIPANT
REQUEST
RESOURCE
ROOM
SIBLING
START
TENTATIVE
TEXT
THISANDFUTURE
THISANDPRIOR
TIME
TRANSPAENT
UNKNOWN
UTCOFFSET
XNAME
ALTREP
CN
CUTYPE
DAYLIGHT
DIR
ENCODING
EVENT
FBTYPE
FMTTYPE
LANGUAGE
MEMBER
PARTSTAT
RANGE
RELATED
RELTYPE
ROLE
RSVP
SENTBY
STANDARD
URI
CHARSET
Rules useless in grammar
37 trigger: /* empty */
Grammar
0 $accept: value $end
1 value: date_value
2 | datetime_value
3 | duration_value
4 | period_value
5 | utcoffset_value
6 | error
7 date_value: DIGITS
8 utc_char: /* empty */
9 | UTC_CHAR
10 utc_char_b: /* empty */
11 | UTC_CHAR
12 datetime_value: DIGITS TIME_CHAR DIGITS utc_char
13 dur_date: dur_day
14 | dur_day dur_time
15 dur_week: DIGITS 'W'
16 dur_time: TIME_CHAR dur_hour
17 | TIME_CHAR dur_minute
18 | TIME_CHAR dur_second
19 dur_hour: DIGITS 'H'
20 | DIGITS 'H' dur_minute
21 dur_minute: DIGITS 'M'
22 | DIGITS 'M' dur_second
23 dur_second: DIGITS 'S'
24 dur_day: DIGITS 'D'
25 dur_prefix: /* empty */
26 | '+'
27 | '-'
28 duration_value: dur_prefix 'P' dur_date
29 | dur_prefix 'P' dur_time
30 | dur_prefix 'P' dur_week
31 period_value: DIGITS TIME_CHAR DIGITS utc_char '/' DIGITS TIME_CHAR DIGITS utc_char_b
32 | DIGITS TIME_CHAR DIGITS utc_char '/' duration_value
33 plusminus: '+'
34 | '-'
35 utcoffset_value: plusminus INTNUMBER INTNUMBER
36 | plusminus INTNUMBER INTNUMBER INTNUMBER
Terminals, with rules where they appear
$end (0) 0
'+' (43) 26 33
'-' (45) 27 34
'/' (47) 31 32
'D' (68) 24
'H' (72) 19 20
'M' (77) 21 22
'P' (80) 28 29 30
'S' (83) 23
'W' (87) 15
error (256) 6
DIGITS (258) 7 12 15 19 20 21 22 23 24 31 32
INTNUMBER (259) 35 36
FLOATNUMBER (260)
STRING (261)
EOL (262)
EQUALS (263)
CHARACTER (264)
COLON (265)
COMMA (266)
SEMICOLON (267)
MINUS (268)
TIMESEPERATOR (269)
TRUE (270)
FALSE (271)
FREQ (272)
BYDAY (273)
BYHOUR (274)
BYMINUTE (275)
BYMONTH (276)
BYMONTHDAY (277)
BYSECOND (278)
BYSETPOS (279)
BYWEEKNO (280)
BYYEARDAY (281)
DAILY (282)
MINUTELY (283)
MONTHLY (284)
SECONDLY (285)
WEEKLY (286)
HOURLY (287)
YEARLY (288)
INTERVAL (289)
COUNT (290)
UNTIL (291)
WKST (292)
MO (293)
SA (294)
SU (295)
TU (296)
WE (297)
TH (298)
FR (299)
BIT8 (300)
ACCEPTED (301)
ADD (302)
AUDIO (303)
BASE64 (304)
BINARY (305)
BOOLEAN (306)
BUSY (307)
BUSYTENTATIVE (308)
BUSYUNAVAILABLE (309)
CALADDRESS (310)
CANCEL (311)
CANCELLED (312)
CHAIR (313)
CHILD (314)
COMPLETED (315)
CONFIDENTIAL (316)
CONFIRMED (317)
COUNTER (318)
DATE (319)
DATETIME (320)
DECLINECOUNTER (321)
DECLINED (322)
DELEGATED (323)
DISPLAY (324)
DRAFT (325)
DURATION (326)
EMAIL (327)
END (328)
FINAL (329)
FLOAT (330)
FREE (331)
GREGORIAN (332)
GROUP (333)
INDIVIDUAL (334)
INPROCESS (335)
INTEGER (336)
NEEDSACTION (337)
NONPARTICIPANT (338)
OPAQUE (339)
OPTPARTICIPANT (340)
PARENT (341)
PERIOD (342)
PRIVATE (343)
PROCEDURE (344)
PUBLIC (345)
PUBLISH (346)
RECUR (347)
REFRESH (348)
REPLY (349)
REQPARTICIPANT (350)
REQUEST (351)
RESOURCE (352)
ROOM (353)
SIBLING (354)
START (355)
TENTATIVE (356)
TEXT (357)
THISANDFUTURE (358)
THISANDPRIOR (359)
TIME (360)
TRANSPAENT (361)
UNKNOWN (362)
UTCOFFSET (363)
XNAME (364)
ALTREP (365)
CN (366)
CUTYPE (367)
DAYLIGHT (368)
DIR (369)
ENCODING (370)
EVENT (371)
FBTYPE (372)
FMTTYPE (373)
LANGUAGE (374)
MEMBER (375)
PARTSTAT (376)
RANGE (377)
RELATED (378)
RELTYPE (379)
ROLE (380)
RSVP (381)
SENTBY (382)
STANDARD (383)
URI (384)
CHARSET (385)
TIME_CHAR (386) 12 16 17 18 31 32
UTC_CHAR (387) 9 11
Nonterminals, with rules where they appear
$accept (142)
on left: 0
value (143)
on left: 1 2 3 4 5 6, on right: 0
date_value (144)
on left: 7, on right: 1
utc_char (145)
on left: 8 9, on right: 12 31 32
utc_char_b (146)
on left: 10 11, on right: 31
datetime_value (147)
on left: 12, on right: 2
dur_date (148)
on left: 13 14, on right: 28
dur_week (149)
on left: 15, on right: 30
dur_time (150)
on left: 16 17 18, on right: 14 29
dur_hour (151)
on left: 19 20, on right: 16
dur_minute (152)
on left: 21 22, on right: 17 20
dur_second (153)
on left: 23, on right: 18 22
dur_day (154)
on left: 24, on right: 13 14
dur_prefix (155)
on left: 25 26 27, on right: 28 29 30
duration_value (156)
on left: 28 29 30, on right: 3 32
period_value (157)
on left: 31 32, on right: 4
plusminus (158)
on left: 33 34, on right: 35 36
utcoffset_value (159)
on left: 35 36, on right: 5
state 0
0 $accept: . value $end
error shift, and go to state 1
DIGITS shift, and go to state 2
'+' shift, and go to state 3
'-' shift, and go to state 4
'P' reduce using rule 25 (dur_prefix)
value go to state 5
date_value go to state 6
datetime_value go to state 7
dur_prefix go to state 8
duration_value go to state 9
period_value go to state 10
plusminus go to state 11
utcoffset_value go to state 12
state 1
6 value: error .
$default reduce using rule 6 (value)
state 2
7 date_value: DIGITS .
12 datetime_value: DIGITS . TIME_CHAR DIGITS utc_char
31 period_value: DIGITS . TIME_CHAR DIGITS utc_char '/' DIGITS TIME_CHAR DIGITS utc_char_b
32 | DIGITS . TIME_CHAR DIGITS utc_char '/' duration_value
TIME_CHAR shift, and go to state 13
$default reduce using rule 7 (date_value)
state 3
26 dur_prefix: '+' .
33 plusminus: '+' .
INTNUMBER reduce using rule 33 (plusminus)
$default reduce using rule 26 (dur_prefix)
state 4
27 dur_prefix: '-' .
34 plusminus: '-' .
INTNUMBER reduce using rule 34 (plusminus)
$default reduce using rule 27 (dur_prefix)
state 5
0 $accept: value . $end
$end shift, and go to state 14
state 6
1 value: date_value .
$default reduce using rule 1 (value)
state 7
2 value: datetime_value .
$default reduce using rule 2 (value)
state 8
28 duration_value: dur_prefix . 'P' dur_date
29 | dur_prefix . 'P' dur_time
30 | dur_prefix . 'P' dur_week
'P' shift, and go to state 15
state 9
3 value: duration_value .
$default reduce using rule 3 (value)
state 10
4 value: period_value .
$default reduce using rule 4 (value)
state 11
35 utcoffset_value: plusminus . INTNUMBER INTNUMBER
36 | plusminus . INTNUMBER INTNUMBER INTNUMBER
INTNUMBER shift, and go to state 16
state 12
5 value: utcoffset_value .
$default reduce using rule 5 (value)
state 13
12 datetime_value: DIGITS TIME_CHAR . DIGITS utc_char
31 period_value: DIGITS TIME_CHAR . DIGITS utc_char '/' DIGITS TIME_CHAR DIGITS utc_char_b
32 | DIGITS TIME_CHAR . DIGITS utc_char '/' duration_value
DIGITS shift, and go to state 17
state 14
0 $accept: value $end .
$default accept
state 15
28 duration_value: dur_prefix 'P' . dur_date
29 | dur_prefix 'P' . dur_time
30 | dur_prefix 'P' . dur_week
DIGITS shift, and go to state 18
TIME_CHAR shift, and go to state 19
dur_date go to state 20
dur_week go to state 21
dur_time go to state 22
dur_day go to state 23
state 16
35 utcoffset_value: plusminus INTNUMBER . INTNUMBER
36 | plusminus INTNUMBER . INTNUMBER INTNUMBER
INTNUMBER shift, and go to state 24
state 17
12 datetime_value: DIGITS TIME_CHAR DIGITS . utc_char
31 period_value: DIGITS TIME_CHAR DIGITS . utc_char '/' DIGITS TIME_CHAR DIGITS utc_char_b
32 | DIGITS TIME_CHAR DIGITS . utc_char '/' duration_value
UTC_CHAR shift, and go to state 25
$default reduce using rule 8 (utc_char)
utc_char go to state 26
state 18
15 dur_week: DIGITS . 'W'
24 dur_day: DIGITS . 'D'
'W' shift, and go to state 27
'D' shift, and go to state 28
state 19
16 dur_time: TIME_CHAR . dur_hour
17 | TIME_CHAR . dur_minute
18 | TIME_CHAR . dur_second
DIGITS shift, and go to state 29
dur_hour go to state 30
dur_minute go to state 31
dur_second go to state 32
state 20
28 duration_value: dur_prefix 'P' dur_date .
$default reduce using rule 28 (duration_value)
state 21
30 duration_value: dur_prefix 'P' dur_week .
$default reduce using rule 30 (duration_value)
state 22
29 duration_value: dur_prefix 'P' dur_time .
$default reduce using rule 29 (duration_value)
state 23
13 dur_date: dur_day .
14 | dur_day . dur_time
TIME_CHAR shift, and go to state 19
$default reduce using rule 13 (dur_date)
dur_time go to state 33
state 24
35 utcoffset_value: plusminus INTNUMBER INTNUMBER .
36 | plusminus INTNUMBER INTNUMBER . INTNUMBER
INTNUMBER shift, and go to state 34
$default reduce using rule 35 (utcoffset_value)
state 25
9 utc_char: UTC_CHAR .
$default reduce using rule 9 (utc_char)
state 26
12 datetime_value: DIGITS TIME_CHAR DIGITS utc_char .
31 period_value: DIGITS TIME_CHAR DIGITS utc_char . '/' DIGITS TIME_CHAR DIGITS utc_char_b
32 | DIGITS TIME_CHAR DIGITS utc_char . '/' duration_value
'/' shift, and go to state 35
$default reduce using rule 12 (datetime_value)
state 27
15 dur_week: DIGITS 'W' .
$default reduce using rule 15 (dur_week)
state 28
24 dur_day: DIGITS 'D' .
$default reduce using rule 24 (dur_day)
state 29
19 dur_hour: DIGITS . 'H'
20 | DIGITS . 'H' dur_minute
21 dur_minute: DIGITS . 'M'
22 | DIGITS . 'M' dur_second
23 dur_second: DIGITS . 'S'
'H' shift, and go to state 36
'M' shift, and go to state 37
'S' shift, and go to state 38
state 30
16 dur_time: TIME_CHAR dur_hour .
$default reduce using rule 16 (dur_time)
state 31
17 dur_time: TIME_CHAR dur_minute .
$default reduce using rule 17 (dur_time)
state 32
18 dur_time: TIME_CHAR dur_second .
$default reduce using rule 18 (dur_time)
state 33
14 dur_date: dur_day dur_time .
$default reduce using rule 14 (dur_date)
state 34
36 utcoffset_value: plusminus INTNUMBER INTNUMBER INTNUMBER .
$default reduce using rule 36 (utcoffset_value)
state 35
31 period_value: DIGITS TIME_CHAR DIGITS utc_char '/' . DIGITS TIME_CHAR DIGITS utc_char_b
32 | DIGITS TIME_CHAR DIGITS utc_char '/' . duration_value
DIGITS shift, and go to state 39
'+' shift, and go to state 40
'-' shift, and go to state 41
$default reduce using rule 25 (dur_prefix)
dur_prefix go to state 8
duration_value go to state 42
state 36
19 dur_hour: DIGITS 'H' .
20 | DIGITS 'H' . dur_minute
DIGITS shift, and go to state 43
$default reduce using rule 19 (dur_hour)
dur_minute go to state 44
state 37
21 dur_minute: DIGITS 'M' .
22 | DIGITS 'M' . dur_second
DIGITS shift, and go to state 45
$default reduce using rule 21 (dur_minute)
dur_second go to state 46
state 38
23 dur_second: DIGITS 'S' .
$default reduce using rule 23 (dur_second)
state 39
31 period_value: DIGITS TIME_CHAR DIGITS utc_char '/' DIGITS . TIME_CHAR DIGITS utc_char_b
TIME_CHAR shift, and go to state 47
state 40
26 dur_prefix: '+' .
$default reduce using rule 26 (dur_prefix)
state 41
27 dur_prefix: '-' .
$default reduce using rule 27 (dur_prefix)
state 42
32 period_value: DIGITS TIME_CHAR DIGITS utc_char '/' duration_value .
$default reduce using rule 32 (period_value)
state 43
21 dur_minute: DIGITS . 'M'
22 | DIGITS . 'M' dur_second
'M' shift, and go to state 37
state 44
20 dur_hour: DIGITS 'H' dur_minute .
$default reduce using rule 20 (dur_hour)
state 45
23 dur_second: DIGITS . 'S'
'S' shift, and go to state 38
state 46
22 dur_minute: DIGITS 'M' dur_second .
$default reduce using rule 22 (dur_minute)
state 47
31 period_value: DIGITS TIME_CHAR DIGITS utc_char '/' DIGITS TIME_CHAR . DIGITS utc_char_b
DIGITS shift, and go to state 48
state 48
31 period_value: DIGITS TIME_CHAR DIGITS utc_char '/' DIGITS TIME_CHAR DIGITS . utc_char_b
UTC_CHAR shift, and go to state 49
$default reduce using rule 10 (utc_char_b)
utc_char_b go to state 50
state 49
11 utc_char_b: UTC_CHAR .
$default reduce using rule 11 (utc_char_b)
state 50
31 period_value: DIGITS TIME_CHAR DIGITS utc_char '/' DIGITS TIME_CHAR DIGITS utc_char_b .
$default reduce using rule 31 (period_value)
--- NEW FILE: icalderivedparameter.c.in ---
/* -*- Mode: C -*-
======================================================================
FILE: icalderivedparameters.{c,h}
CREATOR: eric 09 May 1999
$Id: icalderivedparameter.c.in,v 1.1.2.1 2013-02-13 20:50:29 colin Exp $
$Locker: $
(C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
This program is free software; you can redistribute it and/or modify
it under the terms of either:
The LGPL as published by the Free Software Foundation, version
2.1, available at: http://www.fsf.org/copyleft/lesser.html
Or:
The Mozilla Public License Version 1.0. You may obtain a copy of
the License at http://www.mozilla.org/MPL/
The original code is icalderivedparameters.{c,h}
Contributions from:
Graham Davison (g.m.davison at computer.org)
======================================================================*/
/*#line 29 "icalparameter.c.in"*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "icalparameter.h"
#include "icalparameterimpl.h"
#include "icalproperty.h"
#include "icalerror.h"
#include "icalmemory.h"
#include <stdlib.h> /* for malloc() */
#include <errno.h>
#include <string.h> /* for memset() */
icalvalue_kind icalparameter_value_to_value_kind(icalparameter_value value);
struct icalparameter_impl* icalparameter_new_impl(icalparameter_kind kind);
/* This map associates each of the parameters with the string
representation of the paramter's name */
struct icalparameter_kind_map {
icalparameter_kind kind;
char *name;
};
static struct icalparameter_kind_map parameter_map[];
const char* icalparameter_kind_to_string(icalparameter_kind kind)
{
int i;
for (i=0; parameter_map[i].kind != ICAL_NO_PARAMETER; i++) {
if (parameter_map[i].kind == kind) {
return parameter_map[i].name;
}
}
return 0;
}
icalparameter_kind icalparameter_string_to_kind(const char* string)
{
int i;
if (string ==0 ) {
return ICAL_NO_PARAMETER;
}
for (i=0; parameter_map[i].kind != ICAL_NO_PARAMETER; i++) {
if (strcmp(parameter_map[i].name, string) == 0) {
return parameter_map[i].kind;
}
}
if(strncmp(string,"X-",2)==0){
return ICAL_X_PARAMETER;
}
return ICAL_NO_PARAMETER;
}
/* This map associates the enumerations for the VALUE parameter with
the kinds of VALUEs. */
struct icalparameter_value_kind_map {
icalparameter_value value;
icalvalue_kind kind;
};
static struct icalparameter_value_kind_map value_kind_map[];
icalvalue_kind icalparameter_value_to_value_kind(icalparameter_value value)
{
int i;
for (i=0; value_kind_map[i].kind != ICAL_NO_VALUE; i++) {
if (value_kind_map[i].value == value) {
return value_kind_map[i].kind;
}
}
return ICAL_NO_VALUE;
}
/* This map associates the parameter enumerations with a specific parameter and the string representation of the enumeration */
struct icalparameter_map {
icalparameter_kind kind;
int enumeration;
const char* str;
};
static struct icalparameter_map icalparameter_map[];
const char* icalparameter_enum_to_string(int e)
{
int i;
icalerror_check_arg_rz(e >= ICALPARAMETER_FIRST_ENUM,"e");
icalerror_check_arg_rz(e <= ICALPARAMETER_LAST_ENUM,"e");
for (i=0; icalparameter_map[i].kind != ICAL_NO_PARAMETER; i++){
if(e == icalparameter_map[i].enumeration){
return icalparameter_map[i].str;
}
}
return 0;
}
int icalparameter_string_to_enum(const char* str)
{
int i;
icalerror_check_arg_rz(str != 0,"str");
for (i=0; icalparameter_map[i].kind != ICAL_NO_PARAMETER; i++){
if(strcmp(str,icalparameter_map[i].str) == 0) {
return icalparameter_map[i].enumeration;
}
}
return 0;
}
icalparameter* icalparameter_new_from_value_string(icalparameter_kind kind,const char* val)
{
struct icalparameter_impl* param=0;
int found_kind = 0;
int i;
icalerror_check_arg_rz((val!=0),"val");
/* Search through the parameter map to find a matching kind */
param = icalparameter_new_impl(kind);
for (i=0; icalparameter_map[i].kind != ICAL_NO_PARAMETER; i++){
if(kind == icalparameter_map[i].kind) {
found_kind = 1;
if(strcmp(val,icalparameter_map[i].str) == 0) {
param->data = (int)icalparameter_map[i].enumeration;
return param;
}
}
}
if(found_kind == 1){
/* The kind was in the parameter map, but the string did not
match, so assume that it is an alternate value, like an
X-value.*/
icalparameter_set_xvalue(param, val);
} else {
/* If the kind was not found, then it must be a string type */
((struct icalparameter_impl*)param)->string = icalmemory_strdup(val);
}
return param;
}
/* Everything below this line is machine generated. Do not edit. */
--- NEW FILE: icalproperty.c ---
/* -*- Mode: C -*- */
/*======================================================================
FILE: icalproperty.c
CREATOR: eric 28 April 1999
$Id: icalproperty.c,v 1.1.2.1 2013-02-13 20:50:30 colin 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 icalproperty.c
======================================================================*/
/*#line 27 "icalproperty.c.in"*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "icalproperty.h"
#include "icalparameter.h"
#include "icalcomponent.h"
#include "pvl.h"
#include "icalenums.h"
#include "icalerror.h"
#include "icalmemory.h"
#include "icalparser.h"
#include <string.h> /* For icalmemory_strdup, rindex */
#include <assert.h>
#include <stdlib.h>
#include <errno.h>
#include <stdio.h> /* for printf */
#include <stdarg.h> /* for va_list, va_start, etc. */
#define TMP_BUF_SIZE 1024
/* Private routines for icalproperty */
void icalvalue_set_parent(icalvalue* value,
icalproperty* property);
icalproperty* icalvalue_get_parent(icalvalue* value);
void icalparameter_set_parent(icalparameter* param,
icalproperty* property);
icalproperty* icalparameter_get_parent(icalparameter* value);
void icalproperty_set_x_name(icalproperty* prop, char* name);
struct icalproperty_impl
{
char id[5];
icalproperty_kind kind;
char* x_name;
pvl_list parameters;
pvl_elem parameter_iterator;
icalvalue* value;
icalcomponent *parent;
};
void icalproperty_add_parameters(struct icalproperty_impl *prop,va_list args)
{
void* vp;
struct icalproperty_impl *impl = (struct icalproperty_impl*)prop;
while((vp = va_arg(args, void*)) != 0) {
if (icalvalue_isa_value(vp) != 0 ){
} else if (icalparameter_isa_parameter(vp) != 0 ){
icalproperty_add_parameter((icalproperty*)impl,
(icalparameter*)vp);
} else {
assert(0);
}
}
}
struct icalproperty_impl*
icalproperty_new_impl (icalproperty_kind kind)
{
struct icalproperty_impl* prop;
if ( ( prop = (struct icalproperty_impl*)
malloc(sizeof(struct icalproperty_impl))) == 0) {
icalerror_set_errno(ICAL_NEWFAILED_ERROR);
return 0;
}
strcpy(prop->id,"prop");
prop->kind = kind;
prop->parameters = pvl_newlist();
prop->parameter_iterator = 0;
prop->value = 0;
prop->x_name = 0;
prop->parent = 0;
return prop;
}
icalproperty*
icalproperty_new (icalproperty_kind kind)
{
if(kind == ICAL_NO_PROPERTY){
return 0;
}
return (icalproperty*)icalproperty_new_impl(kind);
}
icalproperty*
icalproperty_new_clone(icalproperty* prop)
{
struct icalproperty_impl *old = (struct icalproperty_impl*)prop;
struct icalproperty_impl *new = icalproperty_new_impl(old->kind);
pvl_elem p;
icalerror_check_arg_rz((prop!=0),"Prop");
icalerror_check_arg_rz((old!=0),"old");
icalerror_check_arg_rz((new!=0),"new");
if (old->value !=0) {
new->value = icalvalue_new_clone(old->value);
}
if (old->x_name != 0) {
new->x_name = icalmemory_strdup(old->x_name);
if (new->x_name == 0) {
icalproperty_free(new);
icalerror_set_errno(ICAL_NEWFAILED_ERROR);
return 0;
}
}
for(p=pvl_head(old->parameters);p != 0; p = pvl_next(p)){
icalparameter *param = icalparameter_new_clone(pvl_data(p));
if (param == 0){
icalproperty_free(new);
icalerror_set_errno(ICAL_NEWFAILED_ERROR);
return 0;
}
pvl_push(new->parameters,param);
}
return new;
}
icalproperty* icalproperty_new_from_string(char* str)
{
size_t buf_size = 1024;
char* buf = icalmemory_new_buffer(buf_size);
char* buf_ptr = buf;
icalproperty *prop;
icalcomponent *comp;
int errors = 0;
icalerror_check_arg_rz( (str!=0),"str");
/* Is this a HACK or a crafty reuse of code? */
icalmemory_append_string(&buf, &buf_ptr, &buf_size, "BEGIN:VCALENDAR\n");
icalmemory_append_string(&buf, &buf_ptr, &buf_size, str);
icalmemory_append_string(&buf, &buf_ptr, &buf_size, "\n");
icalmemory_append_string(&buf, &buf_ptr, &buf_size, "END:VCALENDAR\n");
comp = icalparser_parse_string(buf);
if(comp == 0){
icalerror_set_errno(ICAL_PARSE_ERROR);
return 0;
}
errors = icalcomponent_count_errors(comp);
prop = icalcomponent_get_first_property(comp,ICAL_ANY_PROPERTY);
icalcomponent_remove_property(comp,prop);
icalcomponent_free(comp);
free(buf);
if(errors > 0){
icalproperty_free(prop);
return 0;
} else {
return prop;
}
}
void
icalproperty_free (icalproperty* prop)
{
struct icalproperty_impl *p;
icalparameter* param;
icalerror_check_arg_rv((prop!=0),"prop");
p = (struct icalproperty_impl*)prop;
#ifdef ICAL_FREE_ON_LIST_IS_ERROR
icalerror_assert( (p->parent ==0),"Tried to free a property that is still attached to a component. ");
#else
if(p->parent !=0){
return;
}
#endif
if (p->value != 0){
icalvalue_set_parent(p->value,0);
icalvalue_free(p->value);
}
while( (param = pvl_pop(p->parameters)) != 0){
icalparameter_free(param);
}
pvl_free(p->parameters);
if (p->x_name != 0) {
free(p->x_name);
}
p->kind = ICAL_NO_PROPERTY;
p->parameters = 0;
p->parameter_iterator = 0;
p->value = 0;
p->x_name = 0;
p->id[0] = 'X';
free(p);
}
char*
icalproperty_as_ical_string (icalproperty* prop)
{
icalparameter *param;
/* Create new buffer that we can append names, parameters and a
value to, and reallocate as needed. Later, this buffer will be
copied to a icalmemory_tmp_buffer, which is managed internally
by libical, so it can be given to the caller without fear of
the caller forgetting to free it */
const char* property_name = 0;
size_t buf_size = 1024;
char* buf = icalmemory_new_buffer(buf_size);
char* buf_ptr = buf;
icalvalue* value;
char *out_buf;
char newline[] = "\n";
struct icalproperty_impl *impl = (struct icalproperty_impl*)prop;
icalerror_check_arg_rz( (prop!=0),"prop");
/* Append property name */
if (impl->kind == ICAL_X_PROPERTY && impl->x_name != 0){
property_name = impl->x_name;
} else {
property_name = icalproperty_kind_to_string(impl->kind);
}
if (property_name == 0 ) {
icalerror_warn("Got a property of an unknown kind.");
icalmemory_free_buffer(buf);
return 0;
}
icalmemory_append_string(&buf, &buf_ptr, &buf_size, property_name);
icalmemory_append_string(&buf, &buf_ptr, &buf_size, newline);
/* Determine what VALUE parameter to include. The VALUE parameters
are ignored in the normal parameter printing ( the block after
this one, so we need to do it here */
{
const char* kind_string = 0;
icalparameter *orig_val_param
= icalproperty_get_first_parameter(prop,ICAL_VALUE_PARAMETER);
icalvalue *value = icalproperty_get_value(impl);
icalvalue_kind orig_kind = ICAL_NO_VALUE;
icalvalue_kind this_kind = ICAL_NO_VALUE;
icalvalue_kind default_kind
= icalproperty_kind_to_value_kind(impl->kind);
if(orig_val_param){
orig_kind = (icalvalue_kind)icalparameter_get_value(orig_val_param);
}
if(value != 0){
this_kind = icalvalue_isa(value);
}
if(this_kind == default_kind &&
orig_kind != ICAL_NO_VALUE){
/* The kind is the default, so it does not need to be
included, but do it anyway, since it was explicit in
the property. But, use the default, not the one
specified in the property */
kind_string = icalvalue_kind_to_string(default_kind);
} else if (this_kind != default_kind && this_kind != ICAL_NO_VALUE){
/* Not the default, so it must be specified */
kind_string = icalvalue_kind_to_string(this_kind);
} else {
/* Don'tinclude the VALUE parameter at all */
}
if(kind_string!=0){
icalmemory_append_string(&buf, &buf_ptr, &buf_size, " ;");
icalmemory_append_string(&buf, &buf_ptr, &buf_size, "VALUE=");
icalmemory_append_string(&buf, &buf_ptr, &buf_size, kind_string);
icalmemory_append_string(&buf, &buf_ptr, &buf_size, newline);
}
}
/* Append parameters */
for(param = icalproperty_get_first_parameter(prop,ICAL_ANY_PARAMETER);
param != 0;
param = icalproperty_get_next_parameter(prop,ICAL_ANY_PARAMETER)) {
char* kind_string = icalparameter_as_ical_string(param);
icalparameter_kind kind = icalparameter_isa(param);
if(kind==ICAL_VALUE_PARAMETER){
continue;
}
if (kind_string == 0 ) {
char temp[TMP_BUF_SIZE];
snprintf(temp, TMP_BUF_SIZE,"Got a parameter of unknown kind in %s property",property_name);
icalerror_warn(temp);
continue;
}
icalmemory_append_string(&buf, &buf_ptr, &buf_size, " ;");
icalmemory_append_string(&buf, &buf_ptr, &buf_size, kind_string);
icalmemory_append_string(&buf, &buf_ptr, &buf_size, newline);
}
/* Append value */
icalmemory_append_string(&buf, &buf_ptr, &buf_size, " :");
value = icalproperty_get_value(prop);
if (value != 0){
const char *str = icalvalue_as_ical_string(value);
icalerror_assert((str !=0),"Could not get string representation of a value");
icalmemory_append_string(&buf, &buf_ptr, &buf_size, str);
} else {
icalmemory_append_string(&buf, &buf_ptr, &buf_size,"ERROR: No Value");
}
icalmemory_append_string(&buf, &buf_ptr, &buf_size, newline);
/* Now, copy the buffer to a tmp_buffer, which is safe to give to
the caller without worring about de-allocating it. */
out_buf = icalmemory_tmp_buffer(strlen(buf)+1);
strcpy(out_buf, buf);
icalmemory_free_buffer(buf);
return out_buf;
}
icalproperty_kind
icalproperty_isa (icalproperty* property)
{
struct icalproperty_impl *p = (struct icalproperty_impl*)property;
if(property != 0){
return p->kind;
}
return ICAL_NO_PROPERTY;
}
int
icalproperty_isa_property (void* property)
{
struct icalproperty_impl *impl = (struct icalproperty_impl*)property;
icalerror_check_arg_rz( (property!=0), "property");
if (strcmp(impl->id,"prop") == 0) {
return 1;
} else {
return 0;
}
}
void
icalproperty_add_parameter (icalproperty* prop,icalparameter* parameter)
{
struct icalproperty_impl *p = (struct icalproperty_impl*)prop;
icalerror_check_arg_rv( (prop!=0),"prop");
icalerror_check_arg_rv( (parameter!=0),"parameter");
pvl_push(p->parameters, parameter);
}
void
icalproperty_set_parameter (icalproperty* prop,icalparameter* parameter)
{
icalparameter_kind kind;
icalerror_check_arg_rv( (prop!=0),"prop");
icalerror_check_arg_rv( (parameter!=0),"parameter");
kind = icalparameter_isa(parameter);
icalproperty_remove_parameter(prop,kind);
icalproperty_add_parameter(prop,parameter);
}
void icalproperty_set_parameter_from_string(icalproperty* prop,
const char* name, const char* value)
{
icalparameter_kind kind;
icalparameter *param;
icalerror_check_arg_rv( (prop!=0),"prop");
icalerror_check_arg_rv( (name!=0),"name");
icalerror_check_arg_rv( (value!=0),"value");
kind = icalparameter_string_to_kind(name);
if(kind == ICAL_NO_PARAMETER){
icalerror_set_errno(ICAL_BADARG_ERROR);
return;
}
param = icalparameter_new_from_value_string(kind,value);
if (param == 0){
icalerror_set_errno(ICAL_BADARG_ERROR);
return;
}
icalproperty_set_parameter(prop,param);
}
const char* icalproperty_get_parameter_as_string(icalproperty* prop,
const char* name)
{
icalparameter_kind kind;
icalparameter *param;
char* str;
char* pv;
icalerror_check_arg_rz( (prop!=0),"prop");
icalerror_check_arg_rz( (name!=0),"name");
kind = icalparameter_string_to_kind(name);
if(kind == ICAL_NO_PROPERTY){
/* icalenum_string_to_parameter_kind will set icalerrno */
return 0;
}
param = icalproperty_get_first_parameter(prop,kind);
if (param == 0){
return 0;
}
str = icalparameter_as_ical_string(param);
pv = strchr(str,'=');
if(pv == 0){
icalerror_set_errno(ICAL_INTERNAL_ERROR);
return 0;
}
return pv+1;
}
void
icalproperty_remove_parameter (icalproperty* prop, icalparameter_kind kind)
{
pvl_elem p;
struct icalproperty_impl *impl = (struct icalproperty_impl*)prop;
icalerror_check_arg_rv((prop!=0),"prop");
for(p=pvl_head(impl->parameters);p != 0; p = pvl_next(p)){
icalparameter* param = (icalparameter *)pvl_data (p);
if (icalparameter_isa(param) == kind) {
pvl_remove (impl->parameters, p);
icalparameter_free (param);
break;
}
}
}
int
icalproperty_count_parameters (icalproperty* prop)
{
struct icalproperty_impl *p = (struct icalproperty_impl*)prop;
if(prop != 0){
return pvl_count(p->parameters);
}
icalerror_set_errno(ICAL_USAGE_ERROR);
return -1;
}
icalparameter*
icalproperty_get_first_parameter (icalproperty* prop, icalparameter_kind kind)
{
struct icalproperty_impl *p = (struct icalproperty_impl*)prop;
icalerror_check_arg_rz( (prop!=0),"prop");
p->parameter_iterator = pvl_head(p->parameters);
if (p->parameter_iterator == 0) {
return 0;
}
for( p->parameter_iterator = pvl_head(p->parameters);
p->parameter_iterator !=0;
p->parameter_iterator = pvl_next(p->parameter_iterator)){
icalparameter *param = (icalparameter*)pvl_data(p->parameter_iterator);
if(icalparameter_isa(param) == kind || kind == ICAL_ANY_PARAMETER){
return param;
}
}
return 0;
}
icalparameter*
icalproperty_get_next_parameter (icalproperty* prop, icalparameter_kind kind)
{
struct icalproperty_impl *p = (struct icalproperty_impl*)prop;
icalerror_check_arg_rz( (prop!=0),"prop");
if (p->parameter_iterator == 0) {
return 0;
}
for( p->parameter_iterator = pvl_next(p->parameter_iterator);
p->parameter_iterator !=0;
p->parameter_iterator = pvl_next(p->parameter_iterator)){
icalparameter *param = (icalparameter*)pvl_data(p->parameter_iterator);
if(icalparameter_isa(param) == kind || kind == ICAL_ANY_PARAMETER){
return param;
}
}
return 0;
}
void
icalproperty_set_value (icalproperty* prop, icalvalue* value)
{
struct icalproperty_impl *p = (struct icalproperty_impl*)prop;
icalerror_check_arg_rv((prop !=0),"prop");
icalerror_check_arg_rv((value !=0),"value");
if (p->value != 0){
icalvalue_set_parent(p->value,0);
icalvalue_free(p->value);
p->value = 0;
}
p->value = value;
icalvalue_set_parent(value,prop);
}
void icalproperty_set_value_from_string(icalproperty* prop,const char* str,
const char* type)
{
icalvalue *oval,*nval;
icalvalue_kind kind = ICAL_NO_VALUE;
icalerror_check_arg_rv( (prop!=0),"prop");
icalerror_check_arg_rv( (str!=0),"str");
icalerror_check_arg_rv( (type!=0),"type");
if(strcmp(type,"NO")==0){
/* Get the type from the value the property already has, if it exists */
oval = icalproperty_get_value(prop);
if(oval != 0){
/* Use the existing value kind */
kind = icalvalue_isa(oval);
} else {
/* Use the default kind for the property */
kind = icalproperty_kind_to_value_kind(icalproperty_isa(prop));
}
} else {
/* Use the given kind string */
kind = icalvalue_string_to_kind(type);
}
if(kind == ICAL_NO_VALUE){
icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
return;
}
nval = icalvalue_new_from_string(kind, str);
if(nval == 0){
/* icalvalue_new_from_string sets errno */
assert(icalerrno != ICAL_NO_ERROR);
return;
}
icalproperty_set_value(prop,nval);
}
icalvalue*
icalproperty_get_value (icalproperty* prop)
{
struct icalproperty_impl *p = (struct icalproperty_impl*)prop;
icalerror_check_arg_rz( (prop!=0),"prop");
return p->value;
}
const char* icalproperty_get_value_as_string(icalproperty* prop)
{
icalvalue *value;
struct icalproperty_impl *impl = (struct icalproperty_impl*)prop;
icalerror_check_arg_rz( (prop!=0),"prop");
value = impl->value;
return icalvalue_as_ical_string(value);
}
void icalproperty_set_x_name(icalproperty* prop, char* name)
{
struct icalproperty_impl *impl = (struct icalproperty_impl*)prop;
icalerror_check_arg_rv( (name!=0),"name");
icalerror_check_arg_rv( (prop!=0),"prop");
if (impl->x_name != 0) {
free(impl->x_name);
}
impl->x_name = icalmemory_strdup(name);
if(impl->x_name == 0){
icalerror_set_errno(ICAL_NEWFAILED_ERROR);
}
}
char* icalproperty_get_x_name(icalproperty* prop){
struct icalproperty_impl *impl = (struct icalproperty_impl*)prop;
icalerror_check_arg_rz( (prop!=0),"prop");
return impl->x_name;
}
/* From Jonathan Yue <jonathan.yue at cp.net> */
char* icalproperty_get_name (icalproperty* prop)
{
const char* property_name = 0;
size_t buf_size = 256;
char* buf = icalmemory_new_buffer(buf_size);
char* buf_ptr = buf;
struct icalproperty_impl *impl = (struct icalproperty_impl*)prop;
icalerror_check_arg_rz( (prop!=0),"prop");
if (impl->kind == ICAL_X_PROPERTY && impl->x_name != 0){
property_name = impl->x_name;
} else {
property_name = icalproperty_kind_to_string(impl->kind);
}
if (property_name == 0 ) {
icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
return 0;
} else {
/* _append_string will automatically grow the buffer if
property_name is longer than the initial buffer size */
icalmemory_append_string(&buf, &buf_ptr, &buf_size, property_name);
}
/* Add the buffer to the temporary buffer ring -- the caller will
not have to free the memory. */
icalmemory_add_tmp_buffer(buf);
return buf;
}
void icalproperty_set_parent(icalproperty* property,
icalcomponent* component)
{
struct icalproperty_impl *impl = (struct icalproperty_impl*)property;
icalerror_check_arg_rv( (property!=0),"property");
impl->parent = component;
}
icalcomponent* icalproperty_get_parent(icalproperty* property)
{
struct icalproperty_impl *impl = (struct icalproperty_impl*)property;
icalerror_check_arg_rz( (property!=0),"property");
return impl->parent;
}
/* Everything below this line is machine generated. Do not edit. */
--- NEW FILE: icalyacc.y ---
%{
/* -*- Mode: C -*-
======================================================================
FILE: icalitip.y
CREATOR: eric 10 June 1999
DESCRIPTION:
$Id: icalyacc.y,v 1.1.2.1 2013-02-13 20:50:30 colin Exp $
$Locker: $
(C) COPYRIGHT 1999 Eric Busboom
http://www.softwarestudio.org
The contents of this file are subject to the Mozilla Public License
Version 1.0 (the "License"); you may not use this file except in
compliance with the License. You may obtain a copy of the License at
http://www.mozilla.org/MPL/
Software distributed under the License is distributed on an "AS IS"
basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
the License for the specific language governing rights and
limitations under the License.
The original author is Eric Busboom
The original code is icalitip.y
=======================================================================*/
#include <stdlib.h>
#include <string.h> /* for strdup() */
#include "icalparser.h"
#include "pvl.h"
icalvalue *icalparser_yy_value; /* Current Value */
void ical_yyerror(char* s);
void icalparser_clear_flex_input();
int ical_yy_lex(void);
/* Globals for UTCOFFSET values */
int utc;
int utc_b;
int utcsign;
/* Globals for DURATION values */
struct icaldurationtype duration;
/* Globals for TRIGGER values */
struct icaltriggertype trigger;
void copy_list(short* array, size_t size);
void add_prop(icalproperty_kind);
void icalparser_fill_date(struct tm* t, char* dstr);
void icalparser_fill_time(struct tm* t, char* tstr);
void set_value_type(icalvalue_kind kind);
void set_parser_value_state();
struct icaltimetype fill_datetime(char* d, char* t);
void ical_yy_error(char *s); /* Don't know why I need this.... */
int yylex(void); /* Or this. */
/* Set the state of the lexer so it will interpret values ( iCAL
VALUEs, that is, ) correctly. */
%}
%union {
float v_float;
int v_int;
char* v_string;
}
/* Renaming hack */
/*
#define yymaxdepth ical_yy_maxdepth
#define yyparse ical_yy_parse
#define yyerror ical_yy_error
#define yylval ical_yy_lval
#define yychar ical_yy_char
#define yydebug ical_yy_debug
#define yypact ical_yy_pact
#define yyr1 ical_yy_r1
#define yyr2 ical_yy_r2
#define yydef ical_yy_def
#define yychk ical_yy_chk
#define yypgo ical_yy_pgo
#define yyact ical_yy_act
#define yyexca ical_yy_exca
#define yyerrflag ical_yy_errflag
#define yynerrs ical_yy_nerrs
#define yyps ical_yy_ps
#define yypv ical_yy_pv
#define yys ical_yy_s
#define yy_yys ical_yy_yys
#define yystate ical_yy_state
#define yytmp ical_yy_tmp
#define yyv ical_yy_v
#define yy_yyv ical_yy_yyv
#define yyval ical_yy_val
#define yylloc ical_yy_lloc
#define yyreds ical_yy_reds
#define yytoks ical_yy_toks
#define yylhs ical_yy_yylhs
#define yylen ical_yy_yylen
#define yydefred ical_yy_yydefred
#define yydgoto ical_yy_yydgoto
#define yydefred ical_yy_yydefred
#define yydgoto ical_yy_yydgoto
#define yysindex ical_yy_yysindex
#define yyrindex ical_yy_yyrindex
#define yygindex ical_yy_yygindex
#define yytable ical_yy_yytable
#define yycheck ical_yy_yycheck
#define yyname ical_yy_yyname
#define yyrule ical_yy_yyrule
#define yy_scan_bytes ical_yy_scan_bytes
#define yy_scan_string ical_yy_scan_string
#define yy_scan_buffer ical_yy_scan_buffer
*/
/* These are redefined with the -P option to flex */
/*
#define yy_create_buffer ical_yy_create_buffer
#define yy_delete_buffer ical_yy_delete_buffer
#define yy_flex_debug ical_yy_flex_debug
#define yy_init_buffer ical_yy_init_buffer
#define yy_flush_buffer ical_yy_flush_buffer
#define yy_load_buffer_state ical_yy_load_buffer_state
#define yy_switch_to_buffer ical_yy_switch_to_buffer
#define yyin ical_yyin
#define yyleng ical_yyleng
#define yylex ical_yylex
#define yylineno ical_yylineno
#define yyout ical_yyout
#define yyrestart ical_yyrestart
#define yytext ical_yytext
#define yywrap ical_yywrap
*/
%token <v_string> DIGITS
%token <v_int> INTNUMBER
%token <v_float> FLOATNUMBER
%token <v_string> STRING
%token EOL EQUALS CHARACTER COLON COMMA SEMICOLON MINUS TIMESEPERATOR
%token TRUE FALSE
%token FREQ BYDAY BYHOUR BYMINUTE BYMONTH BYMONTHDAY BYSECOND BYSETPOS BYWEEKNO
%token BYYEARDAY DAILY MINUTELY MONTHLY SECONDLY WEEKLY HOURLY YEARLY
%token INTERVAL COUNT UNTIL WKST MO SA SU TU WE TH FR
%token BIT8 ACCEPTED ADD AUDIO BASE64 BINARY BOOLEAN BUSY BUSYTENTATIVE
%token BUSYUNAVAILABLE CALADDRESS CANCEL CANCELLED CHAIR CHILD COMPLETED
%token CONFIDENTIAL CONFIRMED COUNTER DATE DATETIME DECLINECOUNTER DECLINED
%token DELEGATED DISPLAY DRAFT DURATION EMAIL END FINAL FLOAT FREE GREGORIAN
%token GROUP INDIVIDUAL INPROCESS INTEGER NEEDSACTION NONPARTICIPANT
%token OPAQUE OPTPARTICIPANT PARENT PERIOD PRIVATE PROCEDURE PUBLIC PUBLISH
%token RECUR REFRESH REPLY REQPARTICIPANT REQUEST RESOURCE ROOM SIBLING
%token START TENTATIVE TEXT THISANDFUTURE THISANDPRIOR TIME TRANSPAENT
%token UNKNOWN UTCOFFSET XNAME
%token ALTREP CN CUTYPE DAYLIGHT DIR ENCODING EVENT FBTYPE FMTTYPE LANGUAGE
%token MEMBER PARTSTAT RANGE RELATED RELTYPE ROLE RSVP SENTBY STANDARD URI
%token CHARSET
%token TIME_CHAR UTC_CHAR
%%
value:
date_value
| datetime_value
| duration_value
| period_value
| utcoffset_value
| error {
icalparser_yy_value = 0;
icalparser_clear_flex_input();
yyclearin;
}
date_value: DIGITS
{
struct icaltimetype stm;
stm = fill_datetime($1,0);
stm.hour = -1;
stm.minute = -1;
stm.second = -1;
stm.is_utc = 0;
stm.is_date = 1;
icalparser_yy_value = icalvalue_new_date(stm);
}
utc_char:
/*empty*/ {utc = 0;}
| UTC_CHAR {utc = 1;}
/* This is used in the period_value, where there may be two utc characters per rule. */
utc_char_b:
/*empty*/ {utc_b = 0;}
| UTC_CHAR {utc_b = 1;}
datetime_value:
DIGITS TIME_CHAR DIGITS utc_char
{
struct icaltimetype stm;
stm = fill_datetime($1, $3);
stm.is_utc = utc;
stm.is_date = 0;
icalparser_yy_value =
icalvalue_new_datetime(stm);
}
/* Duration */
dur_date: dur_day
| dur_day dur_time
dur_week: DIGITS 'W'
{
duration.weeks = atoi($1);
}
dur_time: TIME_CHAR dur_hour
{
}
| TIME_CHAR dur_minute
{
}
| TIME_CHAR dur_second
{
}
dur_hour: DIGITS 'H'
{
duration.hours = atoi($1);
}
| DIGITS 'H' dur_minute
{
duration.hours = atoi($1);
}
dur_minute: DIGITS 'M'
{
duration.minutes = atoi($1);
}
| DIGITS 'M' dur_second
{
duration.minutes = atoi($1);
}
dur_second: DIGITS 'S'
{
duration.seconds = atoi($1);
}
dur_day: DIGITS 'D'
{
duration.days = atoi($1);
}
dur_prefix: /* empty */
{
duration.is_neg = 0;
}
| '+'
{
duration.is_neg = 0;
}
| '-'
{
duration.is_neg = 1;
}
duration_value: dur_prefix 'P' dur_date
{
icalparser_yy_value = icalvalue_new_duration(duration);
memset(&duration,0, sizeof(duration));
}
| dur_prefix 'P' dur_time
{
icalparser_yy_value = icalvalue_new_duration(duration);
memset(&duration,0, sizeof(duration));
}
| dur_prefix 'P' dur_week
{
icalparser_yy_value = icalvalue_new_duration(duration);
memset(&duration,0, sizeof(duration));
}
/* Period */
period_value: DIGITS TIME_CHAR DIGITS utc_char '/' DIGITS TIME_CHAR DIGITS utc_char_b
{
struct icalperiodtype p;
p.start = fill_datetime($1,$3);
p.start.is_utc = utc;
p.start.is_date = 0;
p.end = fill_datetime($6,$8);
p.end.is_utc = utc_b;
p.end.is_date = 0;
p.duration.days = -1;
p.duration.weeks = -1;
p.duration.hours = -1;
p.duration.minutes = -1;
p.duration.seconds = -1;
icalparser_yy_value = icalvalue_new_period(p);
}
| DIGITS TIME_CHAR DIGITS utc_char '/' duration_value
{
struct icalperiodtype p;
p.start = fill_datetime($1,$3);
p.start.is_utc = utc;
p.start.is_date = 0;
p.end.year = -1;
p.end.month = -1;
p.end.day = -1;
p.end.hour = -1;
p.end.minute = -1;
p.end.second = -1;
/* The duration_value rule setes the global 'duration'
variable, but it also creates a new value in
icalparser_yy_value. So, free that, then copy
'duration' into the icalperiodtype struct. */
p.duration = icalvalue_get_duration(icalparser_yy_value);
icalvalue_free(icalparser_yy_value);
icalparser_yy_value = 0;
icalparser_yy_value = icalvalue_new_period(p);
}
trigger:
/* UTC Offset */
plusminus: '+' { utcsign = 1; }
| '-' { utcsign = -1; }
utcoffset_value:
plusminus INTNUMBER INTNUMBER
{
icalparser_yy_value = icalvalue_new_utcoffset( utcsign * ($2*3600) + ($3*60) );
}
| plusminus INTNUMBER INTNUMBER INTNUMBER
{
icalparser_yy_value = icalvalue_new_utcoffset(utcsign * ($2*3600) + ($3*60) +($4));
}
%%
struct icaltimetype fill_datetime(char* datestr, char* timestr)
{
struct icaltimetype stm;
memset(&stm,0,sizeof(stm));
if (datestr != 0){
sscanf(datestr,"%4d%2d%2d",&(stm.year), &(stm.month),
&(stm.day));
}
if (timestr != 0){
sscanf(timestr,"%2d%2d%2d", &(stm.hour), &(stm.minute),
&(stm.second));
}
return stm;
}
void ical_yyerror(char* s)
{
/*fprintf(stderr,"Parse error \'%s\'\n", s);*/
}
--- NEW FILE: icalmemory.h ---
/* -*- Mode: C -*- */
/*======================================================================
FILE: icalmemory.h
CREATOR: eric 30 June 1999
$Id: icalmemory.h,v 1.1.2.1 2013-02-13 20:50:30 colin Exp $
$Locker: $
This program is free software; you can redistribute it and/or modify
it under the terms of either:
The LGPL as published by the Free Software Foundation, version
2.1, available at: http://www.fsf.org/copyleft/lesser.html
Or:
The Mozilla Public License Version 1.0. You may obtain a copy of
the License at http://www.mozilla.org/MPL/
The Initial Developer of the Original Code is Eric Busboom
(C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
======================================================================*/
#ifndef ICALMEMORY_H
#define ICALMEMORY_H
#include <sys/types.h> /* for size_t */
/* Tmp buffers are managed by ical. References can be returned to the
caller, although the caller will not own the memory. */
void* icalmemory_tmp_buffer(size_t size);
char* icalmemory_tmp_copy(const char* str);
/* Add an externally allocated buffer to the ring. */
void icalmemory_add_tmp_buffer(void*);
/* Free all memory used in the ring */
void icalmemory_free_ring(void);
/* Non-tmp buffers must be freed. These are mostly wrappers around
* malloc, etc, but are used so the caller can change the memory
* allocators in a future version of the library */
void* icalmemory_new_buffer(size_t size);
void* icalmemory_resize_buffer(void* buf, size_t size);
void icalmemory_free_buffer(void* buf);
/* icalmemory_append_string will copy the string 'string' to the
buffer 'buf' starting at position 'pos', reallocing 'buf' if it is
too small. 'buf_size' is the size of 'buf' and will be changed if
'buf' is reallocated. 'pos' will point to the last byte of the new
string in 'buf', usually a '\0' */
/* THESE ROUTINES CAN NOT BE USED ON TMP BUFFERS. Only use them on
normally allocated memory, or on buffers created from
icalmemory_new_buffer, never with buffers created by
icalmemory_tmp_buffer. If icalmemory_append_string has to resize a
buffer on the ring, the ring will loose track of it an you will
have memory problems. */
void icalmemory_append_string(char** buf, char** pos, size_t* buf_size,
const char* string);
/* icalmemory_append_char is similar, but is appends a character instead of a string */
void icalmemory_append_char(char** buf, char** pos, size_t* buf_size,
char ch);
/* A wrapper around strdup. Partly to trap calls to strdup, partly
because in -ansi, gcc on Red Hat claims that strudup is undeclared */
char* icalmemory_strdup(const char *s);
#endif /* !ICALMEMORY_H */
--- NEW FILE: icalparameter.c ---
/* -*- Mode: C -*-
======================================================================
FILE: icalderivedparameters.{c,h}
CREATOR: eric 09 May 1999
$Id: icalparameter.c,v 1.1.2.1 2013-02-13 20:50:30 colin Exp $
$Locker: $
(C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
This program is free software; you can redistribute it and/or modify
it under the terms of either:
The LGPL as published by the Free Software Foundation, version
2.1, available at: http://www.fsf.org/copyleft/lesser.html
Or:
The Mozilla Public License Version 1.0. You may obtain a copy of
the License at http://www.mozilla.org/MPL/
The original code is icalderivedparameters.{c,h}
Contributions from:
Graham Davison (g.m.davison at computer.org)
======================================================================*/
/*#line 29 "icalparameter.c.in"*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "icalparameter.h"
#include "icalproperty.h"
#include "icalerror.h"
#include "icalmemory.h"
#include "icalparameterimpl.h"
#include <stdlib.h> /* for malloc() */
#include <errno.h>
#include <string.h> /* for memset() */
/* In icalderivedparameter */
icalparameter* icalparameter_new_from_value_string(icalparameter_kind kind,const char* val);
struct icalparameter_impl* icalparameter_new_impl(icalparameter_kind kind)
{
struct icalparameter_impl* v;
if ( ( v = (struct icalparameter_impl*)
malloc(sizeof(struct icalparameter_impl))) == 0) {
icalerror_set_errno(ICAL_NEWFAILED_ERROR);
return 0;
}
strcpy(v->id,"para");
v->kind = kind;
v->size = 0;
v->string = 0;
v->x_name = 0;
v->parent = 0;
v->data = 0;
return v;
}
icalparameter*
icalparameter_new (icalparameter_kind kind)
{
struct icalparameter_impl* v = icalparameter_new_impl(kind);
return (icalparameter*) v;
}
void
icalparameter_free (icalparameter* parameter)
{
struct icalparameter_impl * impl;
impl = (struct icalparameter_impl*)parameter;
/* HACK. This always triggers, even when parameter is non-zero
icalerror_check_arg_rv((parameter==0),"parameter");*/
#ifdef ICAL_FREE_ON_LIST_IS_ERROR
icalerror_assert( (impl->parent ==0),"Tried to free a parameter that is still attached to a component. ");
#else
if(impl->parent !=0){
return;
}
#endif
if (impl->string != 0){
free ((void*)impl->string);
}
if (impl->x_name != 0){
free ((void*)impl->x_name);
}
memset(impl,0,sizeof(impl));
impl->parent = 0;
impl->id[0] = 'X';
free(impl);
}
icalparameter*
icalparameter_new_clone(icalparameter* param)
{
struct icalparameter_impl *old;
struct icalparameter_impl *new;
old = (struct icalparameter_impl *)param;
new = icalparameter_new_impl(old->kind);
icalerror_check_arg_rz((param!=0),"param");
if (new == 0){
return 0;
}
memcpy(new,old,sizeof(struct icalparameter_impl));
if (old->string != 0){
new->string = icalmemory_strdup(old->string);
if (new->string == 0){
icalparameter_free(new);
return 0;
}
}
if (old->x_name != 0){
new->x_name = icalmemory_strdup(old->x_name);
if (new->x_name == 0){
icalparameter_free(new);
return 0;
}
}
return new;
}
icalparameter* icalparameter_new_from_string(const char *str)
{
char* eq;
char* cpy;
icalparameter_kind kind;
icalparameter *param;
icalerror_check_arg_rz(str != 0,"str");
cpy = icalmemory_strdup(str);
if (cpy == 0){
icalerror_set_errno(ICAL_NEWFAILED_ERROR);
return 0;
}
eq = strchr(cpy,'=');
if(eq == 0){
icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
return 0;
}
*eq = '\0';
eq++;
kind = icalparameter_string_to_kind(cpy);
if(kind == ICAL_NO_PARAMETER){
icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
return 0;
}
param = icalparameter_new_from_value_string(kind,eq);
if(kind == ICAL_X_PARAMETER){
icalparameter_set_xname(param,cpy);
}
free(cpy);
return param;
}
char*
icalparameter_as_ical_string (icalparameter* parameter)
{
struct icalparameter_impl* impl;
size_t buf_size = 1024;
char* buf;
char* buf_ptr;
char *out_buf;
const char *kind_string;
icalerror_check_arg_rz( (parameter!=0), "parameter");
/* Create new buffer that we can append names, parameters and a
value to, and reallocate as needed. Later, this buffer will be
copied to a icalmemory_tmp_buffer, which is managed internally
by libical, so it can be given to the caller without fear of
the caller forgetting to free it */
buf = icalmemory_new_buffer(buf_size);
buf_ptr = buf;
impl = (struct icalparameter_impl*)parameter;
if(impl->kind == ICAL_X_PARAMETER) {
icalmemory_append_string(&buf, &buf_ptr, &buf_size,
icalparameter_get_xname(impl));
} else {
kind_string = icalparameter_kind_to_string(impl->kind);
if (impl->kind == ICAL_NO_PARAMETER ||
impl->kind == ICAL_ANY_PARAMETER ||
kind_string == 0)
{
icalerror_set_errno(ICAL_BADARG_ERROR);
return 0;
}
/* Put the parameter name into the string */
icalmemory_append_string(&buf, &buf_ptr, &buf_size, kind_string);
}
icalmemory_append_string(&buf, &buf_ptr, &buf_size, "=");
if(impl->string !=0){
icalmemory_append_string(&buf, &buf_ptr, &buf_size, impl->string);
} else if (impl->data != 0){
const char* str = icalparameter_enum_to_string(impl->data);
icalmemory_append_string(&buf, &buf_ptr, &buf_size, str);
} else {
icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
return 0;
}
/* Now, copy the buffer to a tmp_buffer, which is safe to give to
the caller without worring about de-allocating it. */
out_buf = icalmemory_tmp_buffer(strlen(buf));
strcpy(out_buf, buf);
icalmemory_free_buffer(buf);
return out_buf;
}
int
icalparameter_is_valid (icalparameter* parameter);
icalparameter_kind
icalparameter_isa (icalparameter* parameter)
{
if(parameter == 0){
return ICAL_NO_PARAMETER;
}
return ((struct icalparameter_impl *)parameter)->kind;
}
int
icalparameter_isa_parameter (void* parameter)
{
struct icalparameter_impl *impl = (struct icalparameter_impl *)parameter;
if (parameter == 0){
return 0;
}
if (strcmp(impl->id,"para") == 0) {
return 1;
} else {
return 0;
}
}
void
icalparameter_set_xname (icalparameter* param, const char* v)
{
struct icalparameter_impl *impl = (struct icalparameter_impl*)param;
icalerror_check_arg_rv( (param!=0),"param");
icalerror_check_arg_rv( (v!=0),"v");
if (impl->x_name != 0){
free((void*)impl->x_name);
}
impl->x_name = icalmemory_strdup(v);
if (impl->x_name == 0){
errno = ENOMEM;
}
}
const char*
icalparameter_get_xname (icalparameter* param)
{
struct icalparameter_impl *impl = (struct icalparameter_impl*)param;
icalerror_check_arg_rz( (param!=0),"param");
return impl->x_name;
}
void
icalparameter_set_xvalue (icalparameter* param, const char* v)
{
struct icalparameter_impl *impl = (struct icalparameter_impl*)param;
icalerror_check_arg_rv( (param!=0),"param");
icalerror_check_arg_rv( (v!=0),"v");
if (impl->string != 0){
free((void*)impl->string);
}
impl->string = icalmemory_strdup(v);
if (impl->string == 0){
errno = ENOMEM;
}
}
const char*
icalparameter_get_xvalue (icalparameter* param)
{
struct icalparameter_impl *impl = (struct icalparameter_impl*)param;
icalerror_check_arg_rz( (param!=0),"param");
return impl->string;
}
void icalparameter_set_parent(icalparameter* param,
icalproperty* property)
{
struct icalparameter_impl *impl = (struct icalparameter_impl*)param;
icalerror_check_arg_rv( (param!=0),"param");
impl->parent = property;
}
icalproperty* icalparameter_get_parent(icalparameter* param)
{
struct icalparameter_impl *impl = (struct icalparameter_impl*)param;
icalerror_check_arg_rz( (param!=0),"param");
return impl->parent;
}
/* Everything below this line is machine generated. Do not edit. */
/* ALTREP */
--- NEW FILE: icalderivedproperty.c.in ---
/* -*- Mode: C -*- */
/*======================================================================
FILE: icalderivedproperty.c
CREATOR: eric 15 Feb 2001
$Id: icalderivedproperty.c.in,v 1.1.2.1 2013-02-13 20:50:29 colin 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 icalproperty.c
======================================================================*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "icalproperty.h"
#include "icalcomponent.h"
#include "pvl.h"
#include "icalenums.h"
#include "icalerror.h"
#include "icalmemory.h"
#include "icalparser.h"
#include <string.h> /* For icalmemory_strdup, rindex */
#include <assert.h>
#include <stdlib.h>
#include <errno.h>
#include <stdio.h> /* for printf */
#include <stdarg.h> /* for va_list, va_start, etc. */
#define TMP_BUF_SIZE 1024
struct icalproperty_impl*
icalproperty_new_impl (icalproperty_kind kind);
/* This map associates the property kinds with the string
representation of the property name and the kind of VALUE that the
property uses as a default */
struct icalproperty_map {
icalproperty_kind kind;
const char *name;
icalvalue_kind value;
};
static struct icalproperty_map property_map[];
const char* icalproperty_kind_to_string(icalproperty_kind kind)
{
int i;
for (i=0; property_map[i].kind != ICAL_NO_PROPERTY; i++) {
if (property_map[i].kind == kind) {
return property_map[i].name;
}
}
return 0;
}
icalproperty_kind icalproperty_string_to_kind(const char* string)
{
int i;
if (string ==0 ) {
return ICAL_NO_PROPERTY;
}
for (i=0; property_map[i].kind != ICAL_NO_PROPERTY; i++) {
if (strcmp(property_map[i].name, string) == 0) {
return property_map[i].kind;
}
}
if(strncmp(string,"X-",2)==0){
return ICAL_X_PROPERTY;
}
return ICAL_NO_PROPERTY;
}
icalvalue_kind icalproperty_value_kind_to_kind(icalvalue_kind kind)
{
int i;
for (i=0; property_map[i].kind != ICAL_NO_PROPERTY; i++) {
if ( property_map[i].value == kind ) {
return property_map[i].kind;
}
}
return ICAL_NO_VALUE;
}
icalvalue_kind icalproperty_kind_to_value_kind(icalproperty_kind kind)
{
int i;
for (i=0; property_map[i].kind != ICAL_NO_PROPERTY; i++) {
if ( property_map[i].kind == kind ) {
return property_map[i].value;
}
}
return ICAL_NO_VALUE;
}
/* This map associates the property enumerations with the king of
property that they are used in and the string representation of the
enumeration */
struct icalproperty_enum_map {
icalproperty_kind prop;
int prop_enum;
const char* str;
};
static struct icalproperty_enum_map enum_map[];
const char* icalproperty_enum_to_string(int e)
{
icalerror_check_arg_rz(e >= ICALPROPERTY_FIRST_ENUM,"e");
icalerror_check_arg_rz(e <= ICALPROPERTY_LAST_ENUM,"e");
return enum_map[e-ICALPROPERTY_FIRST_ENUM].str;
}
int icalproperty_string_to_enum(const char* str)
{
int i;
icalerror_check_arg_rz(str!=0,"str")
while(*str == ' '){
str++;
}
for (i=ICALPROPERTY_FIRST_ENUM; i != ICALPROPERTY_LAST_ENUM; i++) {
if ( strcmp(enum_map[i-ICALPROPERTY_FIRST_ENUM].str, str) == 0) {
return enum_map[i-ICALPROPERTY_FIRST_ENUM].prop_enum;
}
}
return 0;
}
int icalproperty_enum_belongs_to_property(icalproperty_kind kind, int e)
{
int i;
for (i=ICALPROPERTY_FIRST_ENUM; i != ICALPROPERTY_LAST_ENUM; i++) {
if(enum_map[i-ICALPROPERTY_FIRST_ENUM].prop_enum == e &&
enum_map[i-ICALPROPERTY_FIRST_ENUM].prop == kind ){
return 1;
}
}
return 0;
}
const char* icalproperty_method_to_string(icalproperty_method method)
{
icalerror_check_arg_rz(method >= ICAL_METHOD_X,"method");
icalerror_check_arg_rz(method <= ICAL_METHOD_NONE,"method");
return enum_map[method-ICALPROPERTY_FIRST_ENUM].str;
}
icalproperty_method icalproperty_string_to_method(const char* str)
{
int i;
icalerror_check_arg_rx(str!=0,"str",ICAL_METHOD_NONE)
while(*str == ' '){
str++;
}
for (i=ICAL_METHOD_X-ICALPROPERTY_FIRST_ENUM;
i != ICAL_METHOD_NONE-ICALPROPERTY_FIRST_ENUM;
i++) {
if ( strcmp(enum_map[i].str, str) == 0) {
return (icalproperty_method)enum_map[i].prop_enum;
}
}
return ICAL_METHOD_NONE;
}
const char* icalenum_status_to_string(icalproperty_status status)
{
icalerror_check_arg_rz(status >= ICAL_STATUS_X,"status");
icalerror_check_arg_rz(status <= ICAL_STATUS_NONE,"status");
return enum_map[status-ICALPROPERTY_FIRST_ENUM].str;
}
icalproperty_status icalenum_string_to_status(const char* str)
{
int i;
icalerror_check_arg_rx(str!=0,"str",ICAL_STATUS_NONE)
while(*str == ' '){
str++;
}
for (i=ICAL_STATUS_X-ICALPROPERTY_FIRST_ENUM;
i != ICAL_STATUS_NONE-ICALPROPERTY_FIRST_ENUM;
i++) {
if ( strcmp(enum_map[i].str, str) == 0) {
return (icalproperty_method)enum_map[i].prop_enum;
}
}
return ICAL_STATUS_NONE;
}
/* Everything below this line is machine generated. Do not edit. */
--- NEW FILE: icalparameter.h ---
/* -*- Mode: C -*- */
/*======================================================================
FILE: icalparam.h
CREATOR: eric 20 March 1999
$Id: icalparameter.h,v 1.1.2.1 2013-02-13 20:50:30 colin Exp $
$Locker: $
(C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
This program is free software; you can redistribute it and/or modify
it under the terms of either:
The LGPL as published by the Free Software Foundation, version
2.1, available at: http://www.fsf.org/copyleft/lesser.html
Or:
The Mozilla Public License Version 1.0. You may obtain a copy of
the License at http://www.mozilla.org/MPL/
The original code is icalparam.h
======================================================================*/
#ifndef ICALPARAM_H
#define ICALPARAM_H
#include "icalderivedparameter.h"
/* Declared in icalderivedparameter.h */
/*typedef void icalparameter;*/
icalparameter* icalparameter_new(icalparameter_kind kind);
icalparameter* icalparameter_new_clone(icalparameter* p);
/* Create from string of form "PARAMNAME=VALUE" */
icalparameter* icalparameter_new_from_string(const char* value);
/* Create from just the value, the part after the "=" */
icalparameter* icalparameter_new_from_value_string(icalparameter_kind kind, const char* value);
void icalparameter_free(icalparameter* parameter);
char* icalparameter_as_ical_string(icalparameter* parameter);
int icalparameter_is_valid(icalparameter* parameter);
icalparameter_kind icalparameter_isa(icalparameter* parameter);
int icalparameter_isa_parameter(void* param);
/* Acess the name of an X parameer */
void icalparameter_set_xname (icalparameter* param, const char* v);
const char* icalparameter_get_xname(icalparameter* param);
void icalparameter_set_xvalue (icalparameter* param, const char* v);
const char* icalparameter_get_xvalue(icalparameter* param);
/* Convert enumerations */
const char* icalparameter_kind_to_string(icalparameter_kind kind);
icalparameter_kind icalparameter_string_to_kind(const char* string);
#endif
--- NEW FILE: icalmemory.c ---
/* -*- Mode: C -*-
======================================================================
FILE: icalmemory.c
CREATOR: eric 30 June 1999
$Id: icalmemory.c,v 1.1.2.1 2013-02-13 20:50:30 colin Exp $
$Locker: $
The contents of this file are subject to the Mozilla Public License
Version 1.0 (the "License"); you may not use this file except in
compliance with the License. You may obtain a copy of the License at
http://www.mozilla.org/MPL/
Software distributed under the License is distributed on an "AS IS"
basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
the License for the specific language governing rights and
limitations under the License.
This program is free software; you can redistribute it and/or modify
it under the terms of either:
The LGPL as published by the Free Software Foundation, version
2.1, available at: http://www.fsf.org/copyleft/lesser.html
Or:
The Mozilla Public License Version 1.0. You may obtain a copy of
the License at http://www.mozilla.org/MPL/
The Original Code is icalmemory.h
======================================================================*/
/* libical often passes strings back to the caller. To make these
* interfaces simple, I did not want the caller to have to pass in a
* memory buffer, but having libical pass out newly allocated memory
* makes it difficult to de-allocate the memory.
*
* The ring buffer in this scheme makes it possible for libical to pass
* out references to memory which the caller does not own, and be able
* to de-allocate the memory later. The ring allows libical to have
* several buffers active simultaneously, which is handy when creating
* string representations of components. */
#define ICALMEMORY_C
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#ifdef DMALLOC
#include "dmalloc.h"
#endif
#include "icalmemory.h"
#include "icalerror.h"
#include <stdio.h> /* for printf (debugging) */
#include <stdlib.h> /* for malloc, realloc */
#include <string.h> /* for memset(), strdup */
#define BUFFER_RING_SIZE 250
#define MIN_BUFFER_SIZE 200
void icalmemory_free_tmp_buffer (void* buf);
/* HACK. Not threadsafe */
void* buffer_ring[BUFFER_RING_SIZE];
int buffer_pos = -1;
int initialized = 0;
/* Add an existing buffer to the buffer ring */
void icalmemory_add_tmp_buffer(void* buf)
{
/* I don't think I need this -- I think static arrays are
initialized to 0 as a standard part of C, but I am not sure. */
if (initialized == 0){
int i;
for(i=0; i<BUFFER_RING_SIZE; i++){
buffer_ring[i] = 0;
}
initialized = 1;
}
/* Wrap around the ring */
if(++buffer_pos == BUFFER_RING_SIZE){
buffer_pos = 0;
}
/* Free buffers as their slots are overwritten */
if ( buffer_ring[buffer_pos] != 0){
free( buffer_ring[buffer_pos]);
buffer_ring[buffer_pos] = 0;
}
/* Assign the buffer to a slot */
buffer_ring[buffer_pos] = buf;
}
/* Create a new temporary buffer on the ring. Libical owns these and
wil deallocate them. */
void*
icalmemory_tmp_buffer (size_t size)
{
char *buf;
if (size < MIN_BUFFER_SIZE){
size = MIN_BUFFER_SIZE;
}
buf = (void*)malloc(size);
if( buf == 0){
icalerror_set_errno(ICAL_NEWFAILED_ERROR);
return 0;
}
memset(buf,0,size);
icalmemory_add_tmp_buffer(buf);
return buf;
}
void icalmemory_free_ring()
{
int i;
for(i=0; i<BUFFER_RING_SIZE; i++){
if ( buffer_ring[i] != 0){
free( buffer_ring[i]);
}
buffer_ring[i] = 0;
}
initialized = 1;
}
/* Like strdup, but the buffer is on the ring. */
char*
icalmemory_tmp_copy(const char* str)
{
char* b = icalmemory_tmp_buffer(strlen(str)+1);
strcpy(b,str);
return b;
}
char* icalmemory_strdup(const char *s)
{
return strdup(s);
}
void
icalmemory_free_tmp_buffer (void* buf)
{
if(buf == 0)
{
return;
}
free(buf);
}
/* These buffer routines create memory the old fashioned way -- so the
caller will have to delocate the new memory */
void* icalmemory_new_buffer(size_t size)
{
void *b = malloc(size);
if( b == 0){
icalerror_set_errno(ICAL_NEWFAILED_ERROR);
return 0;
}
memset(b,0,size);
return b;
}
void* icalmemory_resize_buffer(void* buf, size_t size)
{
void *b = realloc(buf, size);
if( b == 0){
icalerror_set_errno(ICAL_NEWFAILED_ERROR);
return 0;
}
return b;
}
void icalmemory_free_buffer(void* buf)
{
free(buf);
}
void
icalmemory_append_string(char** buf, char** pos, size_t* buf_size,
const char* string)
{
char *new_buf;
char *new_pos;
size_t data_length, final_length, string_length;
#ifndef ICAL_NO_INTERNAL_DEBUG
icalerror_check_arg_rv( (buf!=0),"buf");
icalerror_check_arg_rv( (*buf!=0),"*buf");
icalerror_check_arg_rv( (pos!=0),"pos");
icalerror_check_arg_rv( (*pos!=0),"*pos");
icalerror_check_arg_rv( (buf_size!=0),"buf_size");
icalerror_check_arg_rv( (*buf_size!=0),"*buf_size");
icalerror_check_arg_rv( (string!=0),"string");
#endif
string_length = strlen(string);
data_length = (size_t)*pos - (size_t)*buf;
final_length = data_length + string_length;
if ( final_length >= (size_t) *buf_size) {
*buf_size = (*buf_size) * 2 + final_length;
new_buf = realloc(*buf,*buf_size);
new_pos = (void*)((size_t)new_buf + data_length);
*pos = new_pos;
*buf = new_buf;
}
strcpy(*pos, string);
*pos += string_length;
}
void
icalmemory_append_char(char** buf, char** pos, size_t* buf_size,
char ch)
{
char *new_buf;
char *new_pos;
size_t data_length, final_length;
#ifndef ICAL_NO_INTERNAL_DEBUG
icalerror_check_arg_rv( (buf!=0),"buf");
icalerror_check_arg_rv( (*buf!=0),"*buf");
icalerror_check_arg_rv( (pos!=0),"pos");
icalerror_check_arg_rv( (*pos!=0),"*pos");
icalerror_check_arg_rv( (buf_size!=0),"buf_size");
icalerror_check_arg_rv( (*buf_size!=0),"*buf_size");
#endif
data_length = (size_t)*pos - (size_t)*buf;
final_length = data_length + 2;
if ( final_length > (size_t) *buf_size ) {
*buf_size = (*buf_size) * 2 + final_length +1;
new_buf = realloc(*buf,*buf_size);
new_pos = (void*)((size_t)new_buf + data_length);
*pos = new_pos;
*buf = new_buf;
}
**pos = ch;
*pos += 1;
**pos = 0;
}
--- NEW FILE: Makefile.in ---
# Makefile.in generated by automake 1.11.6 from Makefile.am.
# @configure_input@
# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
# 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011 Free Software
# Foundation, Inc.
# This Makefile.in is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE.
@SET_MAKE@
#======================================================================
# FILE: Makefile.am
# CREATOR: eric
#
# $Id: Makefile.in,v 1.1.2.1 2013-02-13 20:50:29 colin 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
#
#======================================================================
VPATH = @srcdir@
am__make_dryrun = \
{ \
am__dry=no; \
case $$MAKEFLAGS in \
*\\[\ \ ]*) \
echo 'am--echo: ; @echo "AM" OK' | $(MAKE) -f - 2>/dev/null \
| grep '^AM OK$$' >/dev/null || am__dry=yes;; \
*) \
for am__flg in $$MAKEFLAGS; do \
case $$am__flg in \
*=*|--*) ;; \
*n*) am__dry=yes; break;; \
esac; \
done;; \
esac; \
test $$am__dry = yes; \
}
pkgdatadir = $(datadir)/@PACKAGE@
pkgincludedir = $(includedir)/@PACKAGE@
pkglibdir = $(libdir)/@PACKAGE@
pkglibexecdir = $(libexecdir)/@PACKAGE@
am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
install_sh_DATA = $(install_sh) -c -m 644
install_sh_PROGRAM = $(install_sh) -c
install_sh_SCRIPT = $(install_sh) -c
INSTALL_HEADER = $(INSTALL_DATA)
transform = $(program_transform_name)
NORMAL_INSTALL = :
PRE_INSTALL = :
POST_INSTALL = :
NORMAL_UNINSTALL = :
PRE_UNINSTALL = :
POST_UNINSTALL = :
build_triplet = @build@
host_triplet = @host@
target_triplet = @target@
subdir = src/plugins/vcalendar/libical/libical
DIST_COMMON = $(libicalinclude_HEADERS) $(srcdir)/Makefile.am \
$(srcdir)/Makefile.in $(srcdir)/icalversion.h.in icallexer.c \
icalyacc.c icalyacc.h
ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
am__aclocal_m4_deps = $(top_srcdir)/m4/check-type.m4 \
$(top_srcdir)/m4/gnupg-check-typedef.m4 \
$(top_srcdir)/m4/gnupg.m4 $(top_srcdir)/m4/gpgme.m4 \
$(top_srcdir)/m4/isc-posix.m4 $(top_srcdir)/m4/libtool.m4 \
$(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \
$(top_srcdir)/m4/ltversion.m4 $(top_srcdir)/m4/lt~obsolete.m4 \
$(top_srcdir)/m4/spamassassin.m4 $(top_srcdir)/configure.ac
am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
$(ACLOCAL_M4)
mkinstalldirs = $(SHELL) $(top_srcdir)/config/mkinstalldirs
CONFIG_HEADER = $(top_builddir)/config.h \
$(top_builddir)/claws-features.h
CONFIG_CLEAN_VPATH_FILES =
LTLIBRARIES = $(noinst_LTLIBRARIES)
libical_la_LIBADD =
am_libical_la_OBJECTS = icalattendee.lo icalcomponent.lo icalenums.lo \
icalerror.lo icallexer.lo icalmemory.lo icalmime.lo \
icalparameter.lo icalderivedparameter.lo icalparser.lo \
icalderivedproperty.lo icalproperty.lo icalrecur.lo \
icalrestriction.lo icaltime.lo icalduration.lo icalperiod.lo \
icaltypes.lo icalvalue.lo icalderivedvalue.lo icalyacc.lo \
pvl.lo sspm.lo vsnprintf.lo
libical_la_OBJECTS = $(am_libical_la_OBJECTS)
libical_la_LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) \
$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
$(libical_la_LDFLAGS) $(LDFLAGS) -o $@
DEFAULT_INCLUDES = -I. at am__isrc@ -I$(top_builddir)
depcomp = $(SHELL) $(top_srcdir)/config/depcomp
am__depfiles_maybe = depfiles
am__mv = mv -f
COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
LTCOMPILE = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
--mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
CCLD = $(CC)
LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
--mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) \
$(LDFLAGS) -o $@
@MAINTAINER_MODE_FALSE at am__skiplex = test -f $@ ||
LEXCOMPILE = $(LEX) $(AM_LFLAGS) $(LFLAGS)
LTLEXCOMPILE = $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
--mode=compile $(LEX) $(AM_LFLAGS) $(LFLAGS)
YLWRAP = $(top_srcdir)/config/ylwrap
@MAINTAINER_MODE_FALSE at am__skipyacc = test -f $@ ||
YACCCOMPILE = $(YACC) $(AM_YFLAGS) $(YFLAGS)
LTYACCCOMPILE = $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
--mode=compile $(YACC) $(AM_YFLAGS) $(YFLAGS)
SOURCES = $(libical_la_SOURCES)
DIST_SOURCES = $(libical_la_SOURCES)
am__can_run_installinfo = \
case $$AM_UPDATE_INFO_DIR in \
n|no|NO) false;; \
*) (install-info --version) >/dev/null 2>&1;; \
esac
am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
am__vpath_adj = case $$p in \
$(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
*) f=$$p;; \
esac;
am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
am__install_max = 40
am__nobase_strip_setup = \
srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
am__nobase_strip = \
for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
am__nobase_list = $(am__nobase_strip_setup); \
for p in $$list; do echo "$$p $$p"; done | \
sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
$(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
if (++n[$$2] == $(am__install_max)) \
{ print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
END { for (dir in files) print dir, files[dir] }'
am__base_list = \
sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
am__uninstall_files_from_dir = { \
test -z "$$files" \
|| { test ! -d "$$dir" && test ! -f "$$dir" && test ! -r "$$dir"; } \
|| { echo " ( cd '$$dir' && rm -f" $$files ")"; \
$(am__cd) "$$dir" && rm -f $$files; }; \
}
am__installdirs = "$(DESTDIR)$(libicalincludedir)"
HEADERS = $(libicalinclude_HEADERS)
ETAGS = etags
CTAGS = ctags
DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
ACLOCAL = @ACLOCAL@
ALLOCA = @ALLOCA@
AMTAR = @AMTAR@
AR = @AR@
AS = @AS@
AUTOCONF = @AUTOCONF@
AUTOHEADER = @AUTOHEADER@
AUTOMAKE = @AUTOMAKE@
AWK = @AWK@
CC = @CC@
CCDEPMODE = @CCDEPMODE@
CFLAGS = @CFLAGS@
COMPFACE_LIBS = @COMPFACE_LIBS@
CONIC_CFLAGS = @CONIC_CFLAGS@
CONIC_LIBS = @CONIC_LIBS@
CONTACTS_CFLAGS = @CONTACTS_CFLAGS@
CONTACTS_LIBS = @CONTACTS_LIBS@
CPP = @CPP@
CPPFLAGS = @CPPFLAGS@
CRYPT_LIBS = @CRYPT_LIBS@
CURL_CFLAGS = @CURL_CFLAGS@
CURL_LIBS = @CURL_LIBS@
CYGPATH_W = @CYGPATH_W@
DBUS_CFLAGS = @DBUS_CFLAGS@
DBUS_LIBS = @DBUS_LIBS@
DEFS = @DEFS@
DEPDIR = @DEPDIR@
DLLTOOL = @DLLTOOL@
DOCBOOK2HTML = @DOCBOOK2HTML@
DOCBOOK2PDF = @DOCBOOK2PDF@
DOCBOOK2PS = @DOCBOOK2PS@
DOCBOOK2TXT = @DOCBOOK2TXT@
DSYMUTIL = @DSYMUTIL@
DUMPBIN = @DUMPBIN@
ECHO_C = @ECHO_C@
ECHO_N = @ECHO_N@
ECHO_T = @ECHO_T@
EGREP = @EGREP@
ENCHANT_CFLAGS = @ENCHANT_CFLAGS@
ENCHANT_LIBS = @ENCHANT_LIBS@
EXEEXT = @EXEEXT@
EXTRA_VERSION = @EXTRA_VERSION@
FGREP = @FGREP@
GETTEXT_MACRO_VERSION = @GETTEXT_MACRO_VERSION@
GETTEXT_PACKAGE = @GETTEXT_PACKAGE@
GLIB_CFLAGS = @GLIB_CFLAGS@
GLIB_GENMARSHAL = @GLIB_GENMARSHAL@
GLIB_LIBS = @GLIB_LIBS@
GMSGFMT = @GMSGFMT@
GMSGFMT_015 = @GMSGFMT_015@
GNOME2_CFLAGS = @GNOME2_CFLAGS@
GNOME2_LIBS = @GNOME2_LIBS@
GNOME_CONFIG = @GNOME_CONFIG@
GNUTLS_CFLAGS = @GNUTLS_CFLAGS@
GNUTLS_LIBS = @GNUTLS_LIBS@
GPGME_CFLAGS = @GPGME_CFLAGS@
GPGME_CONFIG = @GPGME_CONFIG@
GPGME_LIBS = @GPGME_LIBS@
GREP = @GREP@
GTKPRINTUNIX_CFLAGS = @GTKPRINTUNIX_CFLAGS@
GTKPRINTUNIX_LIBS = @GTKPRINTUNIX_LIBS@
GTK_CFLAGS = @GTK_CFLAGS@
GTK_LIBS = @GTK_LIBS@
INSTALL = @INSTALL@
INSTALL_DATA = @INSTALL_DATA@
INSTALL_PROGRAM = @INSTALL_PROGRAM@
INSTALL_SCRIPT = @INSTALL_SCRIPT@
INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
INTLLIBS = @INTLLIBS@
INTL_MACOSX_LIBS = @INTL_MACOSX_LIBS@
JPILOT_LIBS = @JPILOT_LIBS@
LD = @LD@
LDAP_LIBS = @LDAP_LIBS@
LDFLAGS = @LDFLAGS@
LEX = @LEX@
LEXLIB = @LEXLIB@
LEX_OUTPUT_ROOT = lex.ical_yy
LIBETPAN_FLAGS = @LIBETPAN_FLAGS@
LIBETPAN_LIBS = @LIBETPAN_LIBS@
LIBICONV = @LIBICONV@
LIBINTL = @LIBINTL@
LIBOBJS = @LIBOBJS@
LIBRESOLV = @LIBRESOLV@
LIBS = @LIBS@
LIBSOUP_GNOME_CFLAGS = @LIBSOUP_GNOME_CFLAGS@
LIBSOUP_GNOME_LIBS = @LIBSOUP_GNOME_LIBS@
LIBTOOL = @LIBTOOL@
LIPO = @LIPO@
LN_S = @LN_S@
LTLIBICONV = @LTLIBICONV@
LTLIBINTL = @LTLIBINTL@
LTLIBOBJS = @LTLIBOBJS@
LT_AGE = @LT_AGE@
LT_CURRENT = @LT_CURRENT@
LT_RELEASE = @LT_RELEASE@
LT_REVISION = @LT_REVISION@
MAEMO_CFLAGS = @MAEMO_CFLAGS@
MAEMO_LIBS = @MAEMO_LIBS@
MAINT = @MAINT@
MAJOR_VERSION = @MAJOR_VERSION@
MAKEINFO = @MAKEINFO@
MANIFEST_TOOL = @MANIFEST_TOOL@
MICRO_VERSION = @MICRO_VERSION@
MINOR_VERSION = @MINOR_VERSION@
MKDIR_P = @MKDIR_P@
MSGFMT = @MSGFMT@
MSGFMT_015 = @MSGFMT_015@
MSGMERGE = @MSGMERGE@
NETWORKMANAGER_SUPPORT_CFLAGS = @NETWORKMANAGER_SUPPORT_CFLAGS@
NETWORKMANAGER_SUPPORT_LIBS = @NETWORKMANAGER_SUPPORT_LIBS@
NM = @NM@
NMEDIT = @NMEDIT@
OBJDUMP = @OBJDUMP@
OBJEXT = @OBJEXT@
OTOOL = @OTOOL@
OTOOL64 = @OTOOL64@
PACKAGE = @PACKAGE@
PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_URL = @PACKAGE_URL@
PACKAGE_VERSION = @PACKAGE_VERSION@
PASSCRYPT_KEY = @PASSCRYPT_KEY@
PATH_SEPARATOR = @PATH_SEPARATOR@
PKG_CONFIG = @PKG_CONFIG@
PKG_CONFIG_LIBDIR = @PKG_CONFIG_LIBDIR@
PKG_CONFIG_PATH = @PKG_CONFIG_PATH@
POSUB = @POSUB@
PTHREAD_LIBS = @PTHREAD_LIBS@
RANLIB = @RANLIB@
RC = @RC@
SED = @SED@
SET_MAKE = @SET_MAKE@
SHELL = @SHELL@
SM_LIBS = @SM_LIBS@
STARTUP_NOTIFICATION_CFLAGS = @STARTUP_NOTIFICATION_CFLAGS@
STARTUP_NOTIFICATION_LIBS = @STARTUP_NOTIFICATION_LIBS@
STRIP = @STRIP@
USE_NLS = @USE_NLS@
VALGRIND_CFLAGS = @VALGRIND_CFLAGS@
VALGRIND_LIBS = @VALGRIND_LIBS@
VERSION = @VERSION@
WEBKIT_CFLAGS = @WEBKIT_CFLAGS@
WEBKIT_LIBS = @WEBKIT_LIBS@
XGETTEXT = @XGETTEXT@
XGETTEXT_015 = @XGETTEXT_015@
XGETTEXT_EXTRA_OPTIONS = @XGETTEXT_EXTRA_OPTIONS@
YACC = @YACC@
YFLAGS = -d -v -t -pical_yy
abs_builddir = @abs_builddir@
abs_srcdir = @abs_srcdir@
abs_top_builddir = @abs_top_builddir@
abs_top_srcdir = @abs_top_srcdir@
ac_ct_AR = @ac_ct_AR@
ac_ct_CC = @ac_ct_CC@
ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
ac_cv_enable_crash_dialog = @ac_cv_enable_crash_dialog@
am__include = @am__include@
am__leading_dot = @am__leading_dot@
am__quote = @am__quote@
am__tar = @am__tar@
am__untar = @am__untar@
bindir = @bindir@
build = @build@
build_alias = @build_alias@
build_cpu = @build_cpu@
build_os = @build_os@
build_vendor = @build_vendor@
builddir = @builddir@
datadir = @datadir@
datarootdir = @datarootdir@
docdir = @docdir@
dvidir = @dvidir@
exec_prefix = @exec_prefix@
gnomedatadir = @gnomedatadir@
host = @host@
host_alias = @host_alias@
host_cpu = @host_cpu@
host_os = @host_os@
host_vendor = @host_vendor@
htmldir = @htmldir@
includedir = @includedir@
infodir = @infodir@
install_sh = @install_sh@
libdir = @libdir@
libetpanconfig = @libetpanconfig@
libexecdir = @libexecdir@
localedir = @localedir@
localstatedir = @localstatedir@
mandir = @mandir@
manualdir = @manualdir@
mkdir_p = @mkdir_p@
oldincludedir = @oldincludedir@
pdfdir = @pdfdir@
prefix = @prefix@
program_transform_name = @program_transform_name@
psdir = @psdir@
sbindir = @sbindir@
sharedstatedir = @sharedstatedir@
srcdir = @srcdir@
sysconfdir = @sysconfdir@
target = @target@
target_alias = @target_alias@
target_cpu = @target_cpu@
target_os = @target_os@
target_vendor = @target_vendor@
top_build_prefix = @top_build_prefix@
top_builddir = @top_builddir@
top_srcdir = @top_srcdir@
DESIGNDATA = $(top_srcdir)/src/plugins/vcalendar/libical/design-data
ICALSCRIPTS = $(top_srcdir)/src/plugins/vcalendar/libical/scripts
noinst_LTLIBRARIES = libical.la
LFLAGS = -Pical_yy
INCLUDES = \
-I$(top_builddir) \
-I$(top_srcdir) \
-I$(top_builddir) \
-I$(srcdir) \
-I$(top_srcdir)/src/plugins/vcalendar/libical \
-I$(top_srcdir)/src/plugins/vcalendar/libical/libical
libical_la_LDFLAGS = -version-info 0:0:0
libical_la_SOURCES = \
icalattendee.h \
icalattendee.c \
icalcomponent.c \
icalcomponent.h \
icalenums.c \
icalenums.h \
icalerror.c \
icalerror.h \
icallexer.l \
icalmemory.c \
icalmemory.h \
icalmime.c \
icalmime.h \
icalparameter.c \
icalparameter.h \
icalparameterimpl.h \
icalderivedparameter.c \
icalderivedparameter.h \
icalparser.c \
icalparser.h \
icalderivedproperty.c \
icalderivedproperty.h \
icalproperty.c \
icalproperty.h \
icalrecur.c \
icalrecur.h \
icalrestriction.c \
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 \
pvl.h \
sspm.c \
sspm.h \
vsnprintf.c \
icallangbind.h
libicalincludedir = $(includedir)/claws-mail/plugins/@PACKAGE@
libicalinclude_HEADERS = ical.h
# ORDERING OF HEADERS IS SIGNIFICANT. Don't change this ordering. It
# is required to make the combined header ical.h properly
COMBINEDHEADERS = \
$(top_builddir)/src/plugins/vcalendar/libical/libical/icalversion.h \
$(top_srcdir)/src/plugins/vcalendar/libical/libical/icaltime.h \
$(top_srcdir)/src/plugins/vcalendar/libical/libical/icalduration.h \
$(top_srcdir)/src/plugins/vcalendar/libical/libical/icalperiod.h \
$(top_srcdir)/src/plugins/vcalendar/libical/libical/icalenums.h \
$(top_srcdir)/src/plugins/vcalendar/libical/libical/icaltypes.h \
$(top_srcdir)/src/plugins/vcalendar/libical/libical/icalrecur.h \
icalderivedvalue.h \
icalderivedparameter.h \
icalvalue.h \
icalparameter.h \
icalderivedproperty.h \
icalproperty.h \
$(top_srcdir)/src/plugins/vcalendar/libical/libical/icalattendee.h \
$(top_srcdir)/src/plugins/vcalendar/libical/libical/pvl.h \
$(top_srcdir)/src/plugins/vcalendar/libical/libical/icalcomponent.h \
$(top_srcdir)/src/plugins/vcalendar/libical/libical/icalparser.h \
$(top_srcdir)/src/plugins/vcalendar/libical/libical/icalmemory.h \
$(top_srcdir)/src/plugins/vcalendar/libical/libical/icalerror.h \
$(top_srcdir)/src/plugins/vcalendar/libical/libical/icalrestriction.h \
$(top_srcdir)/src/plugins/vcalendar/libical/libical/sspm.h \
$(top_srcdir)/src/plugins/vcalendar/libical/libical/icalmime.h \
$(top_srcdir)/src/plugins/vcalendar/libical/libical/icallangbind.h
BUILT_SOURCES = \
ical.h \
icalderivedparameter.c \
icalderivedparameter.h \
icalderivedproperty.c \
icalderivedproperty.h \
icalrestriction.c \
icalderivedvalue.c \
icalderivedvalue.h
# parameters
PARAMETERDEPS = \
$(ICALSCRIPTS)/mkderivedparameters.pl \
$(DESIGNDATA)/parameters.csv \
icalderivedparameter.c.in \
icalderivedparameter.h.in
# properties
PROPERTYDEPS = \
$(ICALSCRIPTS)/mkderivedproperties.pl \
$(DESIGNDATA)/properties.csv \
$(DESIGNDATA)/value-types.csv \
icalderivedproperty.c.in \
icalderivedproperty.h.in
# restrictions
RESTRICTIONDEPS = \
$(ICALSCRIPTS)/mkrestrictiontable.pl \
$(DESIGNDATA)/restrictions.csv \
icalrestriction.c.in
# values
VALUEDEPS = \
$(ICALSCRIPTS)/mkderivedvalues.pl \
$(DESIGNDATA)/value-types.csv \
icalderivedvalue.c.in \
icalderivedvalue.h.in
# housekeeping
CONFIG_CLEAN_FILES = y.output
CLEANFILES = $(BUILT_SOURCES)
EXTRA_DIST = \
icalderivedparameter.c.in \
icalderivedparameter.h.in \
icalderivedproperty.c.in \
icalderivedproperty.h.in \
icalrestriction.c.in \
icalderivedvalue.c.in \
icalderivedvalue.h.in \
icalversion.h.in \
icallexer.c \
icalyacc.c
AM_CPPFLAGS = -DNDEBUG $(GLIB_CFLAGS)
all: $(BUILT_SOURCES)
$(MAKE) $(AM_MAKEFLAGS) all-am
.SUFFIXES:
.SUFFIXES: .c .l .lo .o .obj .y
$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ $(srcdir)/Makefile.am $(am__configure_deps)
@for dep in $?; do \
case '$(am__configure_deps)' in \
*$$dep*) \
( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
&& { if test -f $@; then exit 0; else break; fi; }; \
exit 1;; \
esac; \
done; \
echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign src/plugins/vcalendar/libical/libical/Makefile'; \
$(am__cd) $(top_srcdir) && \
$(AUTOMAKE) --foreign src/plugins/vcalendar/libical/libical/Makefile
.PRECIOUS: Makefile
Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
@case '$?' in \
*config.status*) \
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
*) \
echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
esac;
$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(top_srcdir)/configure: @MAINTAINER_MODE_TRUE@ $(am__configure_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(ACLOCAL_M4): @MAINTAINER_MODE_TRUE@ $(am__aclocal_m4_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(am__aclocal_m4_deps):
icalversion.h: $(top_builddir)/config.status $(srcdir)/icalversion.h.in
cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@
clean-noinstLTLIBRARIES:
-test -z "$(noinst_LTLIBRARIES)" || rm -f $(noinst_LTLIBRARIES)
@list='$(noinst_LTLIBRARIES)'; for p in $$list; do \
dir="`echo $$p | sed -e 's|/[^/]*$$||'`"; \
test "$$dir" != "$$p" || dir=.; \
echo "rm -f \"$${dir}/so_locations\""; \
rm -f "$${dir}/so_locations"; \
done
icalyacc.h: icalyacc.c
@if test ! -f $@; then rm -f icalyacc.c; else :; fi
@if test ! -f $@; then $(MAKE) $(AM_MAKEFLAGS) icalyacc.c; else :; fi
libical.la: $(libical_la_OBJECTS) $(libical_la_DEPENDENCIES) $(EXTRA_libical_la_DEPENDENCIES)
$(libical_la_LINK) $(libical_la_OBJECTS) $(libical_la_LIBADD) $(LIBS)
mostlyclean-compile:
-rm -f *.$(OBJEXT)
distclean-compile:
-rm -f *.tab.c
@AMDEP_TRUE@@am__include@ @am__quote at ./$(DEPDIR)/icalattendee.Plo at am__quote@
@AMDEP_TRUE@@am__include@ @am__quote at ./$(DEPDIR)/icalcomponent.Plo at am__quote@
@AMDEP_TRUE@@am__include@ @am__quote at ./$(DEPDIR)/icalderivedparameter.Plo at am__quote@
@AMDEP_TRUE@@am__include@ @am__quote at ./$(DEPDIR)/icalderivedproperty.Plo at am__quote@
@AMDEP_TRUE@@am__include@ @am__quote at ./$(DEPDIR)/icalderivedvalue.Plo at am__quote@
@AMDEP_TRUE@@am__include@ @am__quote at ./$(DEPDIR)/icalduration.Plo at am__quote@
@AMDEP_TRUE@@am__include@ @am__quote at ./$(DEPDIR)/icalenums.Plo at am__quote@
@AMDEP_TRUE@@am__include@ @am__quote at ./$(DEPDIR)/icalerror.Plo at am__quote@
@AMDEP_TRUE@@am__include@ @am__quote at ./$(DEPDIR)/icallexer.Plo at am__quote@
@AMDEP_TRUE@@am__include@ @am__quote at ./$(DEPDIR)/icalmemory.Plo at am__quote@
@AMDEP_TRUE@@am__include@ @am__quote at ./$(DEPDIR)/icalmime.Plo at am__quote@
@AMDEP_TRUE@@am__include@ @am__quote at ./$(DEPDIR)/icalparameter.Plo at am__quote@
@AMDEP_TRUE@@am__include@ @am__quote at ./$(DEPDIR)/icalparser.Plo at am__quote@
@AMDEP_TRUE@@am__include@ @am__quote at ./$(DEPDIR)/icalperiod.Plo at am__quote@
@AMDEP_TRUE@@am__include@ @am__quote at ./$(DEPDIR)/icalproperty.Plo at am__quote@
@AMDEP_TRUE@@am__include@ @am__quote at ./$(DEPDIR)/icalrecur.Plo at am__quote@
@AMDEP_TRUE@@am__include@ @am__quote at ./$(DEPDIR)/icalrestriction.Plo at am__quote@
@AMDEP_TRUE@@am__include@ @am__quote at ./$(DEPDIR)/icaltime.Plo at am__quote@
@AMDEP_TRUE@@am__include@ @am__quote at ./$(DEPDIR)/icaltypes.Plo at am__quote@
@AMDEP_TRUE@@am__include@ @am__quote at ./$(DEPDIR)/icalvalue.Plo at am__quote@
@AMDEP_TRUE@@am__include@ @am__quote at ./$(DEPDIR)/icalyacc.Plo at am__quote@
@AMDEP_TRUE@@am__include@ @am__quote at ./$(DEPDIR)/pvl.Plo at am__quote@
@AMDEP_TRUE@@am__include@ @am__quote at ./$(DEPDIR)/sspm.Plo at am__quote@
@AMDEP_TRUE@@am__include@ @am__quote at ./$(DEPDIR)/vsnprintf.Plo at am__quote@
.c.o:
@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
@am__fastdepCC_TRUE@ $(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@ $(COMPILE) -c $<
.c.obj:
@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
@am__fastdepCC_TRUE@ $(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@ $(COMPILE) -c `$(CYGPATH_W) '$<'`
.c.lo:
@am__fastdepCC_TRUE@ $(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
@am__fastdepCC_TRUE@ $(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo
@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@ $(LTCOMPILE) -c -o $@ $<
.l.c:
$(am__skiplex) $(SHELL) $(YLWRAP) $< $(LEX_OUTPUT_ROOT).c $@ -- $(LEXCOMPILE)
.y.c:
$(am__skipyacc) $(SHELL) $(YLWRAP) $< y.tab.c $@ y.tab.h $*.h y.output $*.output -- $(YACCCOMPILE)
mostlyclean-libtool:
-rm -f *.lo
clean-libtool:
-rm -rf .libs _libs
install-libicalincludeHEADERS: $(libicalinclude_HEADERS)
@$(NORMAL_INSTALL)
@list='$(libicalinclude_HEADERS)'; test -n "$(libicalincludedir)" || list=; \
if test -n "$$list"; then \
echo " $(MKDIR_P) '$(DESTDIR)$(libicalincludedir)'"; \
$(MKDIR_P) "$(DESTDIR)$(libicalincludedir)" || exit 1; \
fi; \
for p in $$list; do \
if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
echo "$$d$$p"; \
done | $(am__base_list) | \
while read files; do \
echo " $(INSTALL_HEADER) $$files '$(DESTDIR)$(libicalincludedir)'"; \
$(INSTALL_HEADER) $$files "$(DESTDIR)$(libicalincludedir)" || exit $$?; \
done
uninstall-libicalincludeHEADERS:
@$(NORMAL_UNINSTALL)
@list='$(libicalinclude_HEADERS)'; test -n "$(libicalincludedir)" || list=; \
files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
dir='$(DESTDIR)$(libicalincludedir)'; $(am__uninstall_files_from_dir)
ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
END { if (nonempty) { for (i in files) print i; }; }'`; \
mkid -fID $$unique
tags: TAGS
TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
$(TAGS_FILES) $(LISP)
set x; \
here=`pwd`; \
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
END { if (nonempty) { for (i in files) print i; }; }'`; \
shift; \
if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
test -n "$$unique" || unique=$$empty_fix; \
if test $$# -gt 0; then \
$(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
"$$@" $$unique; \
else \
$(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
$$unique; \
fi; \
fi
ctags: CTAGS
CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
$(TAGS_FILES) $(LISP)
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
END { if (nonempty) { for (i in files) print i; }; }'`; \
test -z "$(CTAGS_ARGS)$$unique" \
|| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
$$unique
GTAGS:
here=`$(am__cd) $(top_builddir) && pwd` \
&& $(am__cd) $(top_srcdir) \
&& gtags -i $(GTAGS_ARGS) "$$here"
distclean-tags:
-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
distdir: $(DISTFILES)
@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
list='$(DISTFILES)'; \
dist_files=`for file in $$list; do echo $$file; done | \
sed -e "s|^$$srcdirstrip/||;t" \
-e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
case $$dist_files in \
*/*) $(MKDIR_P) `echo "$$dist_files" | \
sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
sort -u` ;; \
esac; \
for file in $$dist_files; do \
if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
if test -d $$d/$$file; then \
dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
if test -d "$(distdir)/$$file"; then \
find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
fi; \
if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
fi; \
cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
else \
test -f "$(distdir)/$$file" \
|| cp -p $$d/$$file "$(distdir)/$$file" \
|| exit 1; \
fi; \
done
check-am: all-am
check: $(BUILT_SOURCES)
$(MAKE) $(AM_MAKEFLAGS) check-am
all-am: Makefile $(LTLIBRARIES) $(HEADERS)
installdirs:
for dir in "$(DESTDIR)$(libicalincludedir)"; do \
test -z "$$dir" || $(MKDIR_P) "$$dir"; \
done
install: $(BUILT_SOURCES)
$(MAKE) $(AM_MAKEFLAGS) install-am
install-exec: install-exec-am
install-data: install-data-am
uninstall: uninstall-am
install-am: all-am
@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
installcheck: installcheck-am
install-strip:
if test -z '$(STRIP)'; then \
$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
install; \
else \
$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
"INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \
fi
mostlyclean-generic:
clean-generic:
-test -z "$(CLEANFILES)" || rm -f $(CLEANFILES)
distclean-generic:
-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
maintainer-clean-generic:
@echo "This command is intended for maintainers to use"
@echo "it deletes files that may require special tools to rebuild."
-rm -f icallexer.c
-rm -f icalyacc.c
-rm -f icalyacc.h
-test -z "$(BUILT_SOURCES)" || rm -f $(BUILT_SOURCES)
clean: clean-am
clean-am: clean-generic clean-libtool clean-noinstLTLIBRARIES \
mostlyclean-am
distclean: distclean-am
-rm -rf ./$(DEPDIR)
-rm -f Makefile
distclean-am: clean-am distclean-compile distclean-generic \
distclean-tags
dvi: dvi-am
dvi-am:
html: html-am
html-am:
info: info-am
info-am:
install-data-am: install-libicalincludeHEADERS
install-dvi: install-dvi-am
install-dvi-am:
install-exec-am:
install-html: install-html-am
install-html-am:
install-info: install-info-am
install-info-am:
install-man:
install-pdf: install-pdf-am
install-pdf-am:
install-ps: install-ps-am
install-ps-am:
installcheck-am:
maintainer-clean: maintainer-clean-am
-rm -rf ./$(DEPDIR)
-rm -f Makefile
maintainer-clean-am: distclean-am maintainer-clean-generic
mostlyclean: mostlyclean-am
mostlyclean-am: mostlyclean-compile mostlyclean-generic \
mostlyclean-libtool
pdf: pdf-am
pdf-am:
ps: ps-am
ps-am:
uninstall-am: uninstall-libicalincludeHEADERS
.MAKE: all check install install-am install-strip
.PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \
clean-libtool clean-noinstLTLIBRARIES ctags distclean \
distclean-compile distclean-generic distclean-libtool \
distclean-tags distdir dvi dvi-am html html-am info info-am \
install install-am install-data install-data-am install-dvi \
install-dvi-am install-exec install-exec-am install-html \
install-html-am install-info install-info-am \
install-libicalincludeHEADERS install-man install-pdf \
install-pdf-am install-ps install-ps-am install-strip \
installcheck installcheck-am installdirs maintainer-clean \
maintainer-clean-generic mostlyclean mostlyclean-compile \
mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
tags uninstall uninstall-am uninstall-libicalincludeHEADERS
ical.h: $(COMBINEDHEADERS)
cat $(COMBINEDHEADERS) \
| egrep -v "#include.*\"ical" \
| egrep -v "#include.*\"pvl\.h\"" > ical.h
icallexer.c : icalyacc.h
icalderivedparameter.h: $(PARAMETERDEPS)
$(PERL) -I $(ICALSCRIPTS) $(ICALSCRIPTS)/mkderivedparameters.pl -i $(srcdir)/icalderivedparameter.h.in -h $(DESIGNDATA)/parameters.csv > icalderivedparameter.h
icalderivedparameter.c: $(PARAMETERDEPS) icalparameter.h
$(PERL) -I $(ICALSCRIPTS) $(ICALSCRIPTS)/mkderivedparameters.pl -i $(srcdir)/icalderivedparameter.c.in -c $(DESIGNDATA)/parameters.csv > icalderivedparameter.c
icalderivedproperty.h: $(PROPERTYDEPS)
$(PERL) -I$(ICALSCRIPTS) $(ICALSCRIPTS)/mkderivedproperties.pl \
-i $(srcdir)/icalderivedproperty.h.in -h $(DESIGNDATA)/properties.csv\
${DESIGNDATA}/value-types.csv > icalderivedproperty.h
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
icalrestriction.c: $(RESTRICTIONDEPS)
$(PERL) $(ICALSCRIPTS)/mkrestrictiontable.pl -i $(srcdir)/icalrestriction.c.in \
$(DESIGNDATA)/restrictions.csv > icalrestriction.c
icalderivedvalue.h: $(VALUEDEPS)
$(PERL) -I$(ICALSCRIPTS) $(ICALSCRIPTS)/mkderivedvalues.pl \
-i $(srcdir)/icalderivedvalue.h.in -h $(DESIGNDATA)/value-types.csv > icalderivedvalue.h
icalderivedvalue.c: $(VALUEDEPS) icalderivedvalue.h
$(PERL) -I$(ICALSCRIPTS) $(ICALSCRIPTS)/mkderivedvalues.pl \
-i $(srcdir)/icalderivedvalue.c.in -c $(DESIGNDATA)/value-types.csv > icalderivedvalue.c
# Tell versions [3.59,3.63) of GNU make to not export all variables.
# Otherwise a system limit (for SysV at least) may be exceeded.
.NOEXPORT:
--- NEW FILE: icallangbind.h ---
/* -*- Mode: C -*-
======================================================================
FILE: icallangbind.h
CREATOR: eric 25 jan 2001
DESCRIPTION:
$Id: icallangbind.h,v 1.1.2.1 2013-02-13 20:50:30 colin Exp $
$Locker: $
(C) COPYRIGHT 1999 Eric Busboom
http://www.softwarestudio.org
This package is free software and is provided "as is" without
express or implied warranty. It may be used, redistributed and/or
modified under the same terms as perl itself. ( Either the Artistic
License or the GPL. )
======================================================================*/
#ifndef __ICALLANGBIND_H__
#define __ICALLANGBIND_H__
int* icallangbind_new_array(int size);
void icallangbind_free_array(int* array);
int icallangbind_access_array(int* array, int index);
icalproperty* icallangbind_get_property(icalcomponent *c, int n, const char* prop);
const char* icallangbind_get_property_val(icalproperty* p);
const char* icallangbind_get_parameter(icalproperty *p, const char* parameter);
icalcomponent* icallangbind_get_component(icalcomponent *c, const char* comp);
icalproperty* icallangbind_get_first_property(icalcomponent *c,
const char* prop);
icalproperty* icallangbind_get_next_property(icalcomponent *c,
const char* prop);
icalcomponent* icallangbind_get_first_component(icalcomponent *c,
const char* comp);
icalcomponent* icallangbind_get_next_component(icalcomponent *c,
const char* comp);
const char* icallangbind_property_eval_string(icalproperty* prop, char* sep);
int icallangbind_string_to_open_flag(const char* str);
#endif /*__ICALLANGBIND_H__*/
--- NEW FILE: icalattendee.h ---
/* -*- Mode: C -*- */
/*======================================================================
FILE: icalattendee.h
CREATOR: eric 8 Mar 01
(C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
This program is free software; you can redistribute it and/or modify
it under the terms of either:
The LGPL as published by the Free Software Foundation, version
2.1, available at: http://www.fsf.org/copyleft/lesser.html
Or:
The Mozilla Public License Version 1.0. You may obtain a copy of
the License at http://www.mozilla.org/MPL/
The original code is icaltypes.h
======================================================================*/
#ifndef ICALATTENDEE_H
#define ICALATTENDEE_H
#include <time.h>
#include "icalenums.h"
#include "icaltime.h"
#include "icalduration.h"
#include "icalperiod.h"
#include "icalderivedparameter.h"
#include "icalderivedvalue.h"
struct icalorganizertype {
const char* value;
const char* common_name;
const char* dir;
const char* sentby;
const char* language;
};
/* Create a copy of the given organizer. Libical will not own the
memory for the strings in the copy; the call must free them */
struct icalorganizertype icalorganizertype_new_clone(struct icalorganizertype a);
struct icalattendeetype {
const char* cuid; /* Cal user id, contents of the property value */
/*icalparameter_cutype cutype;*/
const char* member;
/*icalparameter_role role;*/
int rsvp;
const char* delto;
const char* delfrom;
const char* sentby;
const char* cn;
const char* dir;
const char* language;
};
/* Create a copy of the given attendee. Libical will not own the
memory for the strings in the copy; the call must free them */
struct icalattendeetype icalattendeetype_new_clone(struct icalattendeetype a);
#endif /* !ICALATTENDEE_H */
--- NEW FILE: icalparameterimpl.h ---
/* -*- Mode: C -*-
======================================================================
FILE: icalparameterimpl.h
CREATOR: eric 09 May 1999
$Id: icalparameterimpl.h,v 1.1.2.1 2013-02-13 20:50:30 colin Exp $
$Locker: $
(C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
This program is free software; you can redistribute it and/or modify
it under the terms of either:
The LGPL as published by the Free Software Foundation, version
2.1, available at: http://www.fsf.org/copyleft/lesser.html
Or:
The Mozilla Public License Version 1.0. You may obtain a copy of
the License at http://www.mozilla.org/MPL/
The original code is icalderivedparameters.{c,h}
Contributions from:
Graham Davison (g.m.davison at computer.org)
======================================================================*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#ifndef ICALPARAMETER_IMPL
#define ICALPARAMETER_IMPL
#include "icalparameter.h"
#include "icalproperty.h"
struct icalparameter_impl
{
icalparameter_kind kind;
char id[5];
int size;
const char* string;
const char* x_name;
icalproperty* parent;
int data;
};
#endif /*ICALPARAMETER_IMPL*/
--- NEW FILE: icallangbind.c ---
/* -*- Mode: C -*-
======================================================================
FILE: icallangbind.c
CREATOR: eric 15 dec 2000
DESCRIPTION:
$Id: icallangbind.c,v 1.1.2.1 2013-02-13 20:50:30 colin Exp $
$Locker: $
(C) COPYRIGHT 1999 Eric Busboom
http://www.softwarestudio.org
This package is free software and is provided "as is" without
express or implied warranty. It may be used, redistributed and/or
modified under the same terms as perl itself. ( Either the Artistic
License or the GPL. )
======================================================================*/
#include "icalcomponent.h"
#include "icalproperty.h"
#include "icalerror.h"
#include "icalmemory.h"
#include <malloc.h>
#include <string.h>
int* icallangbind_new_array(int size){
int* p = (int*)malloc(size*sizeof(int));
return p; /* Caller handles failures */
}
void icallangbind_free_array(int* array){
free(array);
}
int icallangbind_access_array(int* array, int index) {
return array[index];
}
/* LIke icalcomponent_get_first_component, buut takes a string for the
kind and can iterate over X properties as if each X name was a
seperate kind */
icalproperty* icallangbind_get_first_property(icalcomponent *c,
const char* prop)
{
icalproperty_kind kind = icalproperty_string_to_kind(prop);
icalproperty *p;
if (kind == ICAL_NO_PROPERTY){
return 0;
}
if(kind == ICAL_X_PROPERTY){
for(p = icalcomponent_get_first_property(c,kind);
p !=0;
p = icalcomponent_get_next_property(c,kind)){
if(strcmp(icalproperty_get_x_name(p),prop) == 0){
return p;
}
}
} else {
p=icalcomponent_get_first_property(c,kind);
return p;
}
return 0;
}
icalproperty* icallangbind_get_next_property(icalcomponent *c,
const char* prop)
{
icalproperty_kind kind = icalenum_string_to_property_kind(prop);
icalproperty *p;
if (kind == ICAL_NO_PROPERTY){
return 0;
}
if(kind == ICAL_X_PROPERTY){
for(p = icalcomponent_get_next_property(c,kind);
p !=0;
p = icalcomponent_get_next_property(c,kind)){
if(strcmp(icalproperty_get_x_name(p),prop) == 0){
return p;
}
}
} else {
p=icalcomponent_get_next_property(c,kind);
return p;
}
return 0;
}
icalcomponent* icallangbind_get_first_component(icalcomponent *c,
const char* comp)
{
icalcomponent_kind kind = icalenum_string_to_component_kind(comp);
if (kind == ICAL_NO_COMPONENT){
return 0;
}
return icalcomponent_get_first_component(c,kind);
}
icalcomponent* icallangbind_get_next_component(icalcomponent *c,
const char* comp)
{
icalcomponent_kind kind = icalenum_string_to_component_kind(comp);
if (kind == ICAL_NO_COMPONENT){
return 0;
}
return icalcomponent_get_next_component(c,kind);
}
#define APPENDS(x) icalmemory_append_string(&buf, &buf_ptr, &buf_size, x);
#define APPENDC(x) icalmemory_append_char(&buf, &buf_ptr, &buf_size, x);
const char* icallangbind_property_eval_string(icalproperty* prop, char* sep)
{
char tmp[25];
size_t buf_size = 1024;
char* buf = icalmemory_new_buffer(buf_size);
char* buf_ptr = buf;
icalparameter *param;
icalvalue* value;
if( prop == 0){
return 0;
}
APPENDS("{ ");
value = icalproperty_get_value(prop);
APPENDS(" 'name' ");
APPENDS(sep);
APPENDC('\'');
APPENDS(icalenum_property_kind_to_string(icalproperty_isa(prop)));
APPENDC('\'');
if(value){
APPENDS(", 'value_type' ");
APPENDS(sep);
APPENDC('\'');
APPENDS(icalenum_value_kind_to_string(icalvalue_isa(value)));
APPENDC('\'');
}
APPENDS(", 'pid' ");
APPENDS(sep);
APPENDC('\'');
snprintf(tmp,25,"%p",prop);
APPENDS(tmp);
APPENDC('\'');
if(value){
switch (icalvalue_isa(value)){
case ICAL_ATTACH_VALUE:
case ICAL_BINARY_VALUE:
case ICAL_NO_VALUE: {
icalerror_set_errno(ICAL_INTERNAL_ERROR);
break;
}
default:
{
const char* str = icalvalue_as_ical_string(value);
char* copy = (char*) malloc(strlen(str)+1);
const char *i;
char *j;
if(copy ==0){
icalerror_set_errno(ICAL_NEWFAILED_ERROR);
break;
}
/* Remove any newlines */
for(j=copy, i = str; *i != 0; j++,i++){
if(*i=='\n'){
i++;
}
*j = *i;
}
*j = 0;
APPENDS(", 'value'");
APPENDS(sep);
APPENDC('\'');
APPENDS(copy);
APPENDC('\'');
free(copy);
break;
}
}
}
/* Add Parameters */
for(param = icalproperty_get_first_parameter(prop,ICAL_ANY_PARAMETER);
param != 0;
param = icalproperty_get_next_parameter(prop,ICAL_ANY_PARAMETER)){
const char* str = icalparameter_as_ical_string(param);
char *copy = icalmemory_tmp_copy(str);
char *v;
if(copy == 0){
icalerror_set_errno(ICAL_NEWFAILED_ERROR);
continue;
}
v = strchr(copy,'=');
if(v == 0){
continue;
}
*v = 0;
v++;
APPENDS(", ");
APPENDC('\'');
APPENDS(copy);
APPENDC('\'');
APPENDS(sep);
APPENDC('\'');
APPENDS(v);
APPENDC('\'');
}
APPENDC('}');
icalmemory_add_tmp_buffer(buf);
return buf;
}
#include "fcntl.h"
int icallangbind_string_to_open_flag(const char* str)
{
if (strcmp(str,"r") == 0) {return O_RDONLY;}
else if (strcmp(str,"r+") == 0) {return O_RDWR;}
else if (strcmp(str,"w") == 0) {return O_WRONLY;}
else if (strcmp(str,"a") == 0) {return O_WRONLY|O_APPEND;}
else return -1;
}
--- NEW FILE: icalversion.h ---
#ifndef ICAL_VERSION_H
#define ICAL_VERSION_H
#define ICAL_PACKAGE "claws-mail"
#define ICAL_VERSION "3.9.0cvs64"
#endif
--- NEW FILE: icalrestriction.h ---
/* -*- Mode: C -*- */
/*======================================================================
FILE: icalrestriction.h
CREATOR: eric 24 April 1999
$Id: icalrestriction.h,v 1.1.2.1 2013-02-13 20:50:30 colin 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 icalrestriction.h
Contributions from:
Graham Davison (g.m.davison at computer.org)
======================================================================*/
#include "icalproperty.h"
#include "icalcomponent.h"
#ifndef ICALRESTRICTION_H
#define ICALRESTRICTION_H
/* These must stay in this order for icalrestriction_compare to work */
typedef enum icalrestriction_kind {
ICAL_RESTRICTION_NONE=0, /* 0 */
ICAL_RESTRICTION_ZERO, /* 1 */
ICAL_RESTRICTION_ONE, /* 2 */
ICAL_RESTRICTION_ZEROPLUS, /* 3 */
ICAL_RESTRICTION_ONEPLUS, /* 4 */
ICAL_RESTRICTION_ZEROORONE, /* 5 */
ICAL_RESTRICTION_ONEEXCLUSIVE, /* 6 */
ICAL_RESTRICTION_ONEMUTUAL, /* 7 */
ICAL_RESTRICTION_UNKNOWN /* 8 */
} icalrestriction_kind;
int
icalrestriction_compare(icalrestriction_kind restr, int count);
int
icalrestriction_is_parameter_allowed(icalproperty_kind property,
icalparameter_kind parameter);
int icalrestriction_check(icalcomponent* comp);
#endif /* !ICALRESTRICTION_H */
--- NEW FILE: pvl.h ---
/*======================================================================
FILE: pvl.h
CREATOR: eric November, 1995
(C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
======================================================================*/
#ifndef __PVL_H__
#define __PVL_H__
typedef void* pvl_list;
typedef void* pvl_elem;
/*
struct pvl_elem_t
This type is private. Always use pvl_elem instead. The struct would
not even appear in this header except to make code in the USE_MACROS
blocks work
*/
typedef struct pvl_elem_t
{
int MAGIC; /* Magic Identifier */
void *d; /* Pointer to data user is storing */
struct pvl_elem_t *next; /* Next element */
struct pvl_elem_t *prior; /* prior element */
} pvl_elem_t;
/* This global is incremented for each call to pvl_new_element(); it gives each
* list a unique identifer */
extern int pvl_elem_count;
extern int pvl_list_count;
/* Create new lists or elements */
pvl_elem pvl_new_element(void* d, pvl_elem next,pvl_elem prior);
pvl_list pvl_newlist(void);
void pvl_free(pvl_list);
/* Add, remove, or get the head of the list */
void pvl_unshift(pvl_list l,void *d);
void* pvl_shift(pvl_list l);
pvl_elem pvl_head(pvl_list);
/* Add, remove or get the tail of the list */
void pvl_push(pvl_list l,void *d);
void* pvl_pop(pvl_list l);
pvl_elem pvl_tail(pvl_list);
/* Insert elements in random places */
typedef int (*pvl_comparef)(void* a, void* b); /* a, b are of the data type*/
void pvl_insert_ordered(pvl_list l,pvl_comparef f,void *d);
void pvl_insert_after(pvl_list l,pvl_elem e,void *d);
void pvl_insert_before(pvl_list l,pvl_elem e,void *d);
/* Remove an element, or clear the entire list */
void* pvl_remove(pvl_list,pvl_elem); /* Remove element, return data */
void pvl_clear(pvl_list); /* Remove all elements, de-allocate all data */
int pvl_count(pvl_list);
/* Navagate the list */
pvl_elem pvl_next(pvl_elem e);
pvl_elem pvl_prior(pvl_elem e);
/* get the data in the list */
#ifndef PVL_USE_MACROS
void* pvl_data(pvl_elem);
#else
#define pvl_data(x) x==0 ? 0 : ((struct pvl_elem_t *)x)->d;
#endif
/* Find an element for which a function returns true */
typedef int (*pvl_findf)(void* a, void* b); /*a is list elem, b is other data*/
pvl_elem pvl_find(pvl_list l,pvl_findf f,void* v);
pvl_elem pvl_find_next(pvl_list l,pvl_findf f,void* v);
/* Pass each element in the list to a function */
typedef void (*pvl_applyf)(void* a, void* b); /*a is list elem, b is other data*/
void pvl_apply(pvl_list l,pvl_applyf f, void *v);
#endif /* __PVL_H__ */
--- NEW FILE: icalparser.c ---
/* -*- Mode: C -*-
======================================================================
FILE: icalparser.c
CREATOR: eric 04 August 1999
$Id: icalparser.c,v 1.1.2.1 2013-02-13 20:50:30 colin Exp $
$Locker: $
The contents of this file are subject to the Mozilla Public License
Version 1.0 (the "License"); you may not use this file except in
compliance with the License. You may obtain a copy of the License at
http://www.mozilla.org/MPL/
Software distributed under the License is distributed on an "AS IS"
basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
the License for the specific language governing rights and
limitations under the License.
[...1070 lines suppressed...]
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;
}
--- NEW FILE: icalvalueimpl.h ---
/* -*- Mode: C -*- */
/*======================================================================
FILE: icalvalue.c
CREATOR: eric 02 May 1999
$Id: icalvalueimpl.h,v 1.1.2.1 2013-02-13 20:50:30 colin 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 icalvalue.c
Contributions from:
Graham Davison (g.m.davison at computer.org)
======================================================================*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#ifndef ICALVALUEIMPL_H
#define ICALVALUEIMPL_H
#include "icalenums.h"
struct icalvalue_impl {
icalvalue_kind kind; /*this is the kind that is visible from the outside*/
char id[5];
int size;
icalproperty* parent;
const char* x_value;
union data {
struct icalattachtype v_attach;
/* void *v_binary; */ /* use v_attach */
const char *v_string;
/*char *v_text;*/
/*char *v_caladdress;*/
/*char *v_uri;*/
float v_float;
int v_int;
/*int v_boolean;*/
/*int v_integer;*/
struct icaldurationtype v_duration;
/*int v_utcoffset;*/
struct icalperiodtype v_period;
/*struct icalperiodtype v_datetimeperiod;*/
struct icalgeotype v_geo;
/*time_t v_time;*/
struct icaltimetype v_time;
/*struct icaltimetype v_date;*/
/*struct icaltimetype v_datetime;*/
/*struct icaltimetype v_datetimedate;*/
/* struct icalrecurrencetype was once included
directly ( not referenced ) in this union, but it
contributes 2000 bytes to every value, so now it is
a reference*/
struct icalrecurrencetype *v_recur;
struct icaltriggertype v_trigger;
int v_enum;
/* v_enum takes care of several enumerated types including:
icalproperty_method v_method;
icalproperty_status v_status;
icalproperty_action v_action;
icalproperty_class v_class;
icalproperty_transp v_transp;
*/
} data;
};
#endif
--- NEW FILE: icalcomponent.c ---
/*======================================================================
FILE: icalcomponent.c
CREATOR: eric 28 April 1999
$Id: icalcomponent.c,v 1.1.2.1 2013-02-13 20:50:29 colin 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/
[...1461 lines suppressed...]
icalcomponent* icalcomponent_new_valarm()
{
return icalcomponent_new(ICAL_VALARM_COMPONENT);
}
icalcomponent* icalcomponent_new_vfreebusy()
{
return icalcomponent_new(ICAL_VFREEBUSY_COMPONENT);
}
icalcomponent* icalcomponent_new_vtimezone()
{
return icalcomponent_new(ICAL_VTIMEZONE_COMPONENT);
}
icalcomponent* icalcomponent_new_xstandard()
{
return icalcomponent_new(ICAL_XSTANDARD_COMPONENT);
}
icalcomponent* icalcomponent_new_xdaylight()
{
return icalcomponent_new(ICAL_XDAYLIGHT_COMPONENT);
}
--- NEW FILE: icalparser.h ---
/* -*- Mode: C -*- */
/*======================================================================
FILE: icalparser.h
CREATOR: eric 20 April 1999
$Id: icalparser.h,v 1.1.2.1 2013-02-13 20:50:30 colin 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 icalparser.h
======================================================================*/
#ifndef ICALPARSER_H
#define ICALPARSER_H
#include "icalenums.h"
#include "icaltypes.h"
#include"icalcomponent.h"
#include <stdio.h> /* For FILE* */
typedef void* icalparser;
/***********************************************************************
* Line-oriented parsing.
*
* Create a new parser via icalparse_new_parser, then add ines one at
* a time with icalparse_add_line(). icalparser_add_line() will return
* non-zero when it has finished with a component.
***********************************************************************/
typedef enum icalparser_state {
ICALPARSER_ERROR,
ICALPARSER_SUCCESS,
ICALPARSER_BEGIN_COMP,
ICALPARSER_END_COMP,
ICALPARSER_IN_PROGRESS
} icalparser_state;
icalparser* icalparser_new(void);
icalcomponent* icalparser_add_line(icalparser* parser, char* str );
icalcomponent* icalparser_clean(icalparser* parser);
icalparser_state icalparser_get_state(icalparser* parser);
void icalparser_free(icalparser* parser);
/***********************************************************************
* Message oriented parsing. icalparser_parse takes a string that
* holds the text ( in RFC 2445 format ) and returns a pointer to an
* icalcomponent. The caller owns the memory. line_gen_func is a
* pointer to a function that returns one content line per invocation
**********************************************************************/
icalcomponent* icalparser_parse(icalparser *parser,
char* (*line_gen_func)(char *s, size_t size, void *d));
/* Set the data that icalparser_parse will give to the line_gen_func
as the parameter 'd'*/
void icalparser_set_gen_data(icalparser* parser, void* data);
icalcomponent* icalparser_parse_string(const char* str);
/***********************************************************************
* Parser support functions
***********************************************************************/
/* Use the flex/bison parser to turn a string into a value type */
icalvalue* icalparser_parse_value(icalvalue_kind kind,
const char* str, icalcomponent** errors);
/* Given a line generator function, return a single iCal content line.*/
char* icalparser_get_line(icalparser* parser, char* (*line_gen_func)(char *s, size_t size, void *d));
char* string_line_generator(char *out, size_t buf_size, void *d);
#endif /* !ICALPARSE_H */
--- NEW FILE: icalduration.c ---
/* -*- Mode: C -*-
======================================================================
FILE: icaltime.c
CREATOR: eric 02 June 2000
$Id: icalduration.c,v 1.1.2.1 2013-02-13 20:50:29 colin Exp $
$Locker: $
(C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
This program is free software; you can redistribute it and/or modify
it under the terms of either:
The LGPL as published by the Free Software Foundation, version
2.1, available at: http://www.fsf.org/copyleft/lesser.html
Or:
The Mozilla Public License Version 1.0. You may obtain a copy of
the License at http://www.mozilla.org/MPL/
The Original Code is eric. The Initial Developer of the Original
Code is Eric Busboom
======================================================================*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "icalduration.h"
#include <assert.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#ifdef ICAL_NO_LIBICAL
#define icalerror_set_errno(x)
#define icalerror_check_arg_rv(x,y)
#define icalerror_check_arg_re(x,y,z)
#else
#include "icalerror.h"
#include "icalmemory.h"
#endif
/* From Seth Alves, <alves at hungry.com> */
struct icaldurationtype icaldurationtype_from_int(int t)
{
struct icaldurationtype dur;
int used = 0;
dur = icaldurationtype_null_duration();
if(t < 0){
dur.is_neg = 1;
t = -t;
}
dur.weeks = (t - used) / (60 * 60 * 24 * 7);
used += dur.weeks * (60 * 60 * 24 * 7);
dur.days = (t - used) / (60 * 60 * 24);
used += dur.days * (60 * 60 * 24);
dur.hours = (t - used) / (60 * 60);
used += dur.hours * (60 * 60);
dur.minutes = (t - used) / (60);
used += dur.minutes * (60);
dur.seconds = (t - used);
return dur;
}
#ifndef ICAL_NO_LIBICAL
#include "icalvalue.h"
struct icaldurationtype icaldurationtype_from_string(const char* str)
{
int i;
int begin_flag = 0;
int time_flag = 0;
int date_flag = 0;
int week_flag = 0;
int digits=-1;
int scan_size = -1;
int size = strlen(str);
char p;
struct icaldurationtype d;
memset(&d, 0, sizeof(struct icaldurationtype));
for(i=0;i != size;i++){
p = str[i];
switch(p)
{
case '-': {
if(i != 0 || begin_flag == 1) goto error;
d.is_neg = 1;
break;
}
case 'P': {
if (i != 0 && i !=1 ) goto error;
begin_flag = 1;
break;
}
case 'T': {
time_flag = 1;
break;
}
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
{
/* HACK. Skip any more digits if the l;ast one
read has not been assigned */
if(digits != -1){
break;
}
if (begin_flag == 0) goto error;
/* Get all of the digits, not one at a time */
scan_size = sscanf((char*)(str+i),"%d",&digits);
if(scan_size == 0) goto error;
break;
}
case 'H': {
if (time_flag == 0||week_flag == 1||d.hours !=0||digits ==-1)
goto error;
d.hours = digits; digits = -1;
break;
}
case 'M': {
if (time_flag == 0||week_flag==1||d.minutes != 0||digits ==-1)
goto error;
d.minutes = digits; digits = -1;
break;
}
case 'S': {
if (time_flag == 0||week_flag==1||d.seconds!=0||digits ==-1)
goto error;
d.seconds = digits; digits = -1;
break;
}
case 'W': {
if (time_flag==1||date_flag==1||d.weeks!=0||digits ==-1)
goto error;
week_flag = 1;
d.weeks = digits; digits = -1;
break;
}
case 'D': {
if (time_flag==1||week_flag==1||d.days!=0||digits ==-1)
goto error;
date_flag = 1;
d.days = digits; digits = -1;
break;
}
default: {
goto error;
}
}
}
return d;
error:
icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
memset(&d, 0, sizeof(struct icaldurationtype));
return d;
}
#define TMP_BUF_SIZE 1024
void append_duration_segment(char** buf, char** buf_ptr, size_t* buf_size,
char* sep, unsigned int value) {
char temp[TMP_BUF_SIZE];
sprintf(temp,"%d",value);
icalmemory_append_string(buf, buf_ptr, buf_size, temp);
icalmemory_append_string(buf, buf_ptr, buf_size, sep);
}
char* icaldurationtype_as_ical_string(struct icaldurationtype d)
{
char *buf, *output_line;
size_t buf_size = 256;
char* buf_ptr = 0;
int seconds;
buf = (char*)icalmemory_new_buffer(buf_size);
buf_ptr = buf;
seconds = icaldurationtype_as_int(d);
if(seconds !=0){
if(d.is_neg == 1){
icalmemory_append_char(&buf, &buf_ptr, &buf_size, '-');
}
icalmemory_append_char(&buf, &buf_ptr, &buf_size, 'P');
if (d.weeks != 0 ) {
append_duration_segment(&buf, &buf_ptr, &buf_size, "W", d.weeks);
}
if (d.days != 0 ) {
append_duration_segment(&buf, &buf_ptr, &buf_size, "D", d.days);
}
if (d.hours != 0 || d.minutes != 0 || d.seconds != 0) {
icalmemory_append_string(&buf, &buf_ptr, &buf_size, "T");
if (d.hours != 0 ) {
append_duration_segment(&buf, &buf_ptr, &buf_size, "H", d.hours);
}
if (d.minutes != 0 ) {
append_duration_segment(&buf, &buf_ptr, &buf_size, "M",
d.minutes);
}
if (d.seconds != 0 ) {
append_duration_segment(&buf, &buf_ptr, &buf_size, "S",
d.seconds);
}
}
} else {
icalmemory_append_string(&buf, &buf_ptr, &buf_size, "PTS0");
}
output_line = icalmemory_tmp_copy(buf);
icalmemory_free_buffer(buf);
return output_line;
}
#endif
/* From Russel Steinthal */
int icaldurationtype_as_int(struct icaldurationtype dur)
{
return (int)( (dur.seconds +
(60 * dur.minutes) +
(60 * 60 * dur.hours) +
(60 * 60 * 24 * dur.days) +
(60 * 60 * 24 * 7 * dur.weeks))
* (dur.is_neg==1? -1 : 1) ) ;
}
struct icaldurationtype icaldurationtype_null_duration()
{
struct icaldurationtype d;
memset(&d,0,sizeof(struct icaldurationtype));
return d;
}
int icaldurationtype_is_null_duration(struct icaldurationtype d)
{
if(icaldurationtype_as_int(d) == 0){
return 1;
} else {
return 0;
}
}
struct icaltimetype icaltime_add(struct icaltimetype t,
struct icaldurationtype d)
{
int dt = icaldurationtype_as_int(d);
t.second += dt;
t = icaltime_normalize(t);
return t;
}
struct icaldurationtype icaltime_subtract(struct icaltimetype t1,
struct icaltimetype t2)
{
time_t t1t = icaltime_as_timet(t1);
time_t t2t = icaltime_as_timet(t2);
return icaldurationtype_from_int(t1t-t2t);
}
--- NEW FILE: pvl.c ---
/*======================================================================
FILE: pvl.c
CREATOR: eric November, 1995
(C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
======================================================================*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "pvl.h"
#include <errno.h>
#include <assert.h>
#include <stdlib.h>
/*
struct pvl_list_t
The list structure. This is the hanlde for the entire list
This type is also private. Use pvl_list instead
*/
typedef struct pvl_list_t
{
int MAGIC; /* Magic Identifier */
struct pvl_elem_t *head; /* Head of list */
struct pvl_elem_t *tail; /* Tail of list */
int count; /* Number of items in the list */
struct pvl_elem_t *p; /* Pointer used for iterators */
} pvl_list_t;
/* This global is incremented for each call to pvl_new_element(); it gives each
* list a unique identifer */
int pvl_elem_count = 0;
int pvl_list_count = 0;
/*----------------------------------------------------------------------
Function: pvl_list pvl_newlist()
Purpose:
Creates a new list, clears the pointers and assigns a magic number
Returns:
Pointer to the new list
0 if there is no available memory.
*----------------------------------------------------------------------*/
pvl_list
pvl_newlist()
{
struct pvl_list_t *L;
if ( ( L = (struct pvl_list_t*)malloc(sizeof(struct pvl_list_t))) == 0)
{
errno = ENOMEM;
return 0;
}
L->MAGIC = pvl_list_count;
pvl_list_count++;
L->head = 0;
L->tail = 0;
L->count = 0;
L->p = 0;
return L;
}
void
pvl_free(pvl_list l)
{
struct pvl_list_t *L = (struct pvl_list_t *)l;
pvl_clear(l);
free(L);
}
/*----------------------------------------------------------------------
Function: pvl_new_element(void *d, struct pvl_elem_t *next,struct pvl_elem_t *prior)
Purpose:
Creates a new list element, assigns a magic number, and assigns
the next and previous pointers.
Passing in the next and previous points may seem odd, but it allos the user
to set them while keeping the internal data hidden. In nearly all cases,
the user is the pvl library itself.
Parameters:
d The data item to be stored in the list
next Pointer value to assign to the member "next"
prior Pointer value to assign to the member "prior"
Returns:
A pointer to the new element.
0 if there is no memory available.
*----------------------------------------------------------------------*/
pvl_elem
pvl_new_element(void *d, pvl_elem next,pvl_elem prior)
{
struct pvl_elem_t *E;
if ( ( E = (struct pvl_elem_t*)malloc(sizeof(struct pvl_elem_t))) == 0)
{
errno = ENOMEM;
return 0;
}
E->MAGIC = pvl_elem_count++;
E->d = d;
E->next = next;
E->prior = prior;
return (pvl_elem)E;
}
/*----------------------------------------------------------------------
Function: pvl_unshift(pvl_list l,void *d)
Purpose:
Add a new element to the from of the list
Parameters:
l The list to add the item to
d Pointer to the item to add
Returns:
*----------------------------------------------------------------------*/
void
pvl_unshift(pvl_list l,void *d)
{
struct pvl_list_t *L = (struct pvl_list_t *)l;
struct pvl_elem_t *E = pvl_new_element(d,L->head,0);
if (E->next != 0)
{
/* Link the head node to it */
E->next->prior = E;
}
/* move the head */
L->head = E;
/* maybe move the tail */
if (L->tail == 0)
{
L->tail = E;
}
L->count++;
}
/*----------------------------------------------------------------------
Function: pvl_shift(pvl_list l)
Purpose:
Remove an element from the front of the list
Parameters:
l The list to operate on
Returns:
*----------------------------------------------------------------------*/
void*
pvl_shift(pvl_list l)
{
struct pvl_list_t *L = (struct pvl_list_t *)l;
if (L->head == 0)
{
return 0;
}
return pvl_remove(l,(void*)L->head);
}
/*----------------------------------------------------------------------
Function: void pvl_push(pvl_list l,void *d)
Purpose:
Add a new item to the tail of the list
Paramters:
l The list to operate on
d Pointer to the item to add
Returns:
*----------------------------------------------------------------------*/
void
pvl_push(pvl_list l,void *d)
{
struct pvl_list_t *L = (struct pvl_list_t *)l;
struct pvl_elem_t *E = pvl_new_element(d,0,L->tail);
/* These are done in pvl_new_element
E->next = 0;
E->prior = L->tail;
*/
if (L->tail != 0)
{
L->tail->next = E;
}
if (L->head == 0)
{
L->head = E;
}
L->tail = E;
L->count++;
}
/*----------------------------------------------------------------------
Function: void* pvl_pop(pvl_list l)
Purpose:
Remove an element from the tail of the list
Paramters:
l The list to operate on
Returns:
*----------------------------------------------------------------------*/
void*
pvl_pop(pvl_list l)
{
struct pvl_list_t *L = (struct pvl_list_t *)l;
if ( L->tail == 0)
{
return 0;
}
return pvl_remove(l,(void*) L->tail);;
}
/*----------------------------------------------------------------------
Function: void pvl_insert_ordered(pvl_list l,pvl_comparef f,void *d)
Purpose:
Add a new item to a list that is ordered by a comparison function.
This routine assumes that the list is properly ordered.
l The list to operate on
f Pointer to a comparison function
d Pointer to data to pass to the comparison function
Returns:
void
*----------------------------------------------------------------------*/
void
pvl_insert_ordered(pvl_list l,pvl_comparef f,void *d)
{
struct pvl_list_t *L = (struct pvl_list_t *)l;
struct pvl_elem_t *P;
L->count++;
/* Empty list, add to head */
if(L->head == 0)
{
pvl_unshift(l,d);
return;
}
/* smaller than head, add to head */
if ( ((*f)(d,L->head->d)) <= 0)
{
pvl_unshift(l,d);
return;
}
/* larger than tail, add to tail */
if ( (*f)(d,L->tail->d) >= 0)
{
pvl_push(l,d);
return;
}
/* Search for the first element that is smaller, and add before it */
for (P=L->head; P != 0; P = P->next)
{
if ( (*f)(P->d,d) >= 0)
{
pvl_insert_before(l,P,d);
return;
}
}
/* badness, choke */
assert(0);
}
/*----------------------------------------------------------------------
Function: void pvl_insert_after(pvl_list l,pvl_elem p,void *d)
Purpose:
Add a new item after the referenced element.
Parameters:
l The list to operate on
p The list element to add the item after
d Pointer to the item to add.
Returns:
void
*----------------------------------------------------------------------*/
void
pvl_insert_after(pvl_list l,pvl_elem p,void *d)
{
struct pvl_list_t *L = (struct pvl_list_t *)l;
struct pvl_elem_t *P = (struct pvl_elem_t *)p;
struct pvl_elem_t *E = 0;
L->count++;
if (P == 0)
{
pvl_unshift(l,d);
return;
}
if ( P == L->tail)
{
E = pvl_new_element(d,0,P);
L->tail = E;
E->prior->next = E;
}
else
{
E = pvl_new_element(d,P->next,P);
E->next->prior = E;
E->prior->next = E;
}
}
/*----------------------------------------------------------------------
Function: void pvl_insert_before(pvl_list l,pvl_elem p,void *d)
Purpose:
Add an item after a referenced item
Parameters:
l The list to operate on
p The list element to add the item before
d Pointer to the data to be added.
Returns:
*----------------------------------------------------------------------*/
void
pvl_insert_before(pvl_list l,pvl_elem p,void *d)
{
struct pvl_list_t *L = (struct pvl_list_t *)l;
struct pvl_elem_t *P = (struct pvl_elem_t *)p;
struct pvl_elem_t *E = 0;
L->count++;
if (P == 0)
{
pvl_unshift(l,d);
return;
}
if ( P == L->head)
{
E = pvl_new_element(d,P,0);
E->next->prior = E;
L->head = E;
}
else
{
E = pvl_new_element(d,P,P->prior);
E->prior->next = E;
E->next->prior = E;
}
}
/*----------------------------------------------------------------------
Function: void pvl_remove(pvl_list l,pvl_elem e)
Purpose:
Remove the referenced item from the list
This routine will free the element, but not the data item that the
element contains.
Parameters:
l The list to operate on
e The element to remove.
Returns:
*----------------------------------------------------------------------*/
void*
pvl_remove(pvl_list l,pvl_elem e)
{
struct pvl_list_t *L = (struct pvl_list_t *)l;
struct pvl_elem_t *E = (struct pvl_elem_t *)e;
void* data;
if (E == L->head)
{
if (E->next != 0)
{
E->next->prior = 0;
L->head = E->next;
} else {
/* E Also points to tail -> only one element in list */
L->tail = 0;
L->head = 0;
}
}
else if (E == L->tail)
{
if (E->prior != 0)
{
E->prior->next = 0;
L->tail = E->prior;
} else {
/* E points to the head, so it was the last element */
/* This case should be taken care of in the previous clause */
L->head = 0;
L->tail = 0;
}
}
else
{
E->prior->next = E->next;
E->next->prior = E->prior;
}
L->count--;
data = E->d;
E->prior = 0;
E->next = 0;
E->d = 0;
free(E);
return data;
}
/*----------------------------------------------------------------------
Function: pvl_elem pvl_find(pvl_list l,pvl_findf f,void* v)
Purpose:
Return a pointer to data that satisfies a function
This routine will interate through the entire list and call the
find function for each item. It will break and return a pointer to the
data that causes the find function to return 1.
Parameters:
l The list to operate on
f Pointer to the find function
v Pointer to constant data to pass into the function
Returns:
Pointer to the element that the find function found.
*----------------------------------------------------------------------*/
pvl_elem
pvl_find(pvl_list l,pvl_findf f,void* v)
{
pvl_elem e;
for (e=pvl_head(l); e!= 0; e = pvl_next(e))
{
if ( (*f)(((struct pvl_elem_t *)e)->d,v) == 1)
{
/* Save this elem for a call to find_next */
((struct pvl_list_t *)l)->p = e;
return e;
}
}
return 0;
}
/*----------------------------------------------------------------------
Function: void* pvl_find_next(pvl_list l,pvl_findf f,void* v)
Purpose:
Like pvl_find(), but continues the search where the last find() or
find_next() left off
Parameters:
l The list to operate on
f Pointer to the find function
v Pointer to constant data to pass into the function
Returns:
Pointer to the element that the find function found.
*----------------------------------------------------------------------*/
pvl_elem
pvl_find_next(pvl_list l,pvl_findf f,void* v)
{
pvl_elem e;
for (e=pvl_head(l); e!= 0; e = pvl_next(e))
{
if ( (*f)(((struct pvl_elem_t *)e)->d,v) == 1)
{
/* Save this elem for a call to find_next */
((struct pvl_list_t *)l)->p = e;
return e;
}
}
return 0;
}
/*----------------------------------------------------------------------
Function: void pvl_clear(pvl_list l)
Purpose:
Remove the all the elements in the list. The does not free the data items
the elements hold.
Returns:
*----------------------------------------------------------------------*/
void
pvl_clear(pvl_list l)
{
pvl_elem e = pvl_head(l);
pvl_elem next;
if (e == 0) {
return;
}
while(e != 0)
{
next = pvl_next(e);
pvl_remove(l,e);
e = next;
}
}
/*----------------------------------------------------------------------
Function: int pvl_count(pvl_list l)
Purpose:
Returns the number of items in the list.
Returns:
*----------------------------------------------------------------------*/
int
pvl_count(pvl_list l)
{
struct pvl_list_t *L = (struct pvl_list_t *)l;
return L->count;
}
/*----------------------------------------------------------------------
Function: pvl_elem pvl_next(pvl_elem e)
Purpose:
Returns a pointer to the given element
Returns:
*----------------------------------------------------------------------*/
pvl_elem
pvl_next(pvl_elem e)
{
struct pvl_elem_t *E = (struct pvl_elem_t *)e;
if (E == 0){
return 0;
}
return (pvl_elem)E->next;
}
/*----------------------------------------------------------------------
Function: pvl_elem pvl_prior(pvl_elem e)
Purpose:
Returns a pointer to the element previous to the element given.
Returns:
*----------------------------------------------------------------------*/
pvl_elem
pvl_prior(pvl_elem e)
{
struct pvl_elem_t *E = (struct pvl_elem_t *)e;
return (pvl_elem)E->prior;
}
/*----------------------------------------------------------------------
Function: pvl_elem pvl_head(pvl_list l )
Purpose:
Returns a pointer to the first item in the list.
Returns:
*----------------------------------------------------------------------*/
pvl_elem
pvl_head(pvl_list l )
{
struct pvl_list_t *L = (struct pvl_list_t *)l;
if (L == NULL)
return NULL;
return (pvl_elem)L->head;
}
/*----------------------------------------------------------------------
Function: pvl_elem pvl_tail(pvl_list l)
Purpose:
Returns a pointer to the last item in the list.
Returns:
*----------------------------------------------------------------------*/
pvl_elem
pvl_tail(pvl_list l)
{
struct pvl_list_t *L = (struct pvl_list_t *)l;
return (pvl_elem)L->tail;
}
/*----------------------------------------------------------------------
Function:
Purpose:
Returns:
*----------------------------------------------------------------------*/
#ifndef PVL_USE_MACROS
void*
pvl_data(pvl_elem e)
{
struct pvl_elem_t *E = (struct pvl_elem_t *)e;
if ( e == 0){
return 0;
}
return E->d;
}
#endif
/*----------------------------------------------------------------------
Function: void pvl_apply(pvl_list l,pvl_applyf f, void *v)
Purpose:
Call a function for every item in the list.
Paramters:
l The list to operate on
f Pointer to the function to call
v Data to pass to the function on every iteration
Returns:
void
*----------------------------------------------------------------------*/
void
pvl_apply(pvl_list l,pvl_applyf f, void *v)
{
pvl_elem e;
for (e=pvl_head(l); e!= 0; e = pvl_next(e))
{
(*f)(((struct pvl_elem_t *)e)->d,v);
}
}
--- NEW FILE: icalversion.h.in ---
#ifndef ICAL_VERSION_H
#define ICAL_VERSION_H
#define ICAL_PACKAGE "@PACKAGE@"
#define ICAL_VERSION "@VERSION@"
#endif
--- NEW FILE: .cvsignore ---
.libs
.deps
Makefile
Makefile.in
*.lo
*.la
ical.h
icalderivedparameter.c
icalderivedparameter.h
icalderivedproperty.c
icalderivedproperty.h
icalderivedvalue.c
icalderivedvalue.h
icallexer.c
icalrestriction.c
icalversion.h
icalyacc.c
icalyacc.h
icalyacc.output
--- NEW FILE: icalcomponent.h ---
/* -*- Mode: C -*- */
/*======================================================================
FILE: icalcomponent.h
CREATOR: eric 20 March 1999
(C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
This program is free software; you can redistribute it and/or modify
it under the terms of either:
The LGPL as published by the Free Software Foundation, version
2.1, available at: http://www.fsf.org/copyleft/lesser.html
Or:
The Mozilla Public License Version 1.0. You may obtain a copy of
the License at http://www.mozilla.org/MPL/
The original code is icalcomponent.h
======================================================================*/
#ifndef ICALCOMPONENT_H
#define ICALCOMPONENT_H
#include "icalproperty.h"
#include "icalvalue.h"
#include "icalenums.h" /* defines icalcomponent_kind */
#include "icalattendee.h"
#include "pvl.h"
typedef void icalcomponent;
/* This is exposed so that callers will not have to allocate and
deallocate iterators. Pretend that you can't see it. */
typedef struct icalcompiter
{
icalcomponent_kind kind;
pvl_elem iter;
} icalcompiter;
icalcomponent* icalcomponent_new(icalcomponent_kind kind);
icalcomponent* icalcomponent_new_clone(icalcomponent* component);
icalcomponent* icalcomponent_new_from_string(char* str);
icalcomponent* icalcomponent_vanew(icalcomponent_kind kind, ...);
void icalcomponent_free(icalcomponent* component);
char* icalcomponent_as_ical_string(icalcomponent* component);
int icalcomponent_is_valid(icalcomponent* component);
icalcomponent_kind icalcomponent_isa(icalcomponent* component);
int icalcomponent_isa_component (void* component);
/*
* Working with properties
*/
void icalcomponent_add_property(icalcomponent* component,
icalproperty* property);
void icalcomponent_remove_property(icalcomponent* component,
icalproperty* property);
int icalcomponent_count_properties(icalcomponent* component,
icalproperty_kind kind);
/* Iterate through the properties */
icalproperty* icalcomponent_get_current_property(icalcomponent* component);
icalproperty* icalcomponent_get_first_property(icalcomponent* component,
icalproperty_kind kind);
icalproperty* icalcomponent_get_next_property(icalcomponent* component,
icalproperty_kind kind);
/*
* Working with components
*/
/* Return the first VEVENT, VTODO or VJOURNAL sub-component of cop, or
comp if it is one of those types */
icalcomponent* icalcomponent_get_inner(icalcomponent* comp);
void icalcomponent_add_component(icalcomponent* parent,
icalcomponent* child);
void icalcomponent_remove_component(icalcomponent* parent,
icalcomponent* child);
int icalcomponent_count_components(icalcomponent* component,
icalcomponent_kind kind);
/* Iteration Routines. There are two forms of iterators, internal and
external. The internal ones came first, and are almost completely
sufficient, but they fail badly when you want to construct a loop that
removes components from the container.*/
/* Iterate through components */
icalcomponent* icalcomponent_get_current_component (icalcomponent* component);
icalcomponent* icalcomponent_get_first_component(icalcomponent* component,
icalcomponent_kind kind);
icalcomponent* icalcomponent_get_next_component(icalcomponent* component,
icalcomponent_kind kind);
/* Using external iterators */
icalcompiter icalcomponent_begin_component(icalcomponent* component,
icalcomponent_kind kind);
icalcompiter icalcomponent_end_component(icalcomponent* component,
icalcomponent_kind kind);
icalcomponent* icalcompiter_next(icalcompiter* i);
icalcomponent* icalcompiter_prior(icalcompiter* i);
icalcomponent* icalcompiter_deref(icalcompiter* i);
/* Working with embedded error properties */
int icalcomponent_count_errors(icalcomponent* component);
/* Remove all X-LIC-ERROR properties*/
void icalcomponent_strip_errors(icalcomponent* component);
/* Convert some X-LIC-ERROR properties into RETURN-STATUS properties*/
void icalcomponent_convert_errors(icalcomponent* component);
/* Internal operations. They are private, and you should not be using them. */
icalcomponent* icalcomponent_get_parent(icalcomponent* component);
void icalcomponent_set_parent(icalcomponent* component,
icalcomponent* parent);
/* Kind conversion routiens */
icalcomponent_kind icalcomponent_string_to_kind(const char* string);
const char* icalcomponent_kind_to_string(icalcomponent_kind kind);
/************* Derived class methods. ****************************
If the code was in an OO language, the remaining routines would be
members of classes derived from icalcomponent. Don't call them on the
wrong component subtypes. */
/* For VCOMPONENT: Return a reference to the first VEVENT, VTODO or
VJOURNAL */
icalcomponent* icalcomponent_get_first_real_component(icalcomponent *c);
/* For VEVENT, VTODO, VJOURNAL and VTIMEZONE: report the start and end
times of an event in UTC */
struct icaltime_span icalcomponent_get_span(icalcomponent* comp);
/******************** Convienience routines **********************/
void icalcomponent_set_dtstart(icalcomponent* comp, struct icaltimetype v);
struct icaltimetype icalcomponent_get_dtstart(icalcomponent* comp);
/* For the icalcomponent routines only, dtend and duration are tied
together. If you call the set routine for one and the other exists,
the routine will calculate the change to the other. That is, if
there is a DTEND and you call set_duration, the routine will modify
DTEND to be the sum of DTSTART and the duration. If you call a get
routine for one and the other exists, the routine will calculate
the return value. If you call a set routine and neither exists, the
routine will create the apcompriate comperty */
struct icaltimetype icalcomponent_get_dtend(icalcomponent* comp);
void icalcomponent_set_dtend(icalcomponent* comp, struct icaltimetype v);
void icalcomponent_set_duration(icalcomponent* comp,
struct icaldurationtype v);
struct icaldurationtype icalcomponent_get_duration(icalcomponent* comp);
void icalcomponent_set_method(icalcomponent* comp, icalproperty_method method);
icalproperty_method icalcomponent_get_method(icalcomponent* comp);
struct icaltimetype icalcomponent_get_dtstamp(icalcomponent* comp);
void icalcomponent_set_dtstamp(icalcomponent* comp, struct icaltimetype v);
void icalcomponent_set_summary(icalcomponent* comp, const char* v);
const char* icalcomponent_get_summary(icalcomponent* comp);
void icalcomponent_set_comment(icalcomponent* comp, const char* v);
const char* icalcomponent_get_comment(icalcomponent* comp);
void icalcomponent_set_uid(icalcomponent* comp, const char* v);
const char* icalcomponent_get_uid(icalcomponent* comp);
void icalcomponent_set_recurrenceid(icalcomponent* comp,
struct icaltimetype v);
struct icaltimetype icalcomponent_get_recurrenceid(icalcomponent* comp);
void icalcomponent_set_organizer(icalcomponent* comp,
struct icalorganizertype org);
struct icalorganizertype icalcomponent_get_organizer(icalcomponent* comp);
void icalcomponent_add_attendee(icalcomponent *comp,
struct icalattendeetype attendee);
int icalcomponent_remove_attendee(icalcomponent *comp, char* cuid);
/* Get the Nth attendee. Out of range indices return an attendee
with cuid == 0 */
struct icalattendeetype icalcomponent_get_attendee(icalcomponent *comp,
int index);
/*************** Type Specific routines ***************/
icalcomponent* icalcomponent_new_vcalendar();
icalcomponent* icalcomponent_new_vevent();
icalcomponent* icalcomponent_new_vtodo();
icalcomponent* icalcomponent_new_vjournal();
icalcomponent* icalcomponent_new_valarm();
icalcomponent* icalcomponent_new_vfreebusy();
icalcomponent* icalcomponent_new_vtimezone();
icalcomponent* icalcomponent_new_xstandard();
icalcomponent* icalcomponent_new_xdaylight();
#endif /* !ICALCOMPONENT_H */
--- NEW FILE: icalattendee.c ---
/* -*- Mode: C -*-
======================================================================
FILE: icalattendee.c
CREATOR: eric 08 Mar 01
$Id: icalattendee.c,v 1.1.2.1 2013-02-13 20:50:29 colin Exp $
$Locker: $
(C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
This program is free software; you can redistribute it and/or modify
it under the terms of either:
The LGPL as published by the Free Software Foundation, version
2.1, available at: http://www.fsf.org/copyleft/lesser.html
Or:
The Mozilla Public License Version 1.0. You may obtain a copy of
the License at http://www.mozilla.org/MPL/
The original code is icaltypes.c
======================================================================*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "icalattendee.h"
--- NEW FILE: vsnprintf.c ---
#ifdef __osf__
/*
* Revision 12: http://theos.com/~deraadt/snprintf.c
*
* Copyright (c) 1997 Theo de Raadt
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include <sys/param.h>
#include <sys/types.h>
#include <sys/mman.h>
#include <signal.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#if __STDC__
#include <stdarg.h>
#include <stdlib.h>
#else
#include <varargs.h>
#endif
#include <setjmp.h>
#ifndef roundup
#define roundup(x, y) ((((x)+((y)-1))/(y))*(y))
#endif
static int pgsize;
static char *curobj;
static sigjmp_buf bail;
#define EXTRABYTES 2 /* XXX: why 2? you don't want to know */
static char *
msetup(str, n)
char *str;
size_t n;
{
char *e;
if (n == 0)
return NULL;
if (pgsize == 0)
pgsize = getpagesize();
curobj = (char *)malloc(n + EXTRABYTES + pgsize * 2);
if (curobj == NULL)
return NULL;
e = curobj + n + EXTRABYTES;
e = (char *)roundup((unsigned long)e, pgsize);
if (mprotect(e, pgsize, PROT_NONE) == -1) {
free(curobj);
curobj = NULL;
return NULL;
}
e = e - n - EXTRABYTES;
*e = '\0';
return (e);
}
static void
mcatch(int i)
{
siglongjmp(bail, 1);
}
static void
mcleanup(str, n, p)
char *str;
size_t n;
char *p;
{
strncpy(str, p, n-1);
str[n-1] = '\0';
if (mprotect((caddr_t)(p + n + EXTRABYTES), pgsize,
PROT_READ|PROT_WRITE|PROT_EXEC) == -1)
mprotect((caddr_t)(p + n + EXTRABYTES), pgsize,
PROT_READ|PROT_WRITE);
free(curobj);
}
int
#if __STDC__
vsnprintf(char *str, size_t n, char const *fmt, va_list ap)
#else
vsnprintf(str, n, fmt, ap)
char *str;
size_t n;
char *fmt;
char *ap;
#endif
{
struct sigaction osa, nsa;
char *p;
int ret = n + 1; /* if we bail, indicated we overflowed */
memset(&nsa, 0, sizeof nsa);
nsa.sa_handler = mcatch;
sigemptyset(&nsa.sa_mask);
p = msetup(str, n);
if (p == NULL) {
*str = '\0';
return 0;
}
if (sigsetjmp(bail, 1) == 0) {
if (sigaction(SIGSEGV, &nsa, &osa) == -1) {
mcleanup(str, n, p);
return (0);
}
ret = vsprintf(p, fmt, ap);
}
mcleanup(str, n, p);
(void) sigaction(SIGSEGV, &osa, NULL);
return (ret);
}
int
#if __STDC__
snprintf(char *str, size_t n, char const *fmt, ...)
#else
snprintf(str, n, fmt, va_alist)
char *str;
size_t n;
char *fmt;
va_dcl
#endif
{
va_list ap;
#if __STDC__
va_start(ap, fmt);
#else
va_start(ap);
#endif
return (vsnprintf(str, n, fmt, ap));
va_end(ap);
}
#else
/* ANSI C forbids an empty source file... */
static void vsnprintf_dummy_func() {
vsnprintf_dummy_func();
}
#endif
--- NEW FILE: icalmime.c ---
/* -*- Mode: C -*-*/
/*======================================================================
FILE: icalmime.c
CREATOR: eric 26 July 2000
$Id: icalmime.c,v 1.1.2.1 2013-02-13 20:50:30 colin Exp $
$Locker: $
(C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
This program is free software; you can redistribute it and/or modify
it under the terms of either:
The LGPL as published by the Free Software Foundation, version
2.1, available at: http://www.fsf.org/copyleft/lesser.html
Or:
The Mozilla Public License Version 1.0. You may obtain a copy of
the License at http://www.mozilla.org/MPL/
The Original Code is eric. The Initial Developer of the Original
Code is Eric Busboom
======================================================================*/
#include "icalmime.h"
#include "icalerror.h"
#include "icalmemory.h"
#include "sspm.h"
#include "stdlib.h"
#include <string.h> /* For strdup */
#include <stdio.h> /* for snprintf*/
#ifdef DMALLOC
#include "dmalloc.h"
#endif
/* These *_part routines are called by the MIME parser via the
local_action_map */
struct text_part
{
char* buf;
char* buf_pos;
size_t buf_size;
};
void* icalmime_text_new_part()
{
#define BUF_SIZE 2048
struct text_part* impl;
if ( ( impl = (struct text_part*)
malloc(sizeof(struct text_part))) == 0) {
return 0;
}
impl->buf = icalmemory_new_buffer(BUF_SIZE);
impl->buf_pos = impl->buf;
impl->buf_size = BUF_SIZE;
return impl;
}
void icalmime_text_add_line(void *part,
struct sspm_header *header,
char* line, size_t size)
{
struct text_part* impl = (struct text_part*) part;
icalmemory_append_string(&(impl->buf),&(impl->buf_pos),
&(impl->buf_size),line);
}
void* icalmime_textcalendar_end_part(void* part)
{
struct text_part* impl = (struct text_part*) part;
icalcomponent *c = icalparser_parse_string(impl->buf);
icalmemory_free_buffer(impl->buf);
free(impl);
return c;
}
void* icalmime_text_end_part(void* part)
{
struct text_part* impl = ( struct text_part*) part;
char *buf;
icalmemory_add_tmp_buffer(impl->buf);
buf = impl->buf;
free(impl);
return impl->buf;
}
void icalmime_text_free_part(void *part)
{
part = part;
}
/* Ignore Attachments for now */
void* icalmime_attachment_new_part()
{
return 0;
}
void icalmime_attachment_add_line(void *part, struct sspm_header *header,
char* line, size_t size)
{
part = part;
header = header;
line = line;
size = size;
}
void* icalmime_attachment_end_part(void* part)
{
return 0;
}
void icalmime_attachment_free_part(void *part)
{
}
struct sspm_action_map icalmime_local_action_map[] =
{
{SSPM_TEXT_MAJOR_TYPE,SSPM_CALENDAR_MINOR_TYPE,icalmime_text_new_part,icalmime_text_add_line,icalmime_textcalendar_end_part,icalmime_text_free_part},
{SSPM_TEXT_MAJOR_TYPE,SSPM_ANY_MINOR_TYPE,icalmime_text_new_part,icalmime_text_add_line,icalmime_text_end_part,icalmime_text_free_part},
{SSPM_TEXT_MAJOR_TYPE,SSPM_PLAIN_MINOR_TYPE,icalmime_text_new_part,icalmime_text_add_line,icalmime_text_end_part,icalmime_text_free_part},
{SSPM_APPLICATION_MAJOR_TYPE,SSPM_CALENDAR_MINOR_TYPE,icalmime_attachment_new_part,icalmime_attachment_add_line,icalmime_attachment_end_part,icalmime_attachment_free_part},
{SSPM_IMAGE_MAJOR_TYPE,SSPM_CALENDAR_MINOR_TYPE,icalmime_attachment_new_part,icalmime_attachment_add_line,icalmime_attachment_end_part,icalmime_attachment_free_part},
{SSPM_AUDIO_MAJOR_TYPE,SSPM_CALENDAR_MINOR_TYPE,icalmime_attachment_new_part,icalmime_attachment_add_line,icalmime_attachment_end_part,icalmime_attachment_free_part},
{SSPM_IMAGE_MAJOR_TYPE,SSPM_CALENDAR_MINOR_TYPE,icalmime_attachment_new_part,icalmime_attachment_add_line,icalmime_attachment_end_part,icalmime_attachment_free_part},
{SSPM_UNKNOWN_MAJOR_TYPE,SSPM_UNKNOWN_MINOR_TYPE,0,0,0,0}
};
#define NUM_PARTS 100 /* HACK. Hard Limit */
struct sspm_part* icalmime_make_part(icalcomponent* comp)
{
comp = comp;
return 0;
}
char* icalmime_as_mime_string(char* icalcomponent);
icalcomponent* icalmime_parse(char* (*get_string)(char *s, size_t size,
void *d),
void *data)
{
struct sspm_part *parts;
int i, last_level=0;
icalcomponent *root=0, *parent=0, *comp=0, *last = 0;
if ( (parts = (struct sspm_part *)
malloc(NUM_PARTS*sizeof(struct sspm_part)))==0) {
icalerror_set_errno(ICAL_NEWFAILED_ERROR);
return 0;
}
memset(parts,0,sizeof(parts));
sspm_parse_mime(parts,
NUM_PARTS, /* Max parts */
icalmime_local_action_map, /* Actions */
get_string,
data, /* data for get_string*/
0 /* First header */);
for(i = 0; i <NUM_PARTS && parts[i].header.major != SSPM_NO_MAJOR_TYPE ; i++){
#define TMPSZ 1024
char mimetype[TMPSZ];
char* major = sspm_major_type_string(parts[i].header.major);
char* minor = sspm_minor_type_string(parts[i].header.minor);
if(parts[i].header.minor == SSPM_UNKNOWN_MINOR_TYPE ){
assert(parts[i].header.minor_text !=0);
minor = parts[i].header.minor_text;
}
sprintf(mimetype,"%s/%s",major,minor);
comp = icalcomponent_new(ICAL_XLICMIMEPART_COMPONENT);
if(comp == 0){
/* HACK Handle Error */
assert(0);
}
if(parts[i].header.error!=SSPM_NO_ERROR){
char *str = NULL;
char* temp[256];
if(parts[i].header.error==SSPM_UNEXPECTED_BOUNDARY_ERROR){
str = "Got an unexpected boundary, possibly due to a MIME header for a MULTIPART part that is missing the Content-Type line";
}
if(parts[i].header.error==SSPM_WRONG_BOUNDARY_ERROR){
str = "Got the wrong boundary for the opening of a MULTIPART part.";
}
if(parts[i].header.error==SSPM_NO_BOUNDARY_ERROR){
str = "Got a multipart header that did not specify a boundary";
}
if(parts[i].header.error==SSPM_NO_HEADER_ERROR){
str = "Did not get a header for the part. Is there a blank\
line between the header and the previous boundary\?";
}
if(parts[i].header.error_text != 0){
snprintf((char*)temp,256,
"%s: %s",str,parts[i].header.error_text);
} else {
strcpy((char*)temp,str);
}
icalcomponent_add_property
(comp,
icalproperty_vanew_xlicerror(
(char*)temp,
icalparameter_new_xlicerrortype(
ICAL_XLICERRORTYPE_MIMEPARSEERROR),
0));
}
if(parts[i].header.major != SSPM_NO_MAJOR_TYPE &&
parts[i].header.major != SSPM_UNKNOWN_MAJOR_TYPE){
icalcomponent_add_property(comp,
icalproperty_new_xlicmimecontenttype((char*)
icalmemory_strdup(mimetype)));
}
if (parts[i].header.encoding != SSPM_NO_ENCODING){
icalcomponent_add_property(comp,
icalproperty_new_xlicmimeencoding(
sspm_encoding_string(parts[i].header.encoding)));
}
if (parts[i].header.filename != 0){
icalcomponent_add_property(comp,
icalproperty_new_xlicmimefilename(parts[i].header.filename));
}
if (parts[i].header.content_id != 0){
icalcomponent_add_property(comp,
icalproperty_new_xlicmimecid(parts[i].header.content_id));
}
if (parts[i].header.charset != 0){
icalcomponent_add_property(comp,
icalproperty_new_xlicmimecharset(parts[i].header.charset));
}
/* Add iCal components as children of the component */
if(parts[i].header.major == SSPM_TEXT_MAJOR_TYPE &&
parts[i].header.minor == SSPM_CALENDAR_MINOR_TYPE &&
parts[i].data != 0){
icalcomponent_add_component(comp,
(icalcomponent*)parts[i].data);
parts[i].data = 0;
} else if(parts[i].header.major == SSPM_TEXT_MAJOR_TYPE &&
parts[i].header.minor != SSPM_CALENDAR_MINOR_TYPE &&
parts[i].data != 0){
/* Add other text components as "DESCRIPTION" properties */
icalcomponent_add_property(comp,
icalproperty_new_description(
(char*)icalmemory_strdup((char*)parts[i].data)));
parts[i].data = 0;
}
if(root!= 0 && parts[i].level == 0){
/* We've already assigned the root, but there is another
part at the root level. This is probably a parse
error*/
icalcomponent_free(comp);
continue;
}
if(parts[i].level == last_level && last_level != 0){
icalerror_assert(parent!=0,"No parent for adding component");
icalcomponent_add_component(parent,comp);
} else if (parts[i].level == last_level && last_level == 0 &&
root == 0) {
root = comp;
parent = comp;
} else if (parts[i].level > last_level){
parent = last;
icalcomponent_add_component(parent,comp);
last_level = parts[i].level;
} else if (parts[i].level < last_level){
parent = icalcomponent_get_parent(parent);
icalcomponent_add_component(parent,comp);
last_level = parts[i].level;
} else {
assert(0);
}
last = comp;
last_level = parts[i].level;
assert(parts[i].data == 0);
}
sspm_free_parts(parts,NUM_PARTS);
free(parts);
return root;
}
int icalmime_test(char* (*get_string)(char *s, size_t size, void *d),
void *data)
{
char *out;
struct sspm_part *parts;
int i;
if ( (parts = (struct sspm_part *)
malloc(NUM_PARTS*sizeof(struct sspm_part)))==0) {
icalerror_set_errno(ICAL_NEWFAILED_ERROR);
return 0;
}
memset(parts,0,sizeof(parts));
sspm_parse_mime(parts,
NUM_PARTS, /* Max parts */
icalmime_local_action_map, /* Actions */
get_string,
data, /* data for get_string*/
0 /* First header */);
for(i = 0; i <NUM_PARTS && parts[i].header.major != SSPM_NO_MAJOR_TYPE ;
i++){
if(parts[i].header.minor == SSPM_CALENDAR_MINOR_TYPE){
parts[i].data = icalmemory_strdup(
icalcomponent_as_ical_string((icalcomponent*)parts[i].data));
}
}
sspm_write_mime(parts,NUM_PARTS,&out,"To: bob at bob.org");
printf("%s\n",out);
return 0;
}
--- NEW FILE: icalperiod.c ---
/* -*- Mode: C -*-
======================================================================
FILE: icalperiod.c
CREATOR: eric 02 June 2000
$Id: icalperiod.c,v 1.1.2.1 2013-02-13 20:50:30 colin Exp $
$Locker: $
(C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
This program is free software; you can redistribute it and/or modify
it under the terms of either:
The LGPL as published by the Free Software Foundation, version
2.1, available at: http://www.fsf.org/copyleft/lesser.html
Or:
The Mozilla Public License Version 1.0. You may obtain a copy of
the License at http://www.mozilla.org/MPL/
The Original Code is eric. The Initial Developer of the Original
Code is Eric Busboom
======================================================================*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "icalperiod.h"
#include <assert.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#ifdef ICAL_NO_LIBICAL
#define icalerror_set_errno(x)
#define icalerror_check_arg_rv(x,y)
#define icalerror_check_arg_re(x,y,z)
#else
#include "icalerror.h"
#include "icalmemory.h"
#endif
struct icalperiodtype icalperiodtype_from_string (const char* str)
{
struct icalperiodtype p, null_p;
char *s = icalmemory_strdup(str);
char *start, *end = s;
icalerrorstate es;
/* Errors are normally generated in the following code, so save
the error state for resoration later */
icalerrorenum e = icalerrno;
p.start = p.end = icaltime_null_time();
p.duration = icaldurationtype_from_int(0);
null_p = p;
if(s == 0) goto error;
start = s;
end = strchr(s, '/');
if(end == 0) goto error;
*end = 0;
end++;
p.start = icaltime_from_string(start);
if (icaltime_is_null_time(p.start)) goto error;
es = icalerror_get_error_state(ICAL_MALFORMEDDATA_ERROR);
icalerror_set_error_state(ICAL_MALFORMEDDATA_ERROR,ICAL_ERROR_NONFATAL);
p.end = icaltime_from_string(end);
icalerror_set_error_state(ICAL_MALFORMEDDATA_ERROR,es);
if (icaltime_is_null_time(p.end)){
p.duration = icaldurationtype_from_string(end);
if(icaldurationtype_as_int(p.duration) == 0) goto error;
}
icalerrno = e;
icalmemory_free_buffer(s);
return p;
error:
icalmemory_free_buffer(s);
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);
icalmemory_add_tmp_buffer(buf);
return buf;
}
struct icalperiodtype icalperiodtype_null_period() {
struct icalperiodtype p;
p.start = icaltime_null_time();
p.end = icaltime_null_time();
p.duration = icaldurationtype_null_duration();
return p;
}
int icalperiodtype_is_null_period(struct icalperiodtype p){
if(icaltime_is_null_time(p.start) &&
icaltime_is_null_time(p.end) &&
icaldurationtype_is_null_duration(p.duration)){
return 1;
} else {
return 0;
}
}
int icalperiodtype_is_valid_period(struct icalperiodtype p){
if(icaltime_is_valid_time(p.start) &&
(icaltime_is_valid_time(p.end) || icaltime_is_null_time(p.end)) )
{
return 1;
}
return 0;
}
--- NEW FILE: sspm.c ---
/* -*- Mode: C -*-
======================================================================
FILE: sspm.c Parse Mime
CREATOR: eric 25 June 2000
$Id: sspm.c,v 1.1.2.1 2013-02-13 20:50:30 colin Exp $
$Locker: $
The contents of this file are subject to the Mozilla Public License
Version 1.0 (the "License"); you may not use this file except in
compliance with the License. You may obtain a copy of the License at
http://www.mozilla.org/MPL/
Software distributed under the License is distributed on an "AS IS"
basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
the License for the specific language governing rights and
limitations under the License.
[...1574 lines suppressed...]
/* End of header */
/* Write body parts */
while(parts[part_num].header.major != SSPM_NO_MAJOR_TYPE){
if (parts[part_num].header.major == SSPM_MULTIPART_MAJOR_TYPE){
sspm_write_multipart_part(&buf,parts,&part_num);
} else {
sspm_write_part(&buf, &(parts[part_num]), &part_num);
}
part_num++;
}
*output_string = buf.buffer;
return 0;
}
--- NEW FILE: icalerror.c ---
/* -*- Mode: C -*-
======================================================================
FILE: icalerror.c
CREATOR: eric 16 May 1999
$Id: icalerror.c,v 1.1.2.1 2013-02-13 20:50:30 colin Exp $
$Locker: $
(C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
This program is free software; you can redistribute it and/or modify
it under the terms of either:
The LGPL as published by the Free Software Foundation, version
2.1, available at: http://www.fsf.org/copyleft/lesser.html
Or:
The Mozilla Public License Version 1.0. You may obtain a copy of
the License at http://www.mozilla.org/MPL/
The original code is icalerror.c
======================================================================*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <string.h>
#include "icalerror.h"
icalerrorenum icalerrno;
int foo;
void icalerror_stop_here(void)
{
foo++; /* Keep optimizers from removing routine */
}
void icalerror_crash_here(void)
{
int *p=0;
*p = 1;
assert( *p);
}
void icalerror_clear_errno() {
icalerrno = ICAL_NO_ERROR;
}
#ifdef ICAL_ERRORS_ARE_FATAL
int icalerror_errors_are_fatal = 1;
#else
int icalerror_errors_are_fatal = 0;
#endif
struct icalerror_state {
icalerrorenum error;
icalerrorstate state;
};
struct icalerror_state error_state_map[] =
{
{ ICAL_BADARG_ERROR,ICAL_ERROR_DEFAULT},
{ ICAL_NEWFAILED_ERROR,ICAL_ERROR_DEFAULT},
{ ICAL_MALFORMEDDATA_ERROR,ICAL_ERROR_DEFAULT},
{ ICAL_PARSE_ERROR,ICAL_ERROR_DEFAULT},
{ ICAL_INTERNAL_ERROR,ICAL_ERROR_DEFAULT},
{ ICAL_FILE_ERROR,ICAL_ERROR_DEFAULT},
{ ICAL_USAGE_ERROR,ICAL_ERROR_DEFAULT},
{ ICAL_UNIMPLEMENTED_ERROR,ICAL_ERROR_DEFAULT},
{ ICAL_UNKNOWN_ERROR,ICAL_ERROR_DEFAULT},
{ ICAL_NO_ERROR,ICAL_ERROR_DEFAULT}
};
struct icalerror_string_map {
const char* str;
icalerrorenum error;
char name[160];
};
static struct icalerror_string_map string_map[] =
{
{"BADARG",ICAL_BADARG_ERROR,"BADARG: Bad argument to function"},
{ "NEWFAILED",ICAL_NEWFAILED_ERROR,"NEWFAILED: Failed to create a new object via a *_new() routine"},
{"MALFORMEDDATA",ICAL_MALFORMEDDATA_ERROR,"MALFORMEDDATA: An input string was not correctly formed or a component has missing or extra properties"},
{ "PARSE",ICAL_PARSE_ERROR,"PARSE: Failed to parse a part of an iCal component"},
{"INTERNAL",ICAL_INTERNAL_ERROR,"INTERNAL: Random internal error. This indicates an error in the library code, not an error in use"},
{ "FILE",ICAL_FILE_ERROR,"FILE: An operation on a file failed. Check errno for more detail."},
{ "USAGE",ICAL_USAGE_ERROR,"USAGE: Failed to propertyl sequence calls to a set of interfaces"},
{ "UNIMPLEMENTED",ICAL_UNIMPLEMENTED_ERROR,"UNIMPLEMENTED: This feature has not been implemented"},
{ "NO",ICAL_NO_ERROR,"NO: No error"},
{"UNKNOWN",ICAL_UNKNOWN_ERROR,"UNKNOWN: Unknown error type -- icalerror_strerror() was probably given bad input"}
};
icalerrorenum icalerror_error_from_string(const char* str){
icalerrorenum e = ICAL_UNKNOWN_ERROR;
int i = 0;
for( i = 0; string_map[i].error != ICAL_NO_ERROR; i++){
if (strcmp(string_map[i].str,str) == 0){
e = string_map[i].error;
}
}
return e;
}
icalerrorstate icalerror_supress(const char* error){
icalerrorenum e = icalerror_error_from_string(error);
icalerrorstate es;
if (e == ICAL_NO_ERROR){
return ICAL_ERROR_UNKNOWN;
}
es = icalerror_get_error_state(e);
icalerror_set_error_state(e,ICAL_ERROR_NONFATAL);
return es;
}
char* icalerror_perror()
{
return icalerror_strerror(icalerrno);
}
void icalerror_restore(const char* error, icalerrorstate es){
icalerrorenum e = icalerror_error_from_string(error);
if (e != ICAL_NO_ERROR){
icalerror_set_error_state(e,es);
}
}
void icalerror_set_error_state( icalerrorenum error,
icalerrorstate state)
{
int i;
for(i = ICAL_BADARG_ERROR; error_state_map[i].error!= ICAL_NO_ERROR;i++){
if(error_state_map[i].error == error){
error_state_map[i].state = state;
}
}
}
icalerrorstate icalerror_get_error_state( icalerrorenum error)
{
int i;
for(i = ICAL_BADARG_ERROR; error_state_map[i].error!= ICAL_NO_ERROR;i++){
if(error_state_map[i].error == error){
return error_state_map[i].state;
}
}
return ICAL_ERROR_UNKNOWN;
}
char* icalerror_strerror(icalerrorenum e) {
int i;
for (i=0; string_map[i].error != ICAL_UNKNOWN_ERROR; i++) {
if (string_map[i].error == e) {
return string_map[i].name;
}
}
return string_map[i].name; /* Return string for ICAL_UNKNOWN_ERROR*/
}
--- NEW FILE: icalderivedproperty.h.in ---
/* -*- Mode: C -*-
======================================================================
FILE: icalderivedproperties.{c,h}
CREATOR: eric 09 May 1999
$Id: icalderivedproperty.h.in,v 1.1.2.1 2013-02-13 20:50:29 colin Exp $
(C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
======================================================================*/
#ifndef ICALDERIVEDPROPERTY_H
#define ICALDERIVEDPROPERTY_H
#include <time.h>
#include "icalparameter.h"
#include "icalderivedvalue.h"
#include "icalrecur.h"
typedef void icalproperty;
/* Everything below this line is machine generated. Do not edit. */
--- NEW FILE: icaltime.c ---
/* -*- Mode: C -*-
======================================================================
FILE: icaltime.c
CREATOR: eric 02 June 2000
$Id: icaltime.c,v 1.1.2.1 2013-02-13 20:50:30 colin Exp $
$Locker: $
(C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
This program is free software; you can redistribute it and/or modify
it under the terms of either:
The LGPL as published by the Free Software Foundation, version
2.1, available at: http://www.fsf.org/copyleft/lesser.html
Or:
The Mozilla Public License Version 1.0. You may obtain a copy of
the License at http://www.mozilla.org/MPL/
The Original Code is eric. The Initial Developer of the Original
Code is Eric Busboom
======================================================================*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#if USE_PTHREAD
#include <pthread.h>
#endif
#include <glib.h>
#include "icaltime.h"
#include <assert.h>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#ifdef ICAL_NO_LIBICAL
#define icalerror_set_errno(x)
#define icalerror_check_arg_rv(x,y)
#define icalerror_check_arg_re(x,y,z)
#else
#include "icalerror.h"
#include "icalmemory.h"
#endif
struct icaltimetype
icaltime_from_timet(time_t tm, int is_date)
{
struct icaltimetype tt = icaltime_null_time();
struct tm t, buft;
t = *(gmtime_r(&tm, &buft));
if(is_date == 0){
tt.second = t.tm_sec;
tt.minute = t.tm_min;
tt.hour = t.tm_hour;
} else {
tt.second = tt.minute =tt.hour = 0 ;
}
tt.day = t.tm_mday;
tt.month = t.tm_mon + 1;
tt.year = t.tm_year+ 1900;
tt.is_utc = 1;
tt.is_date = is_date;
return tt;
}
/* Structure used by set_tz to hold an old value of TZ, and the new
value, which is in memory we will have to free in unset_tz */
struct set_tz_save {char* orig_tzid; char* new_env_str;};
/* Temporarily change the TZ environmental variable. */
struct set_tz_save set_tz(const char* tzid)
{
char *orig_tzid = 0;
char *new_env_str;
struct set_tz_save savetz;
size_t tmp_sz;
savetz.orig_tzid = 0;
savetz.new_env_str = 0;
if(getenv("TZ") != 0){
orig_tzid = (char*)icalmemory_strdup(getenv("TZ"));
if(orig_tzid == 0){
icalerror_set_errno(ICAL_NEWFAILED_ERROR);
return savetz;
}
}
tmp_sz =strlen(tzid)+4;
new_env_str = (char*)malloc(tmp_sz);
if(new_env_str == 0){
icalerror_set_errno(ICAL_NEWFAILED_ERROR);
return savetz;
}
/* Copy the TZid into a string with the form that putenv expects. */
strcpy(new_env_str,"TZ=");
strcpy(new_env_str+3,tzid);
putenv(new_env_str);
/* Old value of TZ and the string we will have to free later */
savetz.orig_tzid = orig_tzid;
savetz.new_env_str = new_env_str;
tzset();
return savetz;
}
void unset_tz(struct set_tz_save savetz)
{
/* restore the original TZ environment */
char* orig_tzid = savetz.orig_tzid;
if(orig_tzid!=0){
size_t tmp_sz =strlen(orig_tzid)+4;
char* orig_env_str = (char*)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 {
g_unsetenv("TZ"); /* Delete from environment */
}
if(savetz.new_env_str != 0){
free(savetz.new_env_str);
}
tzset();
}
time_t icaltime_as_timet(struct icaltimetype tt)
{
struct tm stm;
time_t t;
memset(&stm,0,sizeof( struct tm));
if(icaltime_is_null_time(tt)) {
return 0;
}
stm.tm_sec = tt.second;
stm.tm_min = tt.minute;
stm.tm_hour = tt.hour;
stm.tm_mday = tt.day;
stm.tm_mon = tt.month-1;
stm.tm_year = tt.year-1900;
stm.tm_isdst = -1;
if(tt.is_utc == 1 || tt.is_date == 1){
struct set_tz_save old_tz = set_tz("UTC");
t = mktime(&stm);
unset_tz(old_tz);
} else {
t = mktime(&stm);
}
return t;
}
char* icaltime_as_ical_string(struct icaltimetype tt)
{
size_t size = 17;
char* buf = icalmemory_new_buffer(size);
if(tt.is_date){
snprintf(buf, size,"%04d%02d%02d",tt.year,tt.month,tt.day);
} else {
char* fmt;
if(tt.is_utc){
fmt = "%04d%02d%02dT%02d%02d%02dZ";
} else {
fmt = "%04d%02d%02dT%02d%02d%02d";
}
snprintf(buf, size,fmt,tt.year,tt.month,tt.day,
tt.hour,tt.minute,tt.second);
}
icalmemory_add_tmp_buffer(buf);
return buf;
}
/* convert tt, of timezone tzid, into a utc time */
struct icaltimetype icaltime_as_utc(struct icaltimetype tt,const char* tzid)
{
int tzid_offset;
if(tt.is_utc == 1 || tt.is_date == 1){
return tt;
}
tzid_offset = icaltime_utc_offset(tt,tzid);
tt.second -= tzid_offset;
tt.is_utc = 1;
return icaltime_normalize(tt);
}
/* convert tt, a time in UTC, into a time in timezone tzid */
struct icaltimetype icaltime_as_zone(struct icaltimetype tt,const char* tzid)
{
int tzid_offset;
tzid_offset = icaltime_utc_offset(tt,tzid);
tt.second += tzid_offset;
tt.is_utc = 0;
return icaltime_normalize(tt);
}
/* Return the offset of the named zone as seconds. tt is a time
indicating the date for which you want the offset */
int icaltime_utc_offset(struct icaltimetype ictt, const char* tzid)
{
time_t tt = icaltime_as_timet(ictt);
time_t offset_tt;
struct tm gtm, buft1, buft2;
struct set_tz_save old_tz;
if(tzid != 0){
old_tz = set_tz(tzid);
}
/* Mis-interpret a UTC broken out time as local time */
gtm = *(gmtime_r(&tt, &buft1));
gtm.tm_isdst = localtime_r(&tt, &buft2)->tm_isdst;
offset_tt = mktime(>m);
if(tzid != 0){
unset_tz(old_tz);
}
return tt-offset_tt;
}
/* Normalize by converting from localtime to utc and back to local
time. This uses localtime because localtime and mktime are inverses
of each other */
struct icaltimetype icaltime_normalize(struct icaltimetype tt)
{
struct tm stm, buft;
time_t tut;
memset(&stm,0,sizeof( struct tm));
stm.tm_sec = tt.second;
stm.tm_min = tt.minute;
stm.tm_hour = tt.hour;
stm.tm_mday = tt.day;
stm.tm_mon = tt.month-1;
stm.tm_year = tt.year-1900;
stm.tm_isdst = -1; /* prevents mktime from changing hour based on
daylight savings */
tut = mktime(&stm);
stm = *(localtime_r(&tut, &buft));
tt.second = stm.tm_sec;
tt.minute = stm.tm_min;
tt.hour = stm.tm_hour;
tt.day = stm.tm_mday;
tt.month = stm.tm_mon +1;
tt.year = stm.tm_year+1900;
return tt;
}
#ifndef ICAL_NO_LIBICAL
#include "icalvalue.h"
struct icaltimetype icaltime_from_string(const char* str)
{
struct icaltimetype tt = icaltime_null_time();
int size;
icalerror_check_arg_re(str!=0,"str",icaltime_null_time());
size = strlen(str);
if(size == 15) { /* floating time */
tt.is_utc = 0;
tt.is_date = 0;
} else if (size == 16) { /* UTC time, ends in 'Z'*/
tt.is_utc = 1;
tt.is_date = 0;
if(str[15] != 'Z'){
icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
return icaltime_null_time();
}
} else if (size == 8) { /* A DATE */
tt.is_utc = 1;
tt.is_date = 1;
} else if (size == 20) { /* A shitty date by Outlook */
char tsep, offset_way;
int off_h, off_m;
sscanf(str,"%04d%02d%02d%c%02d%02d%02d%c%02d%02d",&tt.year,&tt.month,&tt.day,
&tsep,&tt.hour,&tt.minute,&tt.second, &offset_way, &off_h, &off_m);
if(tsep != 'T'){
icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
return icaltime_null_time();
}
if (offset_way != '-' && offset_way != '+'){
icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
return icaltime_null_time();
}
/* substract offset to get utc */
if (offset_way == '-')
tt.second += 3600*off_h;
else
tt.second -= 3600*off_h;
tt.is_utc = 1;
tt.is_date = 0;
return icaltime_normalize(tt);
} else { /* error */
icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
return icaltime_null_time();
}
if(tt.is_date == 1){
sscanf(str,"%04d%02d%02d",&tt.year,&tt.month,&tt.day);
} else {
char tsep;
sscanf(str,"%04d%02d%02d%c%02d%02d%02d",&tt.year,&tt.month,&tt.day,
&tsep,&tt.hour,&tt.minute,&tt.second);
if(tsep != 'T'){
icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
return icaltime_null_time();
}
}
return tt;
}
#endif
char ctime_str[20];
char* icaltime_as_ctime(struct icaltimetype t)
{
time_t tt;
char buft[512];
tt = icaltime_as_timet(t);
sprintf(ctime_str,"%s",ctime_r(&tt, buft));
ctime_str[strlen(ctime_str)-1] = 0;
return ctime_str;
}
short days_in_month[] = {0,31,28,31,30,31,30,31,31,30,31,30,31};
short icaltime_days_in_month(short month,short year)
{
int is_leap =0;
int days = days_in_month[month];
assert(month > 0);
assert(month <= 12);
if( (year % 4 == 0 && year % 100 != 0) ||
year % 400 == 0){
is_leap =1;
}
if( month == 2){
days += is_leap;
}
return days;
}
/* 1-> Sunday, 7->Saturday */
short icaltime_day_of_week(struct icaltimetype t){
time_t tt = icaltime_as_timet(t);
struct tm *tm, buft;
if(t.is_utc == 1){
tm = gmtime_r(&tt, &buft);
} else {
tm = localtime_r(&tt, &buft);
}
return tm->tm_wday+1;
}
/* Day of the year that the first day of the week (Sunday) is on */
short icaltime_start_doy_of_week(struct icaltimetype t){
time_t tt = icaltime_as_timet(t);
time_t start_tt;
struct tm *stm, buft1, buft2;
int syear;
stm = gmtime_r(&tt, &buft1);
syear = stm->tm_year;
start_tt = tt - stm->tm_wday*(60*60*24);
stm = gmtime_r(&start_tt, &buft2);
if(syear == stm->tm_year){
return stm->tm_yday+1;
} else {
/* return negative to indicate that start of week is in
previous year. */
int is_leap = 0;
int year = stm->tm_year;
if( (year % 4 == 0 && year % 100 != 0) ||
year % 400 == 0){
is_leap =1;
}
return (stm->tm_yday+1)-(365+is_leap);
}
}
short icaltime_week_number(struct icaltimetype ictt)
{
char str[5];
time_t t = icaltime_as_timet(ictt);
int week_no;
struct tm buft;
strftime(str,5,"%V", gmtime_r(&t, &buft));
week_no = atoi(str);
return week_no;
}
short icaltime_day_of_year(struct icaltimetype t){
time_t tt = icaltime_as_timet(t);
struct tm *stm, buft;
if(t.is_utc==1){
stm = gmtime_r(&tt, &buft);
} else {
stm = localtime_r(&tt, &buft);
}
return stm->tm_yday+1;
}
/* Jan 1 is day #1, not 0 */
struct icaltimetype icaltime_from_day_of_year(short doy, short year)
{
struct tm stm;
time_t tt;
struct set_tz_save old_tz = set_tz("UTC");
/* Get the time of january 1 of this year*/
memset(&stm,0,sizeof(struct tm));
stm.tm_year = year-1900;
stm.tm_mday = 1;
tt = mktime(&stm);
unset_tz(old_tz);
/* Now add in the days */
doy--;
tt += doy *60*60*24;
return icaltime_from_timet(tt, 1);
}
struct icaltimetype icaltime_null_time()
{
struct icaltimetype t;
memset(&t,0,sizeof(struct icaltimetype));
return t;
}
int icaltime_is_valid_time(struct icaltimetype t){
if(t.is_utc > 1 || t.is_utc < 0 ||
t.year < 0 || t.year > 3000 ||
t.is_date > 1 || t.is_date < 0){
return 0;
} else {
return 1;
}
}
int icaltime_is_null_time(struct icaltimetype t)
{
if (t.second +t.minute+t.hour+t.day+t.month+t.year == 0){
return 1;
}
return 0;
}
int icaltime_compare(struct icaltimetype a,struct icaltimetype b)
{
time_t t1 = icaltime_as_timet(a);
time_t t2 = icaltime_as_timet(b);
if (t1 > t2) {
return 1;
} else if (t1 < t2) {
return -1;
} else {
return 0;
}
}
int
icaltime_compare_date_only (struct icaltimetype a, struct icaltimetype b)
{
time_t t1;
time_t t2;
if (a.year == b.year && a.month == b.month && a.day == b.day)
return 0;
t1 = icaltime_as_timet (a);
t2 = icaltime_as_timet (b);
if (t1 > t2)
return 1;
else if (t1 < t2)
return -1;
else {
/* not reached */
assert (0);
return 0;
}
}
/* These are defined in icalduration.c:
struct icaltimetype icaltime_add(struct icaltimetype t,
struct icaldurationtype d)
struct icaldurationtype icaltime_subtract(struct icaltimetype t1,
struct icaltimetype t2)
*/
--- NEW FILE: icalderivedvalue.h.in ---
/* -*- Mode: C -*- */
/*======================================================================
FILE: icalvalue.h
CREATOR: eric 20 March 1999
$Id: icalderivedvalue.h.in,v 1.1.2.1 2013-02-13 20:50:29 colin Exp $
$Locker: $
(C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
This program is free software; you can redistribute it and/or modify
it under the terms of either:
The LGPL as published by the Free Software Foundation, version
2.1, available at: http://www.fsf.org/copyleft/lesser.html
Or:
The Mozilla Public License Version 1.0. You may obtain a copy of
the License at http://www.mozilla.org/MPL/
The original code is icalvalue.h
======================================================================*/
#ifndef ICALDERIVEDVALUE_H
#define ICALDERIVEDVALUE_H
#include "icaltypes.h"
#include "icalrecur.h"
#include "icaltime.h"
#include "icalduration.h"
#include "icalperiod.h"
typedef void icalvalue;
void icalvalue_set_x(icalvalue* value, const char* v);
icalvalue* icalvalue_new_x(const char* v);
const char* icalvalue_get_x(icalvalue* value);
icalvalue* icalvalue_new_recur (struct icalrecurrencetype v);
void icalvalue_set_recur(icalvalue* value, struct icalrecurrencetype v);
struct icalrecurrencetype icalvalue_get_recur(icalvalue* value);
icalvalue* icalvalue_new_trigger (struct icaltriggertype v);
void icalvalue_set_trigger(icalvalue* value, struct icaltriggertype v);
struct icaltriggertype icalvalue_get_trigger(icalvalue* value);
icalvalue* icalvalue_new_datetimeperiod (struct icaldatetimeperiodtype v);
void icalvalue_set_datetimeperiod(icalvalue* value, struct icaldatetimeperiodtype v);
struct icaldatetimeperiodtype icalvalue_get_datetimeperiod(icalvalue* value);
/* Everything below this line is machine generated. Do not edit. */
--- NEW FILE: icalderivedparameter.h.in ---
/* -*- Mode: C -*- */
/*======================================================================
FILE: icalparam.h
CREATOR: eric 20 March 1999
$Id: icalderivedparameter.h.in,v 1.1.2.1 2013-02-13 20:50:29 colin Exp $
$Locker: $
(C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
This program is free software; you can redistribute it and/or modify
it under the terms of either:
The LGPL as published by the Free Software Foundation, version
2.1, available at: http://www.fsf.org/copyleft/lesser.html
Or:
The Mozilla Public License Version 1.0. You may obtain a copy of
the License at http://www.mozilla.org/MPL/
The original code is icalparam.h
======================================================================*/
#ifndef ICALDERIVEDPARAMETER_H
#define ICALDERIVEDPARAMETER_H
typedef void icalparameter;
const char* icalparameter_enum_to_string(int e);
int icalparameter_string_to_enum(const char* str);
--- NEW FILE: icalperiod.h ---
/* -*- Mode: C -*- */
/*======================================================================
FILE: icalperiod.h
CREATOR: eric 26 Jan 2001
$Id: icalperiod.h,v 1.1.2.1 2013-02-13 20:50:30 colin Exp $
$Locker: $
(C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
This program is free software; you can redistribute it and/or modify
it under the terms of either:
The LGPL as published by the Free Software Foundation, version
2.1, available at: http://www.fsf.org/copyleft/lesser.html
Or:
The Mozilla Public License Version 1.0. You may obtain a copy of
the License at http://www.mozilla.org/MPL/
The Original Code is eric. The Initial Developer of the Original
Code is Eric Busboom
======================================================================*/
#ifndef ICALPERIOD_H
#define ICALPERIOD_H
#include "icaltime.h"
#include "icalduration.h"
struct icalperiodtype
{
struct icaltimetype start;
struct icaltimetype end;
struct icaldurationtype duration;
};
struct icalperiodtype icalperiodtype_from_string (const char* str);
const char* icalperiodtype_as_ical_string(struct icalperiodtype p);
struct icalperiodtype icalperiodtype_null_period();
int icalperiodtype_is_null_period(struct icalperiodtype p);
int icalperiodtype_is_valid_period(struct icalperiodtype p);
#endif /* !ICALTIME_H */
--- NEW FILE: icalmime.h ---
/* -*- Mode: C -*- */
/*======================================================================
FILE: icalmime.h
CREATOR: eric 26 July 2000
$Id: icalmime.h,v 1.1.2.1 2013-02-13 20:50:30 colin Exp $
$Locker: $
(C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
This program is free software; you can redistribute it and/or modify
it under the terms of either:
The LGPL as published by the Free Software Foundation, version
2.1, available at: http://www.fsf.org/copyleft/lesser.html
Or:
The Mozilla Public License Version 1.0. You may obtain a copy of
the License at http://www.mozilla.org/MPL/
======================================================================*/
#ifndef ICALMIME_H
#define ICALMIME_H
#include "icalcomponent.h"
#include "icalparser.h"
icalcomponent* icalmime_parse( char* (*line_gen_func)(char *s, size_t size,
void *d),
void *data);
/* The inverse of icalmime_parse, not implemented yet. Use sspm.h directly. */
char* icalmime_as_mime_string(char* component);
#endif /* !ICALMIME_H */
--- NEW FILE: icaltime.h ---
/* -*- Mode: C -*- */
/*======================================================================
FILE: icaltime.h
CREATOR: eric 02 June 2000
$Id: icaltime.h,v 1.1.2.1 2013-02-13 20:50:30 colin Exp $
$Locker: $
(C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
This program is free software; you can redistribute it and/or modify
it under the terms of either:
The LGPL as published by the Free Software Foundation, version
2.1, available at: http://www.fsf.org/copyleft/lesser.html
Or:
The Mozilla Public License Version 1.0. You may obtain a copy of
the License at http://www.mozilla.org/MPL/
The Original Code is eric. The Initial Developer of the Original
Code is Eric Busboom
======================================================================*/
#ifndef ICALTIME_H
#define ICALTIME_H
#include <time.h>
/* icaltime_span is returned by icalcomponent_get_span() */
struct icaltime_span {
time_t start; /* in UTC */
time_t end; /* in UTC */
int is_busy; /* 1->busy time, 0-> free time */
};
struct icaltimetype
{
int year;
int month;
int day;
int hour;
int minute;
int second;
int is_utc; /* 1-> time is in UTC timezone */
int is_date; /* 1 -> interpret this as date. */
const char* zone; /*Ptr to Olsen placename. Libical does not own mem*/
};
/* Convert seconds past UNIX epoch to a timetype*/
struct icaltimetype icaltime_from_timet(time_t v, int is_date);
/* Return the time as seconds past the UNIX epoch */
time_t icaltime_as_timet(struct icaltimetype);
/* Return a string represention of the time, in RFC2445 format. The
string is owned by libical */
char* icaltime_as_ical_string(struct icaltimetype tt);
/* Like icaltime_from_timet(), except that the input may be in seconds
past the epoch in floating time. This routine is deprecated */
struct icaltimetype icaltime_from_int(int v, int is_date, int is_utc);
/* Like icaltime_as_timet, but in a floating epoch. This routine is deprecated */
int icaltime_as_int(struct icaltimetype);
/* create a time from an ISO format string */
struct icaltimetype icaltime_from_string(const char* str);
/* Routines for handling timezones */
/* Return the offset of the named zone as seconds. tt is a time
indicating the date for which you want the offset */
int icaltime_utc_offset(struct icaltimetype tt, const char* tzid);
/* convert tt, of timezone tzid, into a utc time. Does nothing if the
time is already UTC. */
struct icaltimetype icaltime_as_utc(struct icaltimetype tt,
const char* tzid);
/* convert tt, a time in UTC, into a time in timezone tzid */
struct icaltimetype icaltime_as_zone(struct icaltimetype tt,
const char* tzid);
/* Return a null time, which indicates no time has been set. This time represent the beginning of the epoch */
struct icaltimetype icaltime_null_time(void);
/* Return true of the time is null. */
int icaltime_is_null_time(struct icaltimetype t);
/* Returns false if the time is clearly invalid, but is not null. This
is usually the result of creating a new time type buy not clearing
it, or setting one of the flags to an illegal value. */
int icaltime_is_valid_time(struct icaltimetype t);
/* Reset all of the time components to be in their normal ranges. For
instance, given a time with minutes=70, the minutes will be reduces
to 10, and the hour incremented. This allows the caller to do
arithmetic on times without worrying about overflow or
underflow. */
struct icaltimetype icaltime_normalize(struct icaltimetype t);
/* Return the day of the year of the given time */
short icaltime_day_of_year(struct icaltimetype t);
/* Create a new time, given a day of year and a year. */
struct icaltimetype icaltime_from_day_of_year(short doy, short year);
/* Return the day of the week of the given time. Sunday is 1 */
short icaltime_day_of_week(struct icaltimetype t);
/* Return the day of the year for the Sunday of the week that the
given time is within. */
short icaltime_start_doy_of_week(struct icaltimetype t);
/* Return a string with the time represented in the same format as ctime(). THe string is owned by libical */
char* icaltime_as_ctime(struct icaltimetype);
/* Return the week number for the week the given time is within */
short icaltime_week_number(struct icaltimetype t);
/* Create a new time from a weeknumber and a year. */
struct icaltimetype icaltime_from_week_number(short week_number, short year);
/* Return -1, 0, or 1 to indicate that a<b, a==b or a>b */
int icaltime_compare(struct icaltimetype a,struct icaltimetype b);
/* like icaltime_compare, but only use the date parts. */
int icaltime_compare_date_only(struct icaltimetype a, struct icaltimetype b);
/* Return the number of days in the given month */
short icaltime_days_in_month(short month,short year);
#endif /* !ICALTIME_H */
--- NEW FILE: icalderivedvalue.c.in ---
/* -*- Mode: C -*- */
/*======================================================================
FILE: icalvalue.c
CREATOR: eric 02 May 1999
$Id: icalderivedvalue.c.in,v 1.1.2.1 2013-02-13 20:50:29 colin 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 icalvalue.c
Contributions from:
Graham Davison (g.m.davison at computer.org)
======================================================================*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "icalerror.h"
#include "icalmemory.h"
#include "icalparser.h"
#include "icalenums.h"
#include "icalvalueimpl.h"
#include <stdlib.h> /* for malloc */
#include <stdio.h> /* for sprintf */
#include <string.h> /* For memset, others */
#include <stddef.h> /* For offsetof() macro */
#include <errno.h>
#include <time.h> /* for mktime */
#include <stdlib.h> /* for atoi and atof */
#include <limits.h> /* for SHRT_MAX */
#define TMP_BUF_SIZE 1024
struct icalvalue_impl* icalvalue_new_impl(icalvalue_kind kind);
/* This map associates each of the value types with its string
representation */
struct icalvalue_kind_map {
icalvalue_kind kind;
char name[20];
};
static struct icalvalue_kind_map value_map[];
const char* icalvalue_kind_to_string(icalvalue_kind kind)
{
int i;
for (i=0; value_map[i].kind != ICAL_NO_VALUE; i++) {
if (value_map[i].kind == kind) {
return value_map[i].name;
}
}
return 0;
}
icalvalue_kind icalvalue_string_to_kind(const char* str)
{
int i;
for (i=0; value_map[i].kind != ICAL_NO_VALUE; i++) {
if (strcmp(value_map[i].name,str) == 0) {
return value_map[i].kind;
}
}
return value_map[i].kind;
}
icalvalue* icalvalue_new_x (const char* v){
struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_X_VALUE);
icalerror_check_arg_rz( (v!=0),"v");
icalvalue_set_x((icalvalue*)impl,v);
return (icalvalue*)impl;
}
void icalvalue_set_x(icalvalue* value, const char* v) {
struct icalvalue_impl* impl;
icalerror_check_arg_rv( (value!=0),"value");
icalerror_check_arg_rv( (v!=0),"v");
impl = (struct icalvalue_impl*)value;
if(impl->x_value!=0) {free((void*)impl->x_value);}
impl->x_value = icalmemory_strdup(v);
if (impl->x_value == 0){
errno = ENOMEM;
}
}
const char* icalvalue_get_x(icalvalue* value) {
icalerror_check_arg_rz( (value!=0),"value");
icalerror_check_value_type(value, ICAL_X_VALUE);
return ((struct icalvalue_impl*)value)->x_value;
}
/* Recur is a special case, so it is not auto generated. */
icalvalue*
icalvalue_new_recur (struct icalrecurrencetype v)
{
struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_RECUR_VALUE);
icalvalue_set_recur((icalvalue*)impl,v);
return (icalvalue*)impl;
}
void
icalvalue_set_recur(icalvalue* value, struct icalrecurrencetype v)
{
struct icalvalue_impl* impl;
icalerror_check_arg_rv( (value!=0),"value");
icalerror_check_value_type(value, ICAL_RECUR_VALUE);
impl = (struct icalvalue_impl*)value;
if (impl->data.v_recur != 0){
free(impl->data.v_recur);
impl->data.v_recur = 0;
}
impl->data.v_recur = malloc(sizeof(struct icalrecurrencetype));
if (impl->data.v_recur == 0){
icalerror_set_errno(ICAL_NEWFAILED_ERROR);
return;
} else {
memcpy(impl->data.v_recur, &v, sizeof(struct icalrecurrencetype));
}
}
struct icalrecurrencetype
icalvalue_get_recur(icalvalue* value)
{
icalerror_check_arg( (value!=0),"value");
icalerror_check_value_type(value, ICAL_RECUR_VALUE);
return *(((struct icalvalue_impl*)value)->data.v_recur);
}
icalvalue*
icalvalue_new_trigger (struct icaltriggertype v)
{
struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_TRIGGER_VALUE);
icalvalue_set_trigger((icalvalue*)impl,v);
return (icalvalue*)impl;
}
void
icalvalue_set_trigger(icalvalue* value, struct icaltriggertype v)
{
struct icalvalue_impl* impl;
icalerror_check_arg_rv( (value!=0),"value");
impl = (struct icalvalue_impl*)value;
if(!icaltime_is_null_time(v.time)){
icalvalue_set_datetime((icalvalue*)impl,v.time);
impl->kind = ICAL_DATETIME_VALUE;
} else {
icalvalue_set_duration((icalvalue*)impl,v.duration);
impl->kind = ICAL_DURATION_VALUE;
}
}
struct icaltriggertype
icalvalue_get_trigger(icalvalue* value)
{
struct icalvalue_impl *impl = (struct icalvalue_impl*)value;
struct icaltriggertype tr;
icalerror_check_arg( (value!=0),"value");
if(impl->kind == ICAL_DATETIME_VALUE){
tr.duration = icaldurationtype_from_int(0);
tr.time = impl->data.v_time;
} else if(impl->kind == ICAL_DURATION_VALUE){
tr.time = icaltime_null_time();
tr.duration = impl->data.v_duration;
} else {
tr.duration = icaldurationtype_from_int(0);
tr.time = icaltime_null_time();
icalerror_set_errno(ICAL_BADARG_ERROR);
}
return tr;
}
/* DATE-TIME-PERIOD is a special case, and is not auto generated */
icalvalue*
icalvalue_new_datetimeperiod (struct icaldatetimeperiodtype v)
{
struct icalvalue_impl* impl = icalvalue_new_impl(ICAL_DATETIMEPERIOD_VALUE);
icalvalue_set_datetimeperiod((icalvalue*)impl,v);
return (icalvalue*)impl;
}
void
icalvalue_set_datetimeperiod(icalvalue* value, struct icaldatetimeperiodtype v)
{
struct icalvalue_impl* impl = (struct icalvalue_impl*)value;
icalerror_check_arg_rv( (value!=0),"value");
icalerror_check_value_type(value, ICAL_DATETIMEPERIOD_VALUE);
if(!icaltime_is_null_time(v.time)){
if(!icaltime_is_valid_time(v.time)){
icalerror_set_errno(ICAL_BADARG_ERROR);
return;
}
impl->kind = ICAL_DATETIME_VALUE;
icalvalue_set_datetime(impl,v.time);
} else if (!icalperiodtype_is_null_period(v.period)) {
if(!icalperiodtype_is_valid_period(v.period)){
icalerror_set_errno(ICAL_BADARG_ERROR);
return;
}
impl->kind = ICAL_PERIOD_VALUE;
icalvalue_set_period(impl,v.period);
} else {
icalerror_set_errno(ICAL_BADARG_ERROR);
}
}
struct icaldatetimeperiodtype
icalvalue_get_datetimeperiod(icalvalue* value)
{
struct icaldatetimeperiodtype dtp;
struct icalvalue_impl* impl = (struct icalvalue_impl*)value;
icalerror_check_arg( (value!=0),"value");
icalerror_check_value_type(value, ICAL_DATETIMEPERIOD_VALUE);
if(impl->kind == ICAL_DATETIME_VALUE){
dtp.period = icalperiodtype_null_period();
dtp.time = impl->data.v_time;
} else if(impl->kind == ICAL_PERIOD_VALUE) {
dtp.period = impl->data.v_period;
dtp.time = icaltime_null_time();
} else {
dtp.period = icalperiodtype_null_period();
dtp.time = icaltime_null_time();
icalerror_set_errno(ICAL_BADARG_ERROR);
}
return dtp;
}
/* The remaining interfaces are 'new', 'set' and 'get' for each of the value
types */
/* Everything below this line is machine generated. Do not edit. */
--- NEW FILE: icalerror.h ---
/* -*- Mode: C -*- */
/*======================================================================
FILE: icalerror.h
CREATOR: eric 09 May 1999
$Id: icalerror.h,v 1.1.2.1 2013-02-13 20:50:30 colin 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 icalerror.h
======================================================================*/
#ifndef ICALERROR_H
#define ICALERROR_H
#include <assert.h>
#include <stdio.h> /* For icalerror_warn() */
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
/* This routine is called before any error is triggered. It is called
by icalerror_set_errno, so it does not appear in all of the macros
below */
void icalerror_stop_here(void);
void icalerror_crash_here(void);
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
#define icalerror_check_value_type(value,type);
#define icalerror_check_property_type(value,type);
#define icalerror_check_parameter_type(value,type);
#define icalerror_check_component_type(value,type);
/* Assert with a message */
#ifdef ICAL_ERRORS_ARE_FATAL
#ifdef __GNUC__
#define icalerror_assert(test,message) if(!(test)){fprintf(stderr,"%s(), %s:%d: %s\n",__FUNCTION__,__FILE__,__LINE__,message);icalerror_stop_here(); abort();}
#else /*__GNUC__*/
#define icalerror_assert(test,message) if(!(test)){fprintf(stderr,"%s:%d: %s\n",__FILE__,__LINE__,message);icalerror_stop_here(); abort();}
#endif /*__GNUC__*/
#else /* ICAL_ERRORS_ARE_FATAL */
#define icalerror_assert(test,message)
#endif /* ICAL_ERRORS_ARE_FATAL */
/* Check & abort if check fails */
#define icalerror_check_arg(test,arg) if(!(test)) { icalerror_set_errno(ICAL_BADARG_ERROR); }
/* Check & return void if check fails*/
#define icalerror_check_arg_rv(test,arg) if(!(test)) {icalerror_set_errno(ICAL_BADARG_ERROR); return; }
/* Check & return 0 if check fails*/
#define icalerror_check_arg_rz(test,arg) if(!(test)) { icalerror_set_errno(ICAL_BADARG_ERROR); return 0;}
/* Check & return an error if check fails*/
#define icalerror_check_arg_re(test,arg,error) if(!(test)) { icalerror_stop_here(); assert(0); return error;}
/* Check & return something*/
#define icalerror_check_arg_rx(test,arg,x) if(!(test)) { icalerror_set_errno(ICAL_BADARG_ERROR); return x;}
/* String interfaces to set an error to NONFATAL and restore it to its
original value */
icalerrorstate icalerror_supress(const char* error);
void icalerror_restore(const char* error, icalerrorstate es);
#endif /* !ICALERROR_H */
--- NEW FILE: sspm.h ---
/* -*- Mode: C -*-
======================================================================
FILE: sspm.h Mime Parser
CREATOR: eric 25 June 2000
$Id: sspm.h,v 1.1.2.1 2013-02-13 20:50:30 colin Exp $
$Locker: $
The contents of this file are subject to the Mozilla Public License
Version 1.0 (the "License"); you may not use this file except in
compliance with the License. You may obtain a copy of the License at
http://www.mozilla.org/MPL/
Software distributed under the License is distributed on an "AS IS"
basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
the License for the specific language governing rights and
limitations under the License.
This program is free software; you can redistribute it and/or modify
it under the terms of either:
The LGPL as published by the Free Software Foundation, version
2.1, available at: http://www.fsf.org/copyleft/lesser.html
Or:
The Mozilla Public License Version 1.0. You may obtain a copy of
the License at http://www.mozilla.org/MPL/
The Initial Developer of the Original Code is Eric Busboom
(C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
======================================================================*/
#ifndef SSPM_H
#define SSPM_H
enum sspm_major_type {
SSPM_NO_MAJOR_TYPE,
SSPM_TEXT_MAJOR_TYPE,
SSPM_IMAGE_MAJOR_TYPE,
SSPM_AUDIO_MAJOR_TYPE,
SSPM_VIDEO_MAJOR_TYPE,
SSPM_APPLICATION_MAJOR_TYPE,
SSPM_MULTIPART_MAJOR_TYPE,
SSPM_MESSAGE_MAJOR_TYPE,
SSPM_UNKNOWN_MAJOR_TYPE
};
enum sspm_minor_type {
SSPM_NO_MINOR_TYPE,
SSPM_ANY_MINOR_TYPE,
SSPM_PLAIN_MINOR_TYPE,
SSPM_RFC822_MINOR_TYPE,
SSPM_DIGEST_MINOR_TYPE,
SSPM_CALENDAR_MINOR_TYPE,
SSPM_MIXED_MINOR_TYPE,
SSPM_RELATED_MINOR_TYPE,
SSPM_ALTERNATIVE_MINOR_TYPE,
SSPM_PARALLEL_MINOR_TYPE,
SSPM_UNKNOWN_MINOR_TYPE
};
enum sspm_encoding {
SSPM_NO_ENCODING,
SSPM_QUOTED_PRINTABLE_ENCODING,
SSPM_8BIT_ENCODING,
SSPM_7BIT_ENCODING,
SSPM_BINARY_ENCODING,
SSPM_BASE64_ENCODING,
SSPM_UNKNOWN_ENCODING
};
enum sspm_error{
SSPM_NO_ERROR,
SSPM_UNEXPECTED_BOUNDARY_ERROR,
SSPM_WRONG_BOUNDARY_ERROR,
SSPM_NO_BOUNDARY_ERROR,
SSPM_NO_HEADER_ERROR,
SSPM_MALFORMED_HEADER_ERROR
};
struct sspm_header
{
int def;
char* boundary;
enum sspm_major_type major;
enum sspm_minor_type minor;
char *minor_text;
char ** content_type_params;
char* charset;
enum sspm_encoding encoding;
char* filename;
char* content_id;
enum sspm_error error;
char* error_text;
};
struct sspm_part {
struct sspm_header header;
int level;
size_t data_size;
void *data;
};
struct sspm_action_map {
enum sspm_major_type major;
enum sspm_minor_type minor;
void* (*new_part)();
void (*add_line)(void *part, struct sspm_header *header,
char* line, size_t size);
void* (*end_part)(void* part);
void (*free_part)(void *part);
};
char* sspm_major_type_string(enum sspm_major_type type);
char* sspm_minor_type_string(enum sspm_minor_type type);
char* sspm_encoding_string(enum sspm_encoding type);
int sspm_parse_mime(struct sspm_part *parts,
size_t max_parts,
struct sspm_action_map *actions,
char* (*get_string)(char *s, size_t size, void* data),
void *get_string_data,
struct sspm_header *first_header
);
void sspm_free_parts(struct sspm_part *parts, size_t max_parts);
char *decode_quoted_printable(char *dest,
char *src,
size_t *size);
char *decode_base64(char *dest,
char *src,
size_t *size);
int sspm_write_mime(struct sspm_part *parts,size_t num_parts,
char **output_string, char* header);
#endif /*SSPM_H*/
--- NEW FILE: icalvalue.c ---
/* -*- Mode: C -*- */
/*======================================================================
FILE: icalvalue.c
CREATOR: eric 02 May 1999
$Id: icalvalue.c,v 1.1.2.1 2013-02-13 20:50:30 colin 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
[...1158 lines suppressed...]
v->parent = property;
}
icalproperty* icalvalue_get_parent(icalvalue* value)
{
struct icalvalue_impl* v = (struct icalvalue_impl*)value;
return v->parent;
}
/* The remaining interfaces are 'new', 'set' and 'get' for each of the value
types */
/* Everything below this line is machine generated. Do not edit. */
--- NEW FILE: icalvalue.h ---
/* -*- Mode: C -*- */
/*======================================================================
FILE: icalvalue.h
CREATOR: eric 20 March 1999
$Id: icalvalue.h,v 1.1.2.1 2013-02-13 20:50:30 colin Exp $
$Locker: $
(C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
This program is free software; you can redistribute it and/or modify
it under the terms of either:
The LGPL as published by the Free Software Foundation, version
2.1, available at: http://www.fsf.org/copyleft/lesser.html
Or:
The Mozilla Public License Version 1.0. You may obtain a copy of
the License at http://www.mozilla.org/MPL/
The original code is icalvalue.h
======================================================================*/
#ifndef ICALVALUE_H
#define ICALVALUE_H
#include <time.h>
#include "icalenums.h"
#include "icaltypes.h"
#include "icalrecur.h"
#include "icalduration.h"
#include "icalperiod.h"
#include "icalderivedproperty.h" /* For icalproperty_method, etc. */
#include "icalderivedparameter.h"
#include "icalderivedvalue.h"
/* Defined in icalderivedvalue.h */
/*typedef void icalvalue;*/
icalvalue* icalvalue_new(icalvalue_kind kind);
icalvalue* icalvalue_new_clone(icalvalue* value);
icalvalue* icalvalue_new_from_string(icalvalue_kind kind, const char* str);
void icalvalue_free(icalvalue* value);
int icalvalue_is_valid(icalvalue* value);
const char* icalvalue_as_ical_string(icalvalue* value);
icalvalue_kind icalvalue_isa(icalvalue* value);
int icalvalue_isa_value(void*);
icalparameter_xliccomparetype icalvalue_compare(icalvalue* a, icalvalue *b);
/* Special, non autogenerated value accessors */
icalvalue* icalvalue_new_recur (struct icalrecurrencetype v);
void icalvalue_set_recur(icalvalue* value, struct icalrecurrencetype v);
struct icalrecurrencetype icalvalue_get_recur(icalvalue* value);
icalvalue* icalvalue_new_trigger (struct icaltriggertype v);
void icalvalue_set_trigger(icalvalue* value, struct icaltriggertype v);
struct icaltriggertype icalvalue_get_trigger(icalvalue* value);
icalvalue* icalvalue_new_datetimeperiod (struct icaldatetimeperiodtype v);
void icalvalue_set_datetimeperiod(icalvalue* value,
struct icaldatetimeperiodtype v);
struct icaldatetimeperiodtype icalvalue_get_datetimeperiod(icalvalue* value);
/* Convert enumerations */
icalvalue_kind icalvalue_string_to_kind(const char* str);
const char* icalvalue_kind_to_string(icalvalue_kind kind);
#endif /*ICALVALUE_H*/
--- NEW FILE: icalrestriction.c.in ---
/* -*- Mode: C -*- */
/* ======================================================================
File: icalrestriction.c
(C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
======================================================================*/
/*#line 7 "icalrestriction.c.in"*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "icalrestriction.h"
#include "icalenums.h"
#include "icalerror.h"
#include <assert.h>
#include <stdio.h> /* For snprintf */
#define TMP_BUF_SIZE 1024
/* Define the structs for the restrictions. these data are filled out
in machine generated code below */
struct icalrestriction_property_record;
typedef char* (*restriction_func)(struct icalrestriction_property_record* rec,icalcomponent* comp,icalproperty* prop);
typedef struct icalrestriction_property_record {
icalproperty_method method;
icalcomponent_kind component;
icalproperty_kind property;
icalrestriction_kind restriction;
restriction_func function;
} icalrestriction_property_record;
typedef struct icalrestriction_component_record {
icalproperty_method method;
icalcomponent_kind component;
icalcomponent_kind subcomponent;
icalrestriction_kind restriction;
restriction_func function;
} icalrestriction_component_record;
icalrestriction_property_record*
icalrestriction_get_property_restriction(icalproperty_method method,
icalcomponent_kind component,
icalproperty_kind property);
icalrestriction_component_record*
icalrestriction_get_component_restriction(icalproperty_method method,
icalcomponent_kind component,
icalcomponent_kind subcomponent);
icalrestriction_component_record icalrestriction_component_records[];
icalrestriction_property_record icalrestriction_property_records[];
icalrestriction_property_record null_prop_record = {ICAL_METHOD_NONE,ICAL_NO_COMPONENT,ICAL_NO_PROPERTY,ICAL_RESTRICTION_UNKNOWN,0};
icalrestriction_component_record null_comp_record = {ICAL_METHOD_NONE,ICAL_NO_COMPONENT,ICAL_NO_COMPONENT,ICAL_RESTRICTION_UNKNOWN,0};
/* The each row gives the result of comparing a restriction against a
count. The columns in each row represent 0,1,2+. '-1' indicates
'invalid, 'don't care' or 'needs more analysis' So, for
ICAL_RESTRICTION_ONE, if there is 1 of a property with that
restriction, it passes, but if there are 0 or 2+, it fails. */
char compare_map[ICAL_RESTRICTION_UNKNOWN+1][3] = {
{ 1, 1, 1},/*ICAL_RESTRICTION_NONE*/
{ 1, 0, 0},/*ICAL_RESTRICTION_ZERO*/
{ 0, 1, 0},/*ICAL_RESTRICTION_ONE*/
{ 1, 1, 1},/*ICAL_RESTRICTION_ZEROPLUS*/
{ 0, 1, 1},/*ICAL_RESTRICTION_ONEPLUS*/
{ 1, 1, 0},/*ICAL_RESTRICTION_ZEROORONE*/
{ 1, 1, 0},/*ICAL_RESTRICTION_ONEEXCLUSIVE*/
{ 1, 1, 0},/*ICAL_RESTRICTION_ONEMUTUAL*/
{ 1, 1, 1} /*ICAL_RESTRICTION_UNKNOWN*/
};
char restr_string_map[ICAL_RESTRICTION_UNKNOWN+1][60] = {
"unknown number",/*ICAL_RESTRICTION_NONE*/
"0",/*ICAL_RESTRICTION_ZERO*/
"1",/*ICAL_RESTRICTION_ONE*/
"zero or more",/*ICAL_RESTRICTION_ZEROPLUS*/
"one or more" ,/*ICAL_RESTRICTION_ONEPLUS*/
"zero or one",/*ICAL_RESTRICTION_ZEROORONE*/
"zero or one, exclusive with another property",/*ICAL_RESTRICTION_ONEEXCLUSIVE*/
"zero or one, mutual with another property",/*ICAL_RESTRICTION_ONEMUTUAL*/
"unknown number" /*ICAL_RESTRICTION_UNKNOWN*/
};
int
icalrestriction_compare(icalrestriction_kind restr, int count){
if ( restr < ICAL_RESTRICTION_NONE || restr > ICAL_RESTRICTION_UNKNOWN
|| count < 0){
return -1;
}
if (count > 2) {
count = 2;
}
return compare_map[restr][count];
}
/* Special case routines */
char* icalrestriction_may_be_draft_final_canceled(
icalrestriction_property_record *rec,
icalcomponent* comp,
icalproperty* prop)
{
icalproperty_status stat = icalproperty_get_status(prop);
if( !( stat == ICAL_STATUS_DRAFT ||
stat == ICAL_STATUS_FINAL ||
stat == ICAL_STATUS_CANCELLED )){
return "Failed iTIP restrictions for STATUS property. Value must be one of DRAFT, FINAL, or CANCELED";
}
return 0;
}
char* icalrestriction_may_be_comp_need_process(
icalrestriction_property_record *rec,
icalcomponent* comp,
icalproperty* prop)
{
icalproperty_status stat = icalproperty_get_status(prop);
if( !( stat == ICAL_STATUS_COMPLETED ||
stat == ICAL_STATUS_NEEDSACTION ||
stat == ICAL_STATUS_INPROCESS )){
return "Failed iTIP restrictions for STATUS property. Value must be one of COMPLETED, NEEDS-ACTION or IN-PROCESS";
}
return 0;
}
char* icalrestriction_may_be_tent_conf(icalrestriction_property_record *rec,
icalcomponent* comp,
icalproperty* prop){
icalproperty_status stat = icalproperty_get_status(prop);
if( !( stat == ICAL_STATUS_TENTATIVE ||
stat == ICAL_STATUS_CONFIRMED )){
return "Failed iTIP restrictions for STATUS property. Value must be one of TENTATIVE or CONFIRMED";
}
return 0;
}
char* icalrestriction_may_be_tent_conf_cancel(
icalrestriction_property_record *rec,
icalcomponent* comp,
icalproperty* prop)
{
icalproperty_status stat = icalproperty_get_status(prop);
if( !( stat == ICAL_STATUS_TENTATIVE ||
stat == ICAL_STATUS_CONFIRMED ||
stat == ICAL_STATUS_CANCELLED )){
return "Failed iTIP restrictions for STATUS property. Value must be one of TENTATIVE, CONFIRMED or CANCELED";
}
return 0;
}
char* icalrestriction_must_be_cancel_if_present(
icalrestriction_property_record *rec,
icalcomponent* comp,
icalproperty* prop)
{
/* This routine will not be called if prop == 0 */
icalproperty_status stat = icalproperty_get_status(prop);
if( stat != ICAL_STATUS_CANCELLED)
{
return "Failed iTIP restrictions for STATUS property. Value must be CANCELLED";
}
return 0;
}
char* icalrestriction_must_be_canceled_no_attendee(
icalrestriction_property_record *rec,
icalcomponent* comp,
icalproperty* prop)
{
/* Hack. see rfc2446, 3.2.5 CANCEL for porperty STATUS. I don't
understand the note */
return 0;
}
char* icalrestriction_must_be_recurring(icalrestriction_property_record *rec,
icalcomponent* comp,
icalproperty* prop){
/* Hack */
return 0;
}
char* icalrestriction_must_have_duration(icalrestriction_property_record *rec,
icalcomponent* comp,
icalproperty* prop){
if( !icalcomponent_get_first_property(comp,ICAL_DURATION_PROPERTY)){
return "Failed iTIP restrictions for STATUS property. This component must have a DURATION property";
}
return 0;
}
char* icalrestriction_must_have_repeat(icalrestriction_property_record *rec,
icalcomponent* comp,
icalproperty* prop){
if( !icalcomponent_get_first_property(comp,ICAL_REPEAT_PROPERTY)){
return "Failed iTIP restrictions for STATUS property. This component must have a REPEAT property";
}
return 0;
}
char* icalrestriction_must_if_tz_ref(icalrestriction_property_record *rec,
icalcomponent* comp,
icalproperty* prop){
/* Hack */
return 0;
}
char* icalrestriction_no_dtend(icalrestriction_property_record *rec,
icalcomponent* comp,
icalproperty* prop){
if( !icalcomponent_get_first_property(comp,ICAL_DTEND_PROPERTY)){
return "Failed iTIP restrictions for STATUS property. The component must not have both DURATION and DTEND";
}
return 0;
}
char* icalrestriction_no_duration(icalrestriction_property_record *rec,
icalcomponent* comp,
icalproperty* prop){
/* _no_dtend takes care of this one */
return 0;
}
int icalrestriction_check_component(icalproperty_method method,
icalcomponent* comp)
{
icalproperty_kind kind;
icalcomponent_kind comp_kind;
icalrestriction_kind restr;
icalrestriction_property_record *prop_record;
icalrestriction_component_record *comp_record;
char* funcr = 0;
icalproperty *prop;
int count;
int compare;
int valid = 1;
comp_kind = icalcomponent_isa(comp);
/* Check all of the properties in this component */
for(kind = ICAL_ANY_PROPERTY+1; kind != ICAL_NO_PROPERTY; kind++){
count = icalcomponent_count_properties(comp, kind);
prop_record = icalrestriction_get_property_restriction(method,
comp_kind,
kind);
restr = prop_record->restriction;
if(restr == ICAL_RESTRICTION_ONEEXCLUSIVE ||
restr == ICAL_RESTRICTION_ONEMUTUAL) {
/* First treat is as a 0/1 restriction */
restr = ICAL_RESTRICTION_ZEROORONE;
compare = icalrestriction_compare(restr,count);
} else {
compare = icalrestriction_compare(restr,count);
}
assert(compare != -1);
if (compare == 0){
char temp[TMP_BUF_SIZE];
snprintf(temp, TMP_BUF_SIZE,"Failed iTIP restrictions for %s property. Expected %s instances of the property and got %d",
icalenum_property_kind_to_string(kind),
restr_string_map[restr], count);
icalcomponent_add_property
(comp,
icalproperty_vanew_xlicerror(
temp,
icalparameter_new_xlicerrortype(ICAL_XLICERRORTYPE_INVALIDITIP),
0));
}
prop = icalcomponent_get_first_property(comp, kind);
if (prop != 0 && prop_record->function !=0 ){
funcr = prop_record->function(prop_record,comp,prop);
}
if(funcr !=0){
icalcomponent_add_property
(comp,
icalproperty_vanew_xlicerror(
funcr,
icalparameter_new_xlicerrortype(
ICAL_XLICERRORTYPE_INVALIDITIP),
0));
compare = 0;
}
valid = valid && compare;
}
return valid;
}
int icalrestriction_check(icalcomponent* outer_comp)
{
icalcomponent_kind comp_kind;
icalproperty_method method;
icalcomponent* inner_comp;
icalproperty *method_prop;
int valid;
icalerror_check_arg_rz( (outer_comp!=0), "outer comp");
/* Get the Method value from the outer component */
comp_kind = icalcomponent_isa(outer_comp);
if (comp_kind != ICAL_VCALENDAR_COMPONENT){
icalerror_set_errno(ICAL_BADARG_ERROR);
return 0;
}
method_prop = icalcomponent_get_first_property(outer_comp,
ICAL_METHOD_PROPERTY);
if (method_prop == 0){
method = ICAL_METHOD_NONE;
} else {
method = icalproperty_get_method(method_prop);
}
/* Check the VCALENDAR wrapper */
valid = icalrestriction_check_component(ICAL_METHOD_NONE,outer_comp);
/* Now check the inner components */
for(inner_comp= icalcomponent_get_first_component(outer_comp,
ICAL_ANY_COMPONENT);
inner_comp != 0;
inner_comp= icalcomponent_get_next_component(outer_comp,
ICAL_ANY_COMPONENT)){
valid = valid && icalrestriction_check_component(method,inner_comp);
}
return valid;
}
icalrestriction_property_record*
icalrestriction_get_property_restriction(icalproperty_method method,
icalcomponent_kind component,
icalproperty_kind property)
{
int i;
for(i = 0;
icalrestriction_property_records[i].restriction != ICAL_RESTRICTION_NONE;
i++){
if (method == icalrestriction_property_records[i].method &&
component == icalrestriction_property_records[i].component &&
property == icalrestriction_property_records[i].property ){
return &icalrestriction_property_records[i];
}
}
return &null_prop_record;
}
icalrestriction_component_record*
icalrestriction_get_component_restriction(icalproperty_method method,
icalcomponent_kind component,
icalcomponent_kind subcomponent)
{
int i;
for(i = 0;
icalrestriction_component_records[i].restriction != ICAL_RESTRICTION_NONE;
i++){
if (method == icalrestriction_component_records[i].method &&
component == icalrestriction_component_records[i].component &&
subcomponent == icalrestriction_component_records[i].subcomponent ){
return &icalrestriction_component_records[i];
}
}
return &null_comp_record;
}
--- NEW FILE: icaltypes.c ---
/* -*- Mode: C -*-
======================================================================
FILE: icaltypes.c
CREATOR: eric 16 May 1999
$Id: icaltypes.c,v 1.1.2.1 2013-02-13 20:50:30 colin Exp $
$Locker: $
(C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
This program is free software; you can redistribute it and/or modify
it under the terms of either:
The LGPL as published by the Free Software Foundation, version
2.1, available at: http://www.fsf.org/copyleft/lesser.html
Or:
The Mozilla Public License Version 1.0. You may obtain a copy of
the License at http://www.mozilla.org/MPL/
The original code is icaltypes.c
======================================================================*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "icaltypes.h"
#include "icalerror.h"
#include "icalmemory.h"
#include <stdlib.h> /* for malloc and abs() */
#include <errno.h> /* for errno */
#include <string.h> /* for icalmemory_strdup */
#include <assert.h>
#define TEMP_MAX 1024
void*
icalattachtype_get_data (struct icalattachtype* type);
struct icalattachtype*
icalattachtype_new()
{
struct icalattachtype* v;
if ( ( v = (struct icalattachtype*)
malloc(sizeof(struct icalattachtype))) == 0) {
errno = ENOMEM;
return 0;
}
v->refcount = 1;
v->binary = 0;
v->owns_binary = 0;
v->base64 = 0;
v->owns_base64 = 0;
v->url = 0;
return v;
}
void
icalattachtype_free(struct icalattachtype* v)
{
icalerror_check_arg( (v!=0),"v");
v->refcount--;
if (v->refcount <= 0){
if (v->base64 != 0 && v->owns_base64 != 0){
free(v->base64);
}
if (v->binary != 0 && v->owns_binary != 0){
free(v->binary);
}
if (v->url != 0){
free(v->url);
}
free(v);
}
}
void icalattachtype_add_reference(struct icalattachtype* v)
{
icalerror_check_arg( (v!=0),"v");
v->refcount++;
}
void icalattachtype_set_url(struct icalattachtype* v, char* url)
{
icalerror_check_arg( (v!=0),"v");
if (v->url != 0){
free (v->url);
}
v->url = icalmemory_strdup(url);
/* HACK This routine should do something if icalmemory_strdup returns NULL */
}
char* icalattachtype_get_url(struct icalattachtype* v)
{
icalerror_check_arg( (v!=0),"v");
return v->url;
}
void icalattachtype_set_base64(struct icalattachtype* v, char* base64,
int owns)
{
icalerror_check_arg( (v!=0),"v");
v->base64 = base64;
v->owns_base64 = !(owns != 0 );
}
char* icalattachtype_get_base64(struct icalattachtype* v)
{
icalerror_check_arg( (v!=0),"v");
return v->base64;
}
void icalattachtype_set_binary(struct icalattachtype* v, char* binary,
int owns)
{
icalerror_check_arg( (v!=0),"v");
v->binary = binary;
v->owns_binary = !(owns != 0 );
}
void* icalattachtype_get_binary(struct icalattachtype* v)
{
icalerror_check_arg( (v!=0),"v");
return v->binary;
}
struct icaltriggertype icaltriggertype_from_string(const char* str)
{
struct icaltriggertype tr, null_tr;
int old_ieaf = icalerror_errors_are_fatal;
tr.time= icaltime_null_time();
tr.duration = icaldurationtype_from_int(0);
null_tr = tr;
if(str == 0) goto error;
icalerror_errors_are_fatal = 0;
tr.time = icaltime_from_string(str);
icalerror_errors_are_fatal = old_ieaf;
if (icaltime_is_null_time(tr.time)){
tr.duration = icaldurationtype_from_string(str);
if(icaldurationtype_as_int(tr.duration) == 0) goto error;
}
return tr;
error:
icalerror_set_errno(ICAL_MALFORMEDDATA_ERROR);
return null_tr;
}
struct icalreqstattype icalreqstattype_from_string(char* str)
{
char *p1,*p2;
struct icalreqstattype stat;
int major, minor;
icalerror_check_arg((str != 0),"str");
stat.code = ICAL_UNKNOWN_STATUS;
stat.debug = 0;
stat.desc = 0;
/* Get the status numbers */
sscanf(str, "%d.%d",&major, &minor);
if (major <= 0 || minor < 0){
icalerror_set_errno(ICAL_BADARG_ERROR);
return stat;
}
stat.code = icalenum_num_to_reqstat(major, minor);
if (stat.code == ICAL_UNKNOWN_STATUS){
icalerror_set_errno(ICAL_BADARG_ERROR);
return stat;
}
p1 = strchr(str,';');
if (p1 == 0){
/* icalerror_set_errno(ICAL_BADARG_ERROR);*/
return stat;
}
/* Just ignore the second clause; it will be taken from inside the library
*/
p2 = strchr(p1+1,';');
if (p2 != 0 && *p2 != 0){
stat.debug = p2+1;
}
return stat;
}
char* icalreqstattype_as_string(struct icalreqstattype stat)
{
char *temp;
temp = (char*)icalmemory_tmp_buffer(TEMP_MAX);
icalerror_check_arg_rz((stat.code != ICAL_UNKNOWN_STATUS),"Status");
if (stat.desc == 0){
stat.desc = icalenum_reqstat_desc(stat.code);
}
if(stat.debug != 0){
snprintf(temp,TEMP_MAX,"%d.%d;%s;%s", icalenum_reqstat_major(stat.code),
icalenum_reqstat_minor(stat.code),
stat.desc, stat.debug);
} else {
snprintf(temp,TEMP_MAX,"%d.%d;%s", icalenum_reqstat_major(stat.code),
icalenum_reqstat_minor(stat.code),
stat.desc);
}
return temp;
}
--- NEW FILE: icalenums.h ---
/* -*- Mode: C -*-*/
/*======================================================================
FILE: icalenums.h
(C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
This program is free software; you can redistribute it and/or modify
it under the terms of either:
The LGPL as published by the Free Software Foundation, version
2.1, available at: http://www.fsf.org/copyleft/lesser.html
Or:
The Mozilla Public License Version 1.0. You may obtain a copy of
the License at http://www.mozilla.org/MPL/
The original code is icalenums.h
Contributions from:
Graham Davison (g.m.davison at computer.org)
======================================================================*/
#ifndef ICALENUMS_H
#define ICALENUMS_H
/***********************************************************************
* Component enumerations
**********************************************************************/
typedef enum icalcomponent_kind {
ICAL_NO_COMPONENT,
ICAL_ANY_COMPONENT, /* Used to select all components*/
ICAL_XROOT_COMPONENT,
ICAL_XATTACH_COMPONENT, /* MIME attached data, returned by parser. */
ICAL_VEVENT_COMPONENT,
ICAL_VTODO_COMPONENT,
ICAL_VJOURNAL_COMPONENT,
ICAL_VCALENDAR_COMPONENT,
ICAL_VFREEBUSY_COMPONENT,
ICAL_VALARM_COMPONENT,
ICAL_XAUDIOALARM_COMPONENT,
ICAL_XDISPLAYALARM_COMPONENT,
ICAL_XEMAILALARM_COMPONENT,
ICAL_XPROCEDUREALARM_COMPONENT,
ICAL_VTIMEZONE_COMPONENT,
ICAL_XSTANDARD_COMPONENT,
ICAL_XDAYLIGHT_COMPONENT,
ICAL_X_COMPONENT,
ICAL_VSCHEDULE_COMPONENT,
ICAL_VQUERY_COMPONENT,
ICAL_VCAR_COMPONENT,
ICAL_VCOMMAND_COMPONENT,
ICAL_XLICINVALID_COMPONENT,
ICAL_XLICMIMEPART_COMPONENT /* a non-stardard component that mirrors
structure of MIME data */
} icalcomponent_kind;
/***********************************************************************
* Request Status codes
**********************************************************************/
typedef enum icalrequeststatus {
ICAL_UNKNOWN_STATUS,
ICAL_2_0_SUCCESS_STATUS,
ICAL_2_1_FALLBACK_STATUS,
ICAL_2_2_IGPROP_STATUS,
ICAL_2_3_IGPARAM_STATUS,
ICAL_2_4_IGXPROP_STATUS,
ICAL_2_5_IGXPARAM_STATUS,
ICAL_2_6_IGCOMP_STATUS,
ICAL_2_7_FORWARD_STATUS,
ICAL_2_8_ONEEVENT_STATUS,
ICAL_2_9_TRUNC_STATUS,
ICAL_2_10_ONETODO_STATUS,
ICAL_2_11_TRUNCRRULE_STATUS,
ICAL_3_0_INVPROPNAME_STATUS,
ICAL_3_1_INVPROPVAL_STATUS,
ICAL_3_2_INVPARAM_STATUS,
ICAL_3_3_INVPARAMVAL_STATUS,
ICAL_3_4_INVCOMP_STATUS,
ICAL_3_5_INVTIME_STATUS,
ICAL_3_6_INVRULE_STATUS,
ICAL_3_7_INVCU_STATUS,
ICAL_3_8_NOAUTH_STATUS,
ICAL_3_9_BADVERSION_STATUS,
ICAL_3_10_TOOBIG_STATUS,
ICAL_3_11_MISSREQCOMP_STATUS,
ICAL_3_12_UNKCOMP_STATUS,
ICAL_3_13_BADCOMP_STATUS,
ICAL_3_14_NOCAP_STATUS,
ICAL_4_0_BUSY_STATUS,
ICAL_5_0_MAYBE_STATUS,
ICAL_5_1_UNAVAIL_STATUS,
ICAL_5_2_NOSERVICE_STATUS,
ICAL_5_3_NOSCHED_STATUS
} icalrequeststatus;
const char* icalenum_reqstat_desc(icalrequeststatus stat);
short icalenum_reqstat_major(icalrequeststatus stat);
short icalenum_reqstat_minor(icalrequeststatus stat);
icalrequeststatus icalenum_num_to_reqstat(short major, short minor);
/***********************************************************************
* Conversion functions
**********************************************************************/
/* Thse routines used to be in icalenums.c, but were moved into the
icalproperty, icalparameter, icalvalue, or icalcomponent modules. */
/* const char* icalproperty_kind_to_string(icalproperty_kind kind);*/
#define icalenum_property_kind_to_string(x) icalproperty_kind_to_string(x)
/*icalproperty_kind icalproperty_string_to_kind(const char* string)*/
#define icalenum_string_to_property_kind(x) icalproperty_string_to_kind(x)
/*icalvalue_kind icalproperty_kind_to_value_kind(icalproperty_kind kind);*/
#define icalenum_property_kind_to_value_kind(x) icalproperty_kind_to_value_kind(x)
/*const char* icalenum_method_to_string(icalproperty_method);*/
#define icalenum_method_to_string(x) icalproperty_method_to_string(x)
/*icalproperty_method icalenum_string_to_method(const char* string);*/
#define icalenum_string_to_method(x) icalproperty_string_to_method(x)
/*const char* icalenum_status_to_string(icalproperty_status);*/
#define icalenum_status_to_string(x) icalproperty_status_to_string(x)
/*icalproperty_status icalenum_string_to_status(const char* string);*/
#define icalenum_string_to_status(x) icalproperty_string_to_status(x)
/*icalvalue_kind icalenum_string_to_value_kind(const char* str);*/
#define icalenum_string_to_value_kind(x) icalvalue_string_to_kind(x)
/*const char* icalenum_value_kind_to_string(icalvalue_kind kind);*/
#define icalenum_value_kind_to_string(x) icalvalue_kind_to_string(x)
/*const char* icalenum_component_kind_to_string(icalcomponent_kind kind);*/
#define icalenum_component_kind_to_string(x) icalcomponent_kind_to_string(x)
/*icalcomponent_kind icalenum_string_to_component_kind(const char* string);*/
#define icalenum_string_to_component_kind(x) icalcomponent_string_to_kind(x)
#endif /* !ICALENUMS_H */
--- NEW FILE: icalrecur.h ---
/* -*- Mode: C -*- */
/*======================================================================
FILE: icalrecur.h
CREATOR: eric 20 March 2000
(C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
This program is free software; you can redistribute it and/or modify
it under the terms of either:
The LGPL as published by the Free Software Foundation, version
2.1, available at: http://www.fsf.org/copyleft/lesser.html
Or:
The Mozilla Public License Version 1.0. You may obtain a copy of
the License at http://www.mozilla.org/MPL/
How to use:
1) Get a rule and a start time from a component
icalproperty rrule;
struct icalrecurrencetype recur;
struct icaltimetype dtstart;
rrule = icalcomponent_get_first_property(comp,ICAL_RRULE_PROPERTY);
recur = icalproperty_get_rrule(rrule);
start = icalproperty_get_dtstart(dtstart);
Or, just make them up:
recur = icalrecurrencetype_from_string("FREQ=YEARLY;BYDAY=SU,WE");
dtstart = icaltime_from_string("19970101T123000")
2) Create an iterator
icalrecur_iterator* ritr;
ritr = icalrecur_iterator_new(recur,start);
3) Iterator over the occurrences
struct icaltimetype next;
while (next = icalrecur_iterator_next(ritr)
&& !icaltime_is_null_time(next){
Do something with next
}
Note that that the time returned by icalrecur_iterator_next is in
whatever timezone that dtstart is in.
======================================================================*/
#ifndef ICALRECUR_H
#define ICALRECUR_H
#include <time.h>
#include "icaltime.h"
/***********************************************************************
* Recurrance enumerations
**********************************************************************/
typedef enum icalrecurrencetype_frequency
{
/* These enums are used to index an array, so don't change the
order or the integers */
ICAL_SECONDLY_RECURRENCE=0,
ICAL_MINUTELY_RECURRENCE=1,
ICAL_HOURLY_RECURRENCE=2,
ICAL_DAILY_RECURRENCE=3,
ICAL_WEEKLY_RECURRENCE=4,
ICAL_MONTHLY_RECURRENCE=5,
ICAL_YEARLY_RECURRENCE=6,
ICAL_NO_RECURRENCE=7
} icalrecurrencetype_frequency;
typedef enum icalrecurrencetype_weekday
{
ICAL_NO_WEEKDAY,
ICAL_SUNDAY_WEEKDAY,
ICAL_MONDAY_WEEKDAY,
ICAL_TUESDAY_WEEKDAY,
ICAL_WEDNESDAY_WEEKDAY,
ICAL_THURSDAY_WEEKDAY,
ICAL_FRIDAY_WEEKDAY,
ICAL_SATURDAY_WEEKDAY
} icalrecurrencetype_weekday;
enum {
ICAL_RECURRENCE_ARRAY_MAX = 0x7f7f,
ICAL_RECURRENCE_ARRAY_MAX_BYTE = 0x7f
};
/********************** Recurrence type routines **************/
/* See RFC 2445 Section 4.3.10, RECUR Value, for an explaination of
the values and fields in struct icalrecurrencetype */
#define ICAL_BY_SECOND_SIZE 61
#define ICAL_BY_MINUTE_SIZE 61
#define ICAL_BY_HOUR_SIZE 25
#define ICAL_BY_DAY_SIZE 364 /* 7 days * 52 weeks */
#define ICAL_BY_MONTHDAY_SIZE 32
#define ICAL_BY_YEARDAY_SIZE 367
#define ICAL_BY_WEEKNO_SIZE 54
#define ICAL_BY_MONTH_SIZE 13
#define ICAL_BY_SETPOS_SIZE 367
/* Main struct for holding digested recurrence rules */
struct icalrecurrencetype
{
icalrecurrencetype_frequency freq;
/* until and count are mutually exclusive. */
struct icaltimetype until;
int count;
short interval;
icalrecurrencetype_weekday week_start;
/* The BY* parameters can each take a list of values. Here I
* assume that the list of values will not be larger than the
* range of the value -- that is, the client will not name a
* value more than once.
* Each of the lists is terminated with the value
* ICAL_RECURRENCE_ARRAY_MAX unless the the list is full.
*/
short by_second[ICAL_BY_SECOND_SIZE];
short by_minute[ICAL_BY_MINUTE_SIZE];
short by_hour[ICAL_BY_HOUR_SIZE];
short by_day[ICAL_BY_DAY_SIZE]; /* Encoded value, see below */
short by_month_day[ICAL_BY_MONTHDAY_SIZE];
short by_year_day[ ICAL_BY_YEARDAY_SIZE];
short by_week_no[ICAL_BY_WEEKNO_SIZE];
short by_month[ICAL_BY_MONTH_SIZE];
short by_set_pos[ICAL_BY_SETPOS_SIZE];
};
void icalrecurrencetype_clear(struct icalrecurrencetype *r);
/* The 'day' element of the by_day array is encoded to allow
representation of both the day of the week ( Monday, Tueday), but also
the Nth day of the week ( First tuesday of the month, last thursday of
the year) These routines decode the day values */
/* 1 == Monday, etc. */
enum icalrecurrencetype_weekday icalrecurrencetype_day_day_of_week(short day);
/* 0 == any of day of week. 1 == first, 2 = second, -2 == second to last, etc */
short icalrecurrencetype_day_position(short day);
/***********************************************************************
* Recurrance rule parser
**********************************************************************/
/* Convert between strings ans recurrencetype structures. */
struct icalrecurrencetype icalrecurrencetype_from_string(const char* str);
char* icalrecurrencetype_as_string(struct icalrecurrencetype *recur);
/********** recurrence iteration routines ********************/
typedef void icalrecur_iterator;
/* Create a new recurrence rule iterator */
icalrecur_iterator* icalrecur_iterator_new(struct icalrecurrencetype rule,
struct icaltimetype dtstart);
/* Get the next occurrence from an iterator */
struct icaltimetype icalrecur_iterator_next(icalrecur_iterator*);
/* Free the iterator */
void icalrecur_iterator_free(icalrecur_iterator*);
/* Fills array up with at most 'count' time_t values, each
representing an occurrence time in seconds past the POSIX epoch */
int icalrecur_expand_recurrence(char* rule, time_t start,
int count, time_t* array);
#endif
--- NEW FILE: icallexer.l ---
%{
/* -*- Mode: C -*-
======================================================================
FILE: icallexer.l
CREATOR: eric 10 June 1999
DESCRIPTION:
$Id: icallexer.l,v 1.1.2.1 2013-02-13 20:50:30 colin Exp $
$Locker: $
(C) COPYRIGHT 1999 Eric Busboom
http://www.softwarestudio.org
The contents of this file are subject to the Mozilla Public License
Version 1.0 (the "License"); you may not use this file except in
compliance with the License. You may obtain a copy of the License at
http://www.mozilla.org/MPL/
Software distributed under the License is distributed on an "AS IS"
basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
the License for the specific language governing rights and
limitations under the License.
The original author is Eric Busboom
The original code is icalitip.y
======================================================================*/
#include "icalparser.h"
#include "icalenums.h"
#include "icalmemory.h"
#include "assert.h"
#include "icalyacc.h"
#include <string.h> /* For strdup() */
int icalparser_flex_input(char* buf, int max_size);
void icalparser_clear_flex_input(void);
#define ICAL_MAX_STR_CONST 1024
#undef YY_INPUT
#define YY_INPUT(b,r,ms) ( r= icalparser_flex_input(b,ms))
#undef yywrap
#undef YY_FATAL_ERROR
#define YY_FATAL_ERROR(msg) ical_yyerror(msg)
icalvalue_kind value_kind=ICAL_NO_VALUE;
void set_parser_value_state(icalvalue_kind kind);
extern int yydebug;
void ical_yyerror(char *s);
void init_str_buf(void);
int last_state;
char *str_buf;
char *str_buf_p;
size_t buf_sz; /* = ICAL_MAX_STR_CONST;*/
/* Define routines that were not propertly defined because of the
renaming hack applied in icalyacc.y */
YY_BUFFER_STATE ical_yy_scan_buffer ( char *base, yy_size_t size );
YY_BUFFER_STATE ical_yy_scan_string ( yyconst char *yy_str );
YY_BUFFER_STATE ical_yy_scan_bytes ( yyconst char *bytes, int len );
%}
crlf \x0D?\x0A
space [ ]
qsafechar [^\x00-\x1F\"]
safechar [^\x00-\x1F\"\:\;\,]
tsafechar [\x20-\x21\x23-\x2B\x2D-\x39\x3C-\x5B\x5D-\x7E]
valuechar [^\x00-\x08\x10-\x1F]
xname X-[a-zA-Z0-9\-]+
xname2 [a-zA-Z0-9\-\ ]
paramtext {safechar}+
value {valuechar}+
quotedstring \"{qsafechar}+\"
digit [0-9]
%array /* Make yytext an array. Slow, but handy. HACK */
%option caseless
%s quoted_string
%s binary_value boolean_value uri_value time_value duration_value number_value period_value recur_value text_value utcoffset_value
%s enum_param_value string_param_value stringlist_param_value keyword line_start component seperator parameter end_of_value paramtext
%%
%{
%}
<time_value>{
{digit}+ { ical_yylval.v_string =icalmemory_tmp_copy(yytext) ;
return DIGITS; }
T { return TIME_CHAR; }
Z { return UTC_CHAR; }
[\/\+\-PWHMSD] { return yytext[0]; }
{crlf} { return EOL;}
}
<utcoffset_value>{
{crlf} { return EOL;}
\-|\+ { return yytext[0]; }
{digit}{digit} { ical_yylval.v_int=atoi(yytext); return INTNUMBER; }
}
<enum_param_value>{
. { return CHARACTER; }
{crlf} { return EOL;}
}
<seperator>{
, { BEGIN(last_state); return COMMA; }
}
%%
int yywrap()
{
return 1;
}
void set_parser_value_state(icalvalue_kind kind)
{
switch (kind){
case ICAL_UTCOFFSET_VALUE:
{BEGIN(utcoffset_value);break;}
case ICAL_DATETIMEPERIOD_VALUE:
case ICAL_DURATION_VALUE:
case ICAL_PERIOD_VALUE:
{BEGIN(time_value);break;}
default:
{
assert(1==0);
}
}
}
void init_str_buf(void)
{
str_buf = icalmemory_tmp_buffer(ICAL_MAX_STR_CONST);
str_buf_p = str_buf;
buf_sz = ICAL_MAX_STR_CONST;
}
--- NEW FILE: icalduration.h ---
/* -*- Mode: C -*- */
/*======================================================================
FILE: icalduration.h
CREATOR: eric 26 Jan 2001
$Id: icalduration.h,v 1.1.2.1 2013-02-13 20:50:29 colin Exp $
$Locker: $
(C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
This program is free software; you can redistribute it and/or modify
it under the terms of either:
The LGPL as published by the Free Software Foundation, version
2.1, available at: http://www.fsf.org/copyleft/lesser.html
Or:
The Mozilla Public License Version 1.0. You may obtain a copy of
the License at http://www.mozilla.org/MPL/
The Original Code is eric. The Initial Developer of the Original
Code is Eric Busboom
======================================================================*/
#ifndef ICALDURATION_H
#define ICALDURATION_H
#include "icaltime.h"
struct icaldurationtype
{
int is_neg;
unsigned int days;
unsigned int weeks;
unsigned int hours;
unsigned int minutes;
unsigned int seconds;
};
struct icaldurationtype icaldurationtype_from_int(int t);
struct icaldurationtype icaldurationtype_from_string(const char*);
int icaldurationtype_as_int(struct icaldurationtype duration);
char* icaldurationtype_as_ical_string(struct icaldurationtype d);
struct icaldurationtype icaldurationtype_null_duration();
int icaldurationtype_is_null_duration(struct icaldurationtype d);
struct icaltimetype icaltime_add(struct icaltimetype t,
struct icaldurationtype d);
struct icaldurationtype icaltime_subtract(struct icaltimetype t1,
struct icaltimetype t2);
#endif /* !ICALDURATION_H */
--- NEW FILE: icalrecur.c ---
/* -*- Mode: C -*-
======================================================================
FILE: icalrecur.c
CREATOR: eric 16 May 2000
$Id: icalrecur.c,v 1.1.2.1 2013-02-13 20:50:30 colin Exp $
$Locker: $
(C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
This program is free software; you can redistribute it and/or modify
it under the terms of either:
The LGPL as published by the Free Software Foundation, version
2.1, available at: http://www.fsf.org/copyleft/lesser.html
Or:
[...2219 lines suppressed...]
recur = icalrecurrencetype_from_string(rule);
for(ritr = icalrecur_iterator_new(recur,icstart),
next = icalrecur_iterator_next(ritr);
!icaltime_is_null_time(next) && i < count;
next = icalrecur_iterator_next(ritr)){
tt = icaltime_as_timet(next);
if (tt >= start ){
array[i++] = tt;
}
}
icalrecur_iterator_free(ritr);
return 1;
}
--- NEW FILE: icalenums.c ---
/* -*- Mode: C -*- */
/*======================================================================
FILE: icalenum.c
CREATOR: eric 29 April 1999
$Id: icalenums.c,v 1.1.2.1 2013-02-13 20:50:30 colin 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 icalenum.c
======================================================================*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "icalenums.h"
#include <stdio.h> /* For fprintf */
#include <stdio.h> /* For stderr */
#include <string.h> /* For strncmp */
#include <assert.h>
struct {
enum icalrequeststatus kind;
int major;
int minor;
const char* str;
} request_status_map[] = {
{ICAL_2_0_SUCCESS_STATUS, 2,0,"Success."},
{ICAL_2_1_FALLBACK_STATUS, 2,1,"Success but fallback taken on one or more property values."},
{ICAL_2_2_IGPROP_STATUS, 2,2,"Success, invalid property ignored."},
{ICAL_2_3_IGPARAM_STATUS, 2,3,"Success, invalid property parameter ignored."},
{ICAL_2_4_IGXPROP_STATUS, 2,4,"Success, unknown non-standard property ignored."},
{ICAL_2_5_IGXPARAM_STATUS, 2,5,"Success, unknown non standard property value ignored."},
{ICAL_2_6_IGCOMP_STATUS, 2,6,"Success, invalid calendar component ignored."},
{ICAL_2_7_FORWARD_STATUS, 2,7,"Success, request forwarded to Calendar User."},
{ICAL_2_8_ONEEVENT_STATUS, 2,8,"Success, repeating event ignored. Scheduled as a single component."},
{ICAL_2_9_TRUNC_STATUS, 2,9,"Success, truncated end date time to date boundary."},
{ICAL_2_10_ONETODO_STATUS, 2,10,"Success, repeating VTODO ignored. Scheduled as a single VTODO."},
{ICAL_2_11_TRUNCRRULE_STATUS, 2,11,"Success, unbounded RRULE clipped at some finite number of instances "},
{ICAL_3_0_INVPROPNAME_STATUS, 3,0,"Invalid property name."},
{ICAL_3_1_INVPROPVAL_STATUS, 3,1,"Invalid property value."},
{ICAL_3_2_INVPARAM_STATUS, 3,2,"Invalid property parameter."},
{ICAL_3_3_INVPARAMVAL_STATUS, 3,3,"Invalid property parameter value."},
{ICAL_3_4_INVCOMP_STATUS, 3,4,"Invalid calendar component."},
{ICAL_3_5_INVTIME_STATUS, 3,5,"Invalid date or time."},
{ICAL_3_6_INVRULE_STATUS, 3,6,"Invalid rule."},
{ICAL_3_7_INVCU_STATUS, 3,7,"Invalid Calendar User."},
{ICAL_3_8_NOAUTH_STATUS, 3,8,"No authority."},
{ICAL_3_9_BADVERSION_STATUS, 3,9,"Unsupported version."},
{ICAL_3_10_TOOBIG_STATUS, 3,10,"Request entity too large."},
{ICAL_3_11_MISSREQCOMP_STATUS, 3,11,"Required component or property missing."},
{ICAL_3_12_UNKCOMP_STATUS, 3,12,"Unknown component or property found."},
{ICAL_3_13_BADCOMP_STATUS, 3,13,"Unsupported component or property found"},
{ICAL_3_14_NOCAP_STATUS, 3,14,"Unsupported capability."},
{ICAL_4_0_BUSY_STATUS, 4,0,"Event conflict. Date/time is busy."},
{ICAL_5_0_MAYBE_STATUS, 5,0,"Request MAY supported."},
{ICAL_5_1_UNAVAIL_STATUS, 5,1,"Service unavailable."},
{ICAL_5_2_NOSERVICE_STATUS, 5,2,"Invalid calendar service."},
{ICAL_5_3_NOSCHED_STATUS, 5,3,"No scheduling support for user."},
{ICAL_UNKNOWN_STATUS, 0,0,"Error: Unknown request status"}
};
const char* icalenum_reqstat_desc(icalrequeststatus stat)
{
int i;
for (i=0; request_status_map[i].kind != ICAL_UNKNOWN_STATUS; i++) {
if ( request_status_map[i].kind == stat) {
return request_status_map[i].str;
}
}
return 0;
}
short icalenum_reqstat_major(icalrequeststatus stat)
{
int i;
for (i=0; request_status_map[i].kind != ICAL_UNKNOWN_STATUS; i++) {
if ( request_status_map[i].kind == stat) {
return request_status_map[i].major;
}
}
return -1;
}
short icalenum_reqstat_minor(icalrequeststatus stat)
{
int i;
for (i=0; request_status_map[i].kind != ICAL_UNKNOWN_STATUS; i++) {
if ( request_status_map[i].kind == stat) {
return request_status_map[i].minor;
}
}
return -1;
}
icalrequeststatus icalenum_num_to_reqstat(short major, short minor)
{
int i;
for (i=0; request_status_map[i].kind != ICAL_UNKNOWN_STATUS; i++) {
if ( request_status_map[i].major == major && request_status_map[i].minor == minor) {
return request_status_map[i].kind;
}
}
return 0;
}
--- NEW FILE: icaltypes.h ---
/* -*- Mode: C -*- */
/*======================================================================
FILE: icaltypes.h
CREATOR: eric 20 March 1999
(C) COPYRIGHT 2000, Eric Busboom, http://www.softwarestudio.org
This program is free software; you can redistribute it and/or modify
it under the terms of either:
The LGPL as published by the Free Software Foundation, version
2.1, available at: http://www.fsf.org/copyleft/lesser.html
Or:
The Mozilla Public License Version 1.0. You may obtain a copy of
the License at http://www.mozilla.org/MPL/
The original code is icaltypes.h
======================================================================*/
#ifndef ICALTYPES_H
#define ICALTYPES_H
#include <time.h>
#include "icalenums.h"
#include "icaltime.h"
#include "icalduration.h"
#include "icalperiod.h"
/* This type type should probably be an opaque type... */
struct icalattachtype
{
void* binary;
int owns_binary;
char* base64;
int owns_base64;
char* url;
int refcount;
};
/* converts base64 to binary, fetches url and stores as binary, or
just returns data */
struct icalattachtype* icalattachtype_new(void);
void icalattachtype_add_reference(struct icalattachtype* v);
void icalattachtype_free(struct icalattachtype* v);
void icalattachtype_set_url(struct icalattachtype* v, char* url);
char* icalattachtype_get_url(struct icalattachtype* v);
void icalattachtype_set_base64(struct icalattachtype* v, char* base64,
int owns);
char* icalattachtype_get_base64(struct icalattachtype* v);
void icalattachtype_set_binary(struct icalattachtype* v, char* binary,
int owns);
void* icalattachtype_get_binary(struct icalattachtype* v);
struct icalgeotype
{
float lat;
float lon;
};
struct icaldatetimeperiodtype
{
struct icaltimetype time;
struct icalperiodtype period;
};
struct icaltriggertype
{
struct icaltimetype time;
struct icaldurationtype duration;
};
struct icaltriggertype icaltriggertype_from_string(const char* str);
/* struct icalreqstattype. This struct contains two string pointers,
but don't try to free either of them. The "desc" string is a pointer
to a static table inside the library. Don't try to free it. The
"debug" string is a pointer into the string that the called passed
into to icalreqstattype_from_string. Don't try to free it either, and
don't use it after the original string has been freed.
BTW, you would get that original string from
*icalproperty_get_requeststatus() or icalvalue_get_text(), when
operating on a the value of a request_status property. */
struct icalreqstattype {
icalrequeststatus code;
const char* desc;
const char* debug;
};
struct icalreqstattype icalreqstattype_from_string(char* str);
char* icalreqstattype_as_string(struct icalreqstattype);
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 */
More information about the Commits
mailing list